pyvale 2025.7.1__cp311-cp311-win_amd64.whl → 2025.8.1__cp311-cp311-win_amd64.whl

pyvale/{cython → sensorsim/cython}/rastercyth.py

@@ -12,7 +12,7 @@ import numpy as np
 import cython
 #from cython.parallel import prange, parallel, threadid
 from cython.cimports.libc.math import floor, ceil
-from pyvale.cameradata import CameraData
+from pyvale.sensorsim.cameradata import CameraData
 
 # NOTE: This module is a feature under developement.
 
@@ -382,23 +382,22 @@ def raster_static_frame(coords: cython.double[:,:],
 
 
     #---------------------------------------------------------------------------
-
     elems_in_image: cython.size_t = _raster_frame(coords[:,:],
-                                                connect[:,:],
-                                                fields_to_render[:,:],
-                                                world_to_cam_mat[:,:],
-                                                pixels_num[:],
-                                                image_dims[:],
-                                                image_dist,
-                                                sub_samp,
-                                                image_buff_avg[:,:,:],
-                                                depth_buff_avg[:,:],
-                                                image_buff_subpx[:,:,:],
-                                                depth_buff_subpx[:,:],
-                                                nodes_raster_buff[:,:],
-                                                field_raster_buff[:],
-                                                px_coord_buff[:],
-                                                weights_buff[:])
+                                                  connect[:,:],
+                                                  fields_to_render[:,:],
+                                                  world_to_cam_mat[:,:],
+                                                  pixels_num[:],
+                                                  image_dims[:],
+                                                  image_dist,
+                                                  sub_samp,
+                                                  image_buff_avg[:,:,:],
+                                                  depth_buff_avg[:,:],
+                                                  image_buff_subpx[:,:,:],
+                                                  depth_buff_subpx[:,:],
+                                                  nodes_raster_buff[:,:],
+                                                  field_raster_buff[:],
+                                                  px_coord_buff[:],
+                                                  weights_buff[:])
 
     return (image_buff_avg_np,depth_buff_avg_np,elems_in_image)
 

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

@@ -7,7 +7,7 @@
 import enum
 from abc import ABC, abstractmethod
 import numpy as np
-from pyvale.sensordata import SensorData
+from pyvale.sensorsim.sensordata import SensorData
 
 
 class EErrType(enum.Enum):

pyvale/{errorintegrator.py → sensorsim/errorintegrator.py}

@@ -7,10 +7,10 @@
 import copy
 from dataclasses import dataclass
 import numpy as np
