pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/sensorsim/fieldinterp.py

@@ -0,0 +1,89 @@
+# ==============================================================================
+# 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 IFieldInterp(ABC):
+    """Interface (abstract base class) for allowing different methods of field
+    interpolation. Nominally this includes mesh-based and mesh-free
+    interpolation methods.
+    """
+
+    @abstractmethod
+    def interp_field(self,
+                    points: np.ndarray,
+                    sample_times: np.ndarray | None = None,
+                    ) -> np.ndarray:
+        """Invokes the field interpolation algorithm at the given points and 
+        sample times. Spatial interpolation is performed first at existing data 
+        time steps. If the sample times are the same as the underlying data no 
+        temporal interpolation is performed otherwise linear interpolation is 
+        performed between time steps for each point in space.
+
+        Parameters
+        ----------
+        points : np.ndarray
+            Array of points to spatially interpolate the physical field to.
+        sample_times : np.ndarray | None, optional
+            Vector of times at which to sample the underlying physical field,
+            by default None. If this is None then no temporal interpolation is
+            performed and the points returned correspond to the input simulation
+            time steps.
+
+        Returns
+        -------
+        np.ndarray
+            Simulated measurement array intepolated from the simulation data to
+            the desired sensor locations and sample times with shape=(
+            num_sensors,num_field_components,num_sample_times).
+        """
+        pass
+
+
+def interp_to_sample_time(sample_at_sim_time: np.ndarray,
+                          sim_time_steps: np.ndarray,
+                          sample_times: np.ndarray,
+                          ) -> np.ndarray:
+    """Helper function for linear temporal interpolation of simulation data.
+    Assumes the input data has already been interpolated to the desired spatial
+    locations and then performs temporal interpolation linearly based o the
+    specified sample times.
+
+    Parameters
+    ----------
+    sample_at_sim_time : np.ndarray
+        Array of simulated measurement points that have been spatially
+        interpolated to the desired location. Has the same shape as standard
+        measurement array, shape=(num_sensors,num_field_components,
+        num_sim_time_steps)
+    sim_time_steps : np.ndarray
+        Vector of simulation time steps which should have the same length as the
+        last axis of the `sample_at_sim_time` array above.
+    sample_times : np.ndarray
+        Vector of times at which to sample by linearly interpolating between
+        simulation time steps.
+
+    Returns
+    -------
+    np.ndarray
+        Simulated measurement array with shape=(num_sensors,num_field_components
+        ,num_sample_times)
+    """
+    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,119 @@
+# ==============================================================================
+# 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 (IFieldInterp,
+                                          interp_to_sample_time)
+from pyvale.sensorsim.enums import EDim
+
+
+class FieldInterpMesh(IFieldInterp):
+    """Class for interpolating mesh-based simulation fields to the virtual
+    sensor locations and sample times. Note that mesh-based data includes a
+    connectivity table in the underlying `SimData` object.
+
+    Implements the `IFieldInterp` interface.
+    """
+
+    __slots__ = ("_sim_time_steps","_comp_keys","_pyvista_interp")
+
+    def __init__(self,
+                 sim_data: mh.SimData,
+                 comp_keys: tuple[str,...],
+                 spatial_dims: EDim,
+                 ) -> None:
+        """
+        Parameters
+        ----------
+        sim_data : mh.SimData
+            Simulation data object containing the physical field(s) that the
+            virtual sensors will sample.
+        comp_keys : tuple[str,...]
+            Tuple of string keys for the components of the field(s) to be
+            interpolated.
+        spatial_dims : EDim
+            Enumeration used to determine the number of spatial dimensions of
+            the simulation to determine the underlying element types in the
+            mesh.
+        """
+        self._sim_time_steps = sim_data.time
+        self._comp_keys = comp_keys
+        self._pyvista_interp = simdata_to_pyvista_interp(sim_data,
+                                                         self._comp_keys,
+                                                         spatial_dims)
+
+    def interp_field(self,
+                     points: np.ndarray,
+                     sample_times: np.ndarray | None = None,
+                     ) -> np.ndarray:
+        return sample_pyvista_grid(self._comp_keys,
+                                   self._pyvista_interp,
+                                   self._sim_time_steps,
+                                   points,
+                                   sample_times)
+
+
+def sample_pyvista_grid(comp_keys: 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
+    ----------
+    comp_keys : tuple[str,...]
+        String keys for the comp_keys to be sampled in the pyvista grid object.
+        Useful for only interpolating the field comp_keys of interest for speed
+        and memory reduction.
+    pyvista_interp : pv.UnstructuredGrid
+        Pyvista grid object containing the simulation mesh and the comp_keys 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_comp_keys,num_time_steps).
+    """
+    pv_points = pv.PolyData(points)
+    sample_data = pv_points.sample(pyvista_interp)
+
+    n_comps = len(comp_keys)
+    (n_sensors,n_time_steps) = np.array(sample_data[comp_keys[0]]).shape
+    sample_at_sim_time = np.empty((n_sensors,n_comps,n_time_steps))
+
+    for ii,cc in enumerate(comp_keys):
+        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,93 @@
+# ==============================================================================
+# 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
+import pyvale.mooseherder as mh
+from pyvale.sensorsim.simtools import (coords_to_2D)
+from pyvale.sensorsim.fieldinterp import (IFieldInterp,
+                                          interp_to_sample_time)
+from pyvale.sensorsim.enums import EDim
+
+
+class FieldInterpPoints(IFieldInterp):
+    """Class for interpolating mesh-free simulation fields to the virtual
+    sensor locations and sample times.
+
+    Implements the `IFieldInterp` interface.
+    """
+    __slots__ = ("_sim_time_steps", "_comp_keys","_spatial_dims",
+                 "_interp_funcs","_coords")
+
+    def __init__(self,
+                 sim_data: mh.SimData,
+                 comp_keys: tuple[str,...],
+                 spatial_dims: EDim,
+                 ) -> None:
+        """
+        Parameters
+        ----------
+        sim_data : mh.SimData
+            Simulation data object containing the physical field(s) that the
+            virtual sensors will sample.
+        comp_keys : tuple[str,...]
+            Tuple of string keys for the components of the field(s) to be
+            interpolated.
+        spatial_dims : EDim
+            Enumeration used to determine the number of spatial dimensions of
+            the simulation to determine the underlying element types in the
+            mesh.
+        """
+        self._sim_time_steps = sim_data.time
+        self._comp_keys = comp_keys
+        self._spatial_dims = spatial_dims
+
+        # Collapse problem to 2D
+        self._coords = sim_data.coords
+        if self._spatial_dims == EDim.TWOD:
+            self._coords = coords_to_2D(self._coords)
+
+        # We do this once instead of inside the loop to save a lot of time as
+        # the coordinates don't change between frames
+        triang = Delaunay(self._coords)
+
+        self._interp_funcs = {}
+        for cc in self._comp_keys:
+            interp_frames = []
+            for tt in range(self._sim_time_steps.shape[0]):
+                interp = LinearNDInterpolator(triang,
+                                              sim_data.node_vars[cc][:,tt])
+                interp_frames.append(interp)
+
+            self._interp_funcs[cc] = interp_frames
+
+
+    def interp_field(self,
+                    points: np.ndarray,
+                    sample_times: np.ndarray | None = None,
+                    ) -> np.ndarray:
+        if self._spatial_dims == EDim.TWOD:
+            points = coords_to_2D(points)
+
+        n_points = points.shape[0]
+        n_comps = len(self._comp_keys)
+        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,cc in enumerate(self._comp_keys):
+            for tt in range(self._sim_time_steps.shape[0]):
+                interp_func = self._interp_funcs[cc][tt]
+                sample_at_sim_time[:,ii,tt] = interp_func(points)
+
+        if sample_times is None:
+            return sample_at_sim_time
+
+        return interp_to_sample_time(sample_at_sim_time,
+                                     self._sim_time_steps,
+                                     sample_times)
+

pyvale/sensorsim/fieldsampler.py

@@ -0,0 +1,110 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import numpy as np
+import pyvista as pv
+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
+                                  ) -> np.ndarray:
+    """Samples (interpolates) an `IField` object using the parameters specified
+    in the `SensorData` object.
+
+    Parameters
+    ----------
+    field : IField
+        The simulated physical field that the sensors will samples from. This is
+        normally a `FieldScalar`, `FieldVector` or `FieldTensor`.
+    sensor_data : SensorData
+        Contains sensor array parameters including: number of sensors, positions
+        and sample times. See the `SensorData` class for more information.
+
+    Returns
+    -------
+    np.ndarray
+        Array of sampled sensor measurements with shape=(num_sensors,
+        num_field_components,num_time_steps).
+    """
+    if sensor_data.spatial_averager is None:
+        return field.sample_field(sensor_data.positions,
+                                  sensor_data.sample_times,
+                                  sensor_data.angles)
+
+    spatial_integrator = build_spatial_averager(field,sensor_data)
+    return spatial_integrator.calc_averages()
+
+
+def sample_pyvista_grid(components: tuple[str,...],
+                        pyvista_grid: 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_grid : 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_grid)
+
+    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
+
+    def sample_time_interp(x):
+        return np.interp(sample_times, sim_time_steps, x)
+
+    n_time_steps = sample_times.shape[0]
+    sample_at_spec_time = np.empty((n_sensors,n_comps,n_time_steps))
+
+    for ii,cc in enumerate(components):
+        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/fieldscalar.py

@@ -0,0 +1,94 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import numpy as np
+import pyvista as pv
+from scipy.spatial.transform import Rotation
+import pyvale.mooseherder as mh
+
+from pyvale.sensorsim.field import IField
+from pyvale.sensorsim.fieldconverter import simdata_to_pyvista_vis
+from pyvale.sensorsim.fieldinterpmesh import FieldInterpMesh
+from pyvale.sensorsim.fieldinterppoints import FieldInterpPoints
+from pyvale.sensorsim.enums import EDim
+
+class FieldScalar(IField):
+    """Class for sampling (interpolating) scalar fields from simulations to
+    provide sensor values at specified locations and times. Supports 
+    interpolation of mesh-based data (with a connectivity table) and point 
+    clouds.
+
+    Implements the `IField` interface.
+    """
+    __slots__ = ("_comp_key","_spatial_dims","_sim_data","_interpolator",
+                 "_visualiser")
+
+    def __init__(self,
+                 sim_data: mh.SimData,
+                 comp_key: str,
+                 spatial_dims: EDim) -> None:
+        """
+        Parameters
+        ----------
+        sim_data : mh.SimData
+            Simulation data object containing the mesh and field to interpolate.
+        comp_key : str
+            String key for the scalar field component in the `SimData` nodal
+            variables dictionary.
+        spatial_dims : EDim
+            Number of spatial dimensions (TWOD or THREED) used for identifying 
+            element types. If point cloud data then set to the number of 
+            dimensions of the problem as 2D triangulation is much faster than 
+            3D.
+        """
+
+        self._comp_key = comp_key
+        self._spatial_dims = spatial_dims
+
+        # NOTE: these get set in the function call to `set_sim_data` - this is
+        # separated out to allow inserting a new simdata object
+        self._sim_data =  None
+        self._visualiser = None
+        self._interpolator = None
+        self.set_sim_data(sim_data)
+
+
+    def set_sim_data(self, sim_data: mh.SimData) -> None:
+        self._sim_data = sim_data
+
+        self._visualiser = simdata_to_pyvista_vis(sim_data,
+                                                  self._spatial_dims)
+        if self._sim_data.connect is None:
+            self._interpolator = FieldInterpPoints(self._sim_data,
+                                                   (self._comp_key,),
+                                                   self._spatial_dims)
+        else:
+            self._interpolator = FieldInterpMesh(self._sim_data,
+                                                 (self._comp_key,),
+                                                 self._spatial_dims)
+
+    def get_sim_data(self) -> mh.SimData:
+        return self._sim_data
+
+    def get_time_steps(self) -> np.ndarray:
+        return self._sim_data.time
+
+    def get_visualiser(self) -> pv.UnstructuredGrid:
+        return self._visualiser
+
+    def get_all_components(self) -> tuple[str, ...]:
+        return (self._comp_key,)
+
+    def get_component_index(self, comp_key: str) -> int:
+        return 0 # scalar fields only have one component!
+
+    def sample_field(self,
+                    points: np.ndarray,
+                    times: np.ndarray | None = None,
+                    angles: tuple[Rotation,...] | None = None,
+                    ) -> np.ndarray:
+        return self._interpolator.interp_field(points,times)
+

pyvale/sensorsim/fieldtensor.py

@@ -0,0 +1,150 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import numpy as np
+import pyvista as pv
+from scipy.spatial.transform import Rotation
+import pyvale.mooseherder as mh
+
+from pyvale.sensorsim.field import IField
+from pyvale.sensorsim.fieldconverter import (simdata_to_pyvista_vis,
+                                            simdata_to_pyvista_interp)
+from pyvale.sensorsim.fieldinterpmesh import FieldInterpMesh
+from pyvale.sensorsim.fieldinterppoints import FieldInterpPoints
+#TODO: cythonise these transformations
+from pyvale.sensorsim.fieldtransform import (transform_tensor_2d,
+                                            transform_tensor_2d_batch,
+                                            transform_tensor_3d,
+                                            transform_tensor_3d_batch)
+from pyvale.sensorsim.enums import EDim
+
+# TODO:
+# - Checking to ensure normal and dev components are consistent
+
+class FieldTensor(IField):
+    """Class for sampling (interpolating) tensor fields from simulations to
+    provide sensor values at specified locations and times. Supports 
+    interpolation of mesh-based data (with a connectivity table) and point 
+    clouds.
+
+    Implements the `IField` interface.
+    """
+    __slots__ = ("_norm_comp_keys","_dev_comp_keys","_spatial_dims","_sim_data",
+                 "_visualiser","_interpolator")
+
+    def __init__(self,
+                 sim_data: mh.SimData,
+                 norm_comp_keys: tuple[str,...],
+                 dev_comp_keys: tuple[str,...],
+                 spatial_dims: EDim) -> None:
+        """
+        Parameters
+        ----------
+        sim_data : mh.SimData
+            Simulation data object containing the mesh and field to interpolate.
+        norm_comp_keys : tuple[str,...]
+            String keys for the tensor normal field components in the `SimData` 
+            nodal variables dictionary. For example ('stain_xx','strain_yy',) 
+            for strain in 2D and ('strain_xx','strain_yy','strain_zz') in 3D.
+        norm_dev_keys : tuple[str,...]
+            String keys for the tensor deviatoric field components in the 
+            `SimData` nodal variables dictionary. For example ('stain_xy',) 
+            for strain in 2D and ('strain_xy','strain_xz','strain_yz') in 3D.
+        spatial_dims : EDim
+            Number of spatial dimensions (TWOD or THREED) used for identifying 
+            element types. If point cloud data then set to the number of 
+            dimensions of the problem as 2D triangulation is much faster than 
+            3D.
+        """
+        self._norm_comp_keys = norm_comp_keys
+        self._dev_comp_keys = dev_comp_keys
+        self._spatial_dims = spatial_dims
+
+        # NOTE: these get set in the function call to `set_sim_data` - this is
+        # separated out to allow inserting a new simdata object
+        self._sim_data = None
+        self._visualiser = None
+        self._interpolator = None
+        self.set_sim_data(sim_data)
+
+
+    def set_sim_data(self, sim_data: mh.SimData) -> None:
+        self._sim_data = sim_data
+        self._visualiser = simdata_to_pyvista_vis(sim_data,self._spatial_dims)
+
+        if self._sim_data.connect is None:
+            self._interpolator = FieldInterpPoints(self._sim_data,
+                                                   self._norm_comp_keys
+                                                   + self._dev_comp_keys,
+                                                   self._spatial_dims)
+        else:
+            self._interpolator = FieldInterpMesh(self._sim_data,
+                                                 self._norm_comp_keys
+                                                 + self._dev_comp_keys,
+                                                 self._spatial_dims)
+
+
+    def get_sim_data(self) -> mh.SimData:
+        return self._sim_data
+
+    def get_time_steps(self) -> np.ndarray:
+        return self._sim_data.time
+
+    def get_visualiser(self) -> pv.UnstructuredGrid:
+        return self._visualiser
+
+    def get_all_components(self) -> tuple[str, ...]:
+        return self._norm_comp_keys + self._dev_comp_keys
+
+    def get_component_index(self, comp_key: str) -> int:
+        return self.get_all_components().index(comp_key)
+
+    def sample_field(self,
+                    points: np.ndarray,
+                    times: np.ndarray | None = None,
+                    angles: tuple[Rotation,...] | None = None,
+                    ) -> np.ndarray:
+        field_data = self._interpolator.interp_field(points,times)
+
+        if angles is None:
+            return field_data
+
+        # NOTE:
+        # ROTATION= object rotates with coords fixed
+        # For Z rotation: sin negative in row 1.
+        # TRANSFORMATION= coords rotate with object fixed
+        # For Z transformation: sin negative in row 2, transpose scipy mat.
+
+        # If we only have one angle we assume all sensors have the same angle
+        # and we can batch process the rotations
+        if len(angles) == 1:
+            rmat = angles[0].as_matrix().T
+
+            #TODO: assumes 2D in the x-y plane
+            if self._spatial_dims == EDim.TWOD:
+                rmat = rmat[:2,:2]
+                field_data = transform_tensor_2d_batch(rmat,field_data)
+            else:
+                field_data = transform_tensor_3d_batch(rmat,field_data)
+
+        else: #  Need to rotate each sensor using individual rotation = loop :(
+            #TODO: assumes 2D in the x-y plane
+            if self._spatial_dims == EDim.TWOD:
+                for ii,rr in enumerate(angles):
+                    rmat = rr.as_matrix().T
+                    rmat = rmat[:2,:2]
+                    field_data[ii,:,:] = transform_tensor_2d(rmat,
+                                                             field_data[ii,:,:])
+
+            else:
+                for ii,rr in enumerate(angles):
+                    rmat = rr.as_matrix().T
+                    field_data[ii,:,:] = transform_tensor_3d(rmat,
+                                                             field_data[ii,:,:])
+
+
+        return field_data
+