-from pyvale.errorcalculator import (IErrCalculator,
+from pyvale.sensorsim.errorcalculator import (IErrCalculator,
                                     EErrType,
                                     EErrDep)
-from pyvale.sensordata import SensorData
+from pyvale.sensorsim.sensordata import SensorData
 
 
 @dataclass(slots=True)

pyvale/{errorrand.py → sensorsim/errorrand.py}

@@ -5,11 +5,11 @@
 # ==============================================================================
 
 import numpy as np
-from pyvale.sensordata import SensorData
-from pyvale.errorcalculator import (IErrCalculator,
+from pyvale.sensorsim.sensordata import SensorData
+from pyvale.sensorsim.errorcalculator import (IErrCalculator,
                                          EErrType,
                                          EErrDep)
-from pyvale.generatorsrandom import IGenRandom
+from pyvale.sensorsim.generatorsrandom import IGenRandom
 
 
 class ErrRandUnif(IErrCalculator):
@@ -428,7 +428,7 @@ class ErrRandNormPercent(IErrCalculator):
         return (err_basis*self._std*norm_rand,sens_data)
 
 
-class ErrRandGenerator(IErrCalculator):
+class ErrRandGen(IErrCalculator):
     """Sensor random error calculator based on sampling a user specified random
     number generator implementing the `IGeneratorRandom` interface.
 

pyvale/{errorsyscalib.py → sensorsim/errorsyscalib.py}

@@ -6,10 +6,10 @@
 
 from typing import Callable
 import numpy as np
-from pyvale.errorcalculator import (IErrCalculator,
+from pyvale.sensorsim.errorcalculator import (IErrCalculator,
                                          EErrType,
                                          EErrDep)
-from pyvale.sensordata import SensorData
+from pyvale.sensorsim.sensordata import SensorData
 
 # TODO: add option to use Newton's method for function inversion instead of a
 # cal table.

pyvale/{errorsysdep.py → sensorsim/errorsysdep.py}

@@ -7,8 +7,8 @@
 import enum
 from typing import Callable
 import numpy as np
-from pyvale.sensordata import SensorData
-from pyvale.errorcalculator import (IErrCalculator,
+from pyvale.sensorsim.sensordata import SensorData
+from pyvale.sensorsim.errorcalculator import (IErrCalculator,
                                          EErrType,
                                          EErrDep)
 

pyvale/{errorsysfield.py → sensorsim/errorsysfield.py}

@@ -9,15 +9,15 @@ from dataclasses import dataclass
 import numpy as np
 from scipy.spatial.transform import Rotation
 
-from pyvale.field import IField
-from pyvale.fieldsampler import sample_field_with_sensor_data
-from pyvale.sensordata import SensorData
-from pyvale.integratortype import EIntSpatialType
-from pyvale.errorcalculator import (IErrCalculator,
+from pyvale.sensorsim.field import IField
+from pyvale.sensorsim.fieldsampler import sample_field_with_sensor_data
+from pyvale.sensorsim.sensordata import SensorData
+from pyvale.sensorsim.integratortype import EIntSpatialType
+from pyvale.sensorsim.errorcalculator import (IErrCalculator,
                                     EErrType,
                                     EErrDep)
-from pyvale.errordriftcalc import IDriftCalculator
-from pyvale.generatorsrandom import IGenRandom
+from pyvale.sensorsim.errordriftcalc import IDriftCalculator
+from pyvale.sensorsim.generatorsrandom import IGenRandom
 
 # TODO:
 # - Implement different perturbed sampling times for each sensor or allow all
@@ -402,7 +402,7 @@ def _perturb_sensor_angles(n_sensors: int,
             for jj,rand_ang in enumerate(rand_ang_zyx): # loop over components
                 if rand_ang is not None:
                     sensor_rot_angs[jj] = sensor_rot_angs[jj] + \
-                        rand_ang.generate(shape=1)
+                        rand_ang.generate(shape=(1,))[0]
 
         if angle_loc_zyx is not None:
             # No rotation about locked axes using mask

pyvale/{errorsysindep.py → sensorsim/errorsysindep.py}

@@ -5,11 +5,11 @@
 # ==============================================================================
 
 import numpy as np
-from pyvale.errorcalculator import (IErrCalculator,
+from pyvale.sensorsim.errorcalculator import (IErrCalculator,
                                          EErrType,
                                          EErrDep)
-from pyvale.generatorsrandom import IGenRandom
-from pyvale.sensordata import SensorData
+from pyvale.sensorsim.generatorsrandom import IGenRandom
+from pyvale.sensorsim.sensordata import SensorData
 
 
 class ErrSysOffset(IErrCalculator):

pyvale/sensorsim/exceptions.py

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

pyvale/{experimentsimulator.py → sensorsim/experimentsimulator.py}

@@ -11,8 +11,8 @@ of input simulation cases and sensor arrays.
 
 from dataclasses import dataclass
 import numpy as np
-import mooseherder as mh
-from pyvale.sensorarray import ISensorArray
+import pyvale.mooseherder as mh
+from pyvale.sensorsim.sensorarray import ISensorArray
 
 
 @dataclass(slots=True)
@@ -104,6 +104,26 @@ class ExperimentSimulator:
         self._exp_data = None
         self._exp_stats = None
 
+    def get_sim_list(self) -> list[mh.SimData]:
+        """Gets the list of simulations to run simulated experiments for.
+
+        Returns
+        -------
+        list[mh.SimData]
+            List of simulation data objects.
+        """
+        return self._sim_list
+
+    def get_sensor_arrays(self) -> list[ISensorArray]:
+        """Gets the sensor array list for this experiment.
+
+        Returns
+        -------
+        list[ISensorArray]
+            List of sensor arrays for the simulated experiment.
+        """
+        return self._sensor_arrays
+
     def run_experiments(self) -> list[np.ndarray]:
         """Runs the specified number of virtual experiments over the number of
         input simulation cases and virtual sensor arrays.
@@ -122,7 +142,7 @@ class ExperimentSimulator:
 
         for ii,aa in enumerate(self._sensor_arrays):
             meas_array = np.zeros((n_sims,self._num_exp_per_sim)+
-                                aa.get_measurement_shape())
+                                   aa.get_measurement_shape())
 
             for jj,ss in enumerate(self._sim_list):
                 aa.get_field().set_sim_data(ss)

pyvale/{field.py → sensorsim/field.py}

@@ -8,7 +8,7 @@ from abc import ABC, abstractmethod
 import numpy as np
 from scipy.spatial.transform import Rotation
 import pyvista as pv
-import mooseherder as mh
+import pyvale.mooseherder as mh
 
 
 class IField(ABC):

pyvale/{fieldconverter.py → sensorsim/fieldconverter.py}

@@ -12,14 +12,15 @@ compatible with the underlying machinery of pyvale.
 import numpy as np
 import pyvista as pv
 from pyvista import CellType
-import mooseherder as mh
+import pyvale.mooseherder as mh
 
-def simdata_to_pyvista(sim_data: mh.SimData,
-                        components: tuple[str,...] | None,
-                        elem_dims: int
-                        ) -> tuple[pv.UnstructuredGrid,pv.UnstructuredGrid]:
+
+def simdata_to_pyvista_interp(sim_data: mh.SimData,
+                              components: tuple[str,...] | None,
+                              elem_dims: int
+                              ) -> pv.UnstructuredGrid:
     """Converts the mesh and field data in a `SimData` object into a pyvista
-    UnstructuredGrid for sampling (interpolating) the data and visualisation.
+    UnstructuredGrid for interpolating the data.
 
     Parameters
     ----------
@@ -34,9 +35,67 @@ def simdata_to_pyvista(sim_data: mh.SimData,
 
     Returns
     -------
-    tuple[pv.UnstructuredGrid,pv.UnstructuredGrid]
-        The first UnstructuredGrid has the field components attached as dataset
-        arrays. The second has no field data attached for visualisation.
+    pv.UnstructuredGrid
+        As pyvista grid with attached field data to allow for interpolation on
+        the mesh using the element shape functions.
+    """
+
+    pv_grid = _gen_pyvista_grid(sim_data,elem_dims)
+
+    if components is not None and sim_data.node_vars is not None:
+        for cc in components:
+            pv_grid[cc] = sim_data.node_vars[cc]
+
+    return pv_grid
+
+
+def simdata_to_pyvista_vis(sim_data: mh.SimData,
+                           elem_dims: int
+                           ) -> pv.UnstructuredGrid | pv.PolyData:
+    """Converts the mesh and field data in a `SimData` object into a pyvista
+    UnstructuredGrid or PolyData object for visualisation.
+
+    Parameters
+    ----------
+    sim_data : mh.SimData
+        Object containing a mesh and associated field data from a simulation.
+    elem_dim : int
+        Number of spatial dimensions (2 or 3) used to determine the element
+        types in the mesh from the number of nodes per element. Set to the
+        dimensionality of the problem for point cloud data as 2D triangulation
+        will be much faster if possible.
+
+    Returns
+    -------
+    pv.UnstructuredGrid | pv.PolyData
+        A pyvista unstructured grid or poly data object that has no field data
+        attached for visualisation purposes.
+    """
+    if sim_data.connect is None:
+        return pv.PolyData(sim_data.coords)
+
+    return _gen_pyvista_grid(sim_data,elem_dims)
+
+
+
+def _gen_pyvista_grid(sim_data: mh.SimData,
+                      elem_dims: int) -> pv.UnstructuredGrid:
+    """Helper function for generating a blank pyvista unstructure grid mesh from
+    a SimData object.
+
+    Parameters
+    ----------
+    sim_data : mh.SimData
+        Object containing a mesh and associated field data from a simulation.
+    elem_dims : int
+        Number of spatial dimensions (2 or 3) used to determine the element
+        types in the mesh from the number of nodes per element.
+
+
+    Returns
+    -------
+    pv.UnstructuredGrid
+        A pyvista unstructured grid that has no field data attached.
     """
     flat_connect = np.array([],dtype=np.int64)
     cell_types = np.array([],dtype=np.int64)
@@ -65,13 +124,7 @@ def simdata_to_pyvista(sim_data: mh.SimData,
 
     points = sim_data.coords
     pv_grid = pv.UnstructuredGrid(cells, cell_types, points)
-    pv_grid_vis = pv.UnstructuredGrid(cells, cell_types, points)
-
-    if components is not None and sim_data.node_vars is not None:
-        for cc in components:
-            pv_grid[cc] = sim_data.node_vars[cc]
-
-    return (pv_grid,pv_grid_vis)
+    return pv_grid
 
 
 def scale_length_units(scale: float,
@@ -208,7 +261,7 @@ def extract_surf_mesh(sim_data: mh.SimData) -> mh.SimData:
 
     return face_data
 
-
+#TODO: make this support triangular prisms in 3D.
 def _get_pyvista_cell_type(nodes_per_elem: int, spat_dim: int) -> CellType | None:
     """Helper function to identify the pyvista element type in the mesh.
 
@@ -253,7 +306,7 @@ def _get_pyvista_cell_type(nodes_per_elem: int, spat_dim: int) -> CellType | Non
 
     return cell_type
 
-
+#TODO: make this support triangular prisms in 3D.
 def _exodus_to_pyvista_connect(cell_type: CellType,
                                connect: np.ndarray) -> np.ndarray:
     """Helper function that specifies the nodal winding map for higher order
@@ -290,7 +343,7 @@ def _exodus_to_pyvista_connect(cell_type: CellType,
 
     return connect
 
-
+#TODO: make this support triangular prisms in 3D.
 def _get_surf_map(nodes_per_elem: int) -> np.ndarray:
     """Helper function specifying the mapping from 3D tet and hex elements to
     the individual faces consistent with the exodus output format.

pyvale/sensorsim/fieldinterp.py

@@ -0,0 +1,37 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from abc import ABC, abstractmethod
+import numpy as np
+
+
+class FieldInterp(ABC):
+    @abstractmethod
+    def interp_field(self,
+                    points: np.ndarray,
+                    sample_times: np.ndarray | None = None,
+                    ) -> np.ndarray:
+        pass
+
+
+def interp_to_sample_time(sample_at_sim_time: np.ndarray,
+                          sim_time_steps: np.ndarray,
+                          sample_times: np.ndarray,
+                          ) -> np.ndarray:
+
+    def sample_time_interp(x):
+        return np.interp(sample_times, sim_time_steps, x)
+
+    n_time_steps = sample_times.shape[0]
+    n_sensors = sample_at_sim_time.shape[0]
+    n_comps = sample_at_sim_time.shape[1]
+    sample_at_spec_time = np.empty((n_sensors,n_comps,n_time_steps))
+
+    for ii in range(n_comps):
+        sample_at_spec_time[:,ii,:] = np.apply_along_axis(sample_time_interp,-1,
+                                                    sample_at_sim_time[:,ii,:])
+
+    return sample_at_spec_time

pyvale/sensorsim/fieldinterpmesh.py

@@ -0,0 +1,124 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+
+import numpy as np
+import pyvista as pv
+import pyvale.mooseherder as mh
+from pyvale.sensorsim.fieldconverter import simdata_to_pyvista_interp
+from pyvale.sensorsim.fieldinterp import (FieldInterp,
+                                          interp_to_sample_time)
+
+class FieldInterpMesh(FieldInterp):
+    """TODO
+    """
+
+    __slots__ = ("_sim_time_steps","_components","_pyvista_interp")
+
+    def __init__(self,
+                 sim_data: mh.SimData,
+                 components: tuple[str,...],
+                 elem_dims: int,
+                 ) -> None:
+        """
+        Parameters
+        ----------
+        sim_data : mh.SimData
+            _description_
+        components : tuple[str,...]
+            _description_
+        elem_dims : int
+            _description_
+        """
+        self._sim_time_steps = sim_data.time
+        self._components = components
+        self._pyvista_interp = simdata_to_pyvista_interp(sim_data,
+                                                         self._components,
+                                                         elem_dims=elem_dims)
+
+    def interp_field(self,
+                     points: np.ndarray,
+                     sample_times: np.ndarray | None = None,
+                     ) -> np.ndarray:
+        """_summary_
+
+        Parameters
+        ----------
+        points : np.ndarray
+            _description_
+        times : np.ndarray | None, optional
+            _description_, by default None
+
+        Returns
+        -------
+        np.ndarray
+            _description_
+        """
+        return sample_pyvista_grid(self._components,
+                                   self._pyvista_interp,
+                                   self._sim_time_steps,
+                                   points,
+                                   sample_times)
+
+
+def sample_pyvista_grid(components: tuple[str,...],
+                        pyvista_interp: pv.UnstructuredGrid,
+                        sim_time_steps: np.ndarray,
+                        points: np.ndarray,
+                        sample_times: np.ndarray | None = None
+                        ) -> np.ndarray:
+    """Function for sampling (interpolating) a pyvista grid object containing
+    simulated field data. The pyvista sample method uses VTK to perform the
+    spatial interpolation using the element shape functions. If the sampling
+    time steps are not the same as the simulation time then a linear
+    interpolation over time is performed using numpy.
+
+    NOTE: sampling outside the mesh bounds of the sample returns a value of 0.
+
+    Parameters
+    ----------
+    components : tuple[str,...]
+        String keys for the components to be sampled in the pyvista grid object.
+        Useful for only interpolating the field components of interest for speed
+        and memory reduction.
+    pyvista_interp : pv.UnstructuredGrid
+        Pyvista grid object containing the simulation mesh and the components of
+        the physical field that will be sampled.
+    sim_time_steps : np.ndarray
+        Simulation time steps corresponding to the fields in the pyvista grid
+        object.
+    points : np.ndarray
+        Coordinates of the points at which to sample the pyvista grid object.
+        shape=(num_points,3) where the columns are the X, Y and Z coordinates of
+        the sample points in simulation world coordintes.
+    sample_times : np.ndarray | None, optional
+        Array of time steps at which to sample the pyvista grid. If None then no
+        temporal interpolation is performed and the sample times are assumed to
+        be the simulation time steps.
+
+    Returns
+    -------
+    np.ndarray
+        Array of sampled sensor measurements with shape=(num_sensors,
+        num_field_components,num_time_steps).
+    """
+    pv_points = pv.PolyData(points)
+    sample_data = pv_points.sample(pyvista_interp)
+
+    n_comps = len(components)
+    (n_sensors,n_time_steps) = np.array(sample_data[components[0]]).shape
+    sample_at_sim_time = np.empty((n_sensors,n_comps,n_time_steps))
+
+    for ii,cc in enumerate(components):
+        sample_at_sim_time[:,ii,:] = np.array(sample_data[cc])
+
+    if sample_times is None:
+        return sample_at_sim_time
+
+    return interp_to_sample_time(sample_at_sim_time,
+                                 sim_time_steps,
+                                 sample_times)
+

pyvale/sensorsim/fieldinterppoints.py

@@ -0,0 +1,55 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import numpy as np
+from scipy.spatial import Delaunay
+from scipy.interpolate import LinearNDInterpolator
+from pyvale.sensorsim.fieldinterp import (FieldInterp,
+                                          interp_to_sample_time)
+
+class FieldInterpPoints(FieldInterp):
+
+    def __init__(self,
+                 coords: np.ndarray,
+                 sim_time_steps: np.ndarray,
+                 components: tuple[str,...],
+                 ) -> None:
+        pass
+        # self._coords = coords
+        # self._sim_time_steps = sim_time_steps
+        # self._components = components
+
+        # self._triangulation = Delaunay()
+        # self._interp_funcs = []
+
+        # for ii in range(self._sim_time_steps.shape[0]):
+        #     interp = LinearNDInterpolator(coords,)
+        #     self._interp_funcs.append(interp)
+
+
+    def interp_field(self,
+                    points: np.ndarray,
+                    sample_times: np.ndarray | None = None,
+                    ) -> np.ndarray:
+        pass
+        # n_points = points.shape[0]
+        # n_comps = len(self._components)
+        # n_sim_time = self._sim_time_steps.shape[0]
+        # sample_at_sim_time = np.empty((n_points,n_comps,n_sim_time),
+        #                               dtype=np.float64)
+
+        # for ii in range(self._sim_time_steps.shape[0]):
+
+        #     sample_at_sim_time[:,]
+
+
+
+        # if sample_times is None:
+        #     return sample_at_sim_time
+
+        # return interp_to_sample_time(sample_at_sim_time,
+        #                             sim_time_steps,
+        #                             sample_times)

pyvale/{fieldsampler.py → sensorsim/fieldsampler.py}

@@ -6,9 +6,9 @@
 
 import numpy as np
 import pyvista as pv
-from pyvale.field import IField
-from pyvale.sensordata import SensorData
-from pyvale.integratorfactory import build_spatial_averager
+from pyvale.sensorsim.field import IField
+from pyvale.sensorsim.sensordata import SensorData
+from pyvale.sensorsim.integratorfactory import build_spatial_averager
 
 
 def sample_field_with_sensor_data(field: IField, sensor_data: SensorData
@@ -40,7 +40,7 @@ def sample_field_with_sensor_data(field: IField, sensor_data: SensorData
     return spatial_integrator.calc_averages()
 
 
-# NOTE: sampling outside the bounds of the sample returns a value of 0
+# TODO: move this into the fieldinterpmesh object
 def sample_pyvista_grid(components: tuple[str,...],
                         pyvista_grid: pv.UnstructuredGrid,
                         sim_time_steps: np.ndarray,