pyvale 2025.7.2__cp311-cp311-macosx_14_0_arm64.whl → 2025.8.1__cp311-cp311-macosx_14_0_arm64.whl

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

@@ -7,11 +7,12 @@
 import numpy as np
 import pyvista as pv
 from scipy.spatial.transform import Rotation
-import mooseherder as mh
+import pyvale.mooseherder as mh
 
-from pyvale.field import IField
-from pyvale.fieldconverter import simdata_to_pyvista
-from pyvale.fieldsampler import sample_pyvista_grid
+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
 
 
 class FieldScalar(IField):
@@ -20,8 +21,8 @@ class FieldScalar(IField):
 
     Implements the `IField` interface.
     """
-    __slots__ = ("_field_key","_elem_dims","_sim_data","_pyvista_grid",
-                 "_pyvista_vis")
+    __slots__ = ("_field_key","_elem_dims","_sim_data","_interpolator",
+                 "_visualiser")
 
     def __init__(self,
                  sim_data: mh.SimData,
@@ -36,18 +37,20 @@ class FieldScalar(IField):
             String key for the scalar field component in the `SimData` object.
         elem_dims : int
             Number of spatial dimensions (2 or 3) used for identifying element
-            types.
+            types. If point cloud data then set to the number of dimensions of
+            the problem as 2D triangulation is much faster than 3D.
         """
 
         self._field_key = field_key
         self._elem_dims = elem_dims
 
-        self._sim_data = sim_data
-        (self._pyvista_grid,self._pyvista_vis) = simdata_to_pyvista(
-            self._sim_data,
-            (self._field_key,),
-            self._elem_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:
         """Sets the `SimData` object that will be interpolated to obtain sensor
@@ -60,12 +63,17 @@ class FieldScalar(IField):
             Mooseherder SimData object. Contains a mesh and a simulated
             physical field.
         """
+
         self._sim_data = sim_data
-        (self._pyvista_grid,self._pyvista_vis) = simdata_to_pyvista(
-            sim_data,
-            (self._field_key,),
-            self._elem_dims
-        )
+
+        self._visualiser = simdata_to_pyvista_vis(sim_data,
+                                                  self._elem_dims)
+        if self._sim_data.connect is None:
+            self._interpolator = None #FieldInterpPoints()
+        else:
+            self._interpolator = FieldInterpMesh(self._sim_data,
+                                                 (self._field_key,),
+                                                 self._elem_dims)
 
     def get_sim_data(self) -> mh.SimData:
         """Gets the simulation data object associated with this field. Used by
@@ -99,7 +107,7 @@ class FieldScalar(IField):
             Pyvista unstructured grid object containing only a mesh without any
             physical field data attached.
         """
-        return self._pyvista_vis
+        return self._visualiser
 
     def get_all_components(self) -> tuple[str, ...]:
         """Gets the string key for the component of the physical field. A scalar
@@ -158,9 +166,5 @@ class FieldScalar(IField):
             An array of sampled (interpolated) values with the following
             dimensions: shape=(num_points,num_components,num_time_steps).
         """
-        return sample_pyvista_grid((self._field_key,),
-                                self._pyvista_grid,
-                                self._sim_data.time,
-                                points,
-                                times)
+        return self._interpolator.interp_field(points,times)
 

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

@@ -7,15 +7,18 @@
 import numpy as np
 import pyvista as pv
 from scipy.spatial.transform import Rotation
-import mooseherder as mh
-
-from pyvale.field import IField
-from pyvale.fieldconverter import simdata_to_pyvista
-from pyvale.fieldsampler import sample_pyvista_grid
-from pyvale.fieldtransform import (transform_tensor_2d,
-                                   transform_tensor_2d_batch,
-                                   transform_tensor_3d,
-                                   transform_tensor_3d_batch)
+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)
 
 # TODO:
 # - Checking to ensure normal and dev components are consistent
@@ -26,7 +29,7 @@ class FieldTensor(IField):
 
     Implements the `IField` interface.
     """
-    __slots__ = ("_field_key","_spat_dims","_time_steps","_pyvista_grid",
+    __slots__ = ("_field_key","_elem_dims","_time_steps","_interpolator",
                  "_norm_components","_dev_components")
 
     def __init__(self,
@@ -52,14 +55,13 @@ class FieldTensor(IField):
         self._field_key = field_name
         self._norm_components = norm_comps
         self._dev_components = dev_comps
-        self._spat_dims = elem_dims
-
+        self._elem_dims = elem_dims
         self._sim_data = sim_data
-        (self._pyvista_grid,self._pyvista_vis) = simdata_to_pyvista(
-            self._sim_data,
-            self._norm_components+self._dev_components,
-            self._spat_dims
-        )
+        self._visualiser = None
+        self._interpolator = None
+
+        self.set_sim_data(sim_data)
+
 
     def set_sim_data(self, sim_data: mh.SimData) -> None:
         """Sets the `SimData` object that will be interpolated to obtain sensor
@@ -73,11 +75,16 @@ class FieldTensor(IField):
             physical field.
         """
         self._sim_data = sim_data
-        (self._pyvista_grid,self._pyvista_vis) = simdata_to_pyvista(
-            sim_data,
-            self._norm_components+self._dev_components,
-            self._spat_dims
-        )
+        self._visualiser = simdata_to_pyvista_vis(sim_data,self._elem_dims)
+
+        if self._sim_data.connect is None:
+            self._interpolator = None #FieldInterpPoints()
+        else:
+            self._interpolator = FieldInterpMesh(self._sim_data,
+                                                 self._norm_components
+                                                 + self._dev_components,
+                                                 self._elem_dims)
+
 
     def get_sim_data(self) -> mh.SimData:
         """Gets the simulation data object associated with this field. Used by
@@ -111,7 +118,7 @@ class FieldTensor(IField):
             Pyvista unstructured grid object containing only a mesh without any
             physical field data attached.
         """
-        return self._pyvista_vis
+        return self._visualiser
 
     def get_all_components(self) -> tuple[str, ...]:
         """Gets the string keys for the component of the physical field. For
@@ -172,11 +179,7 @@ class FieldTensor(IField):
             An array of sampled (interpolated) values with the following
             dimensions: shape=(num_points,num_components,num_time_steps).
         """
-        field_data =  sample_pyvista_grid(self._norm_components+self._dev_components,
-                                    self._pyvista_grid,
-                                    self._sim_data.time,
-                                    points,
-                                    times)
+        field_data = self._interpolator.interp_field(points,times)
 
         if angles is None:
             return field_data
@@ -187,14 +190,13 @@ class FieldTensor(IField):
         # 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._spat_dims == 2:
+            if self._elem_dims == 2:
                 rmat = rmat[:2,:2]
                 field_data = transform_tensor_2d_batch(rmat,field_data)
             else:
@@ -202,7 +204,7 @@ class FieldTensor(IField):
 
         else: #  Need to rotate each sensor using individual rotation = loop :(
             #TODO: assumes 2D in the x-y plane
-            if self._spat_dims == 2:
+            if self._elem_dims == 2:
                 for ii,rr in enumerate(angles):
                     rmat = rr.as_matrix().T
                     rmat = rmat[:2,:2]

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

@@ -7,15 +7,17 @@
 import numpy as np
 import pyvista as pv
 from scipy.spatial.transform import Rotation
-import mooseherder as mh
-
-from pyvale.field import IField
-from pyvale.fieldconverter import simdata_to_pyvista
-from pyvale.fieldsampler import sample_pyvista_grid
-from pyvale.fieldtransform import (transform_vector_2d,
-                                        transform_vector_2d_batch,
-                                        transform_vector_3d,
-                                        transform_vector_3d_batch)
+import pyvale.mooseherder as mh
+
+from pyvale.sensorsim.field import IField
+from pyvale.sensorsim.fieldconverter import (simdata_to_pyvista_interp,
+                                   simdata_to_pyvista_vis)
+from pyvale.sensorsim.fieldinterpmesh import FieldInterpMesh
+from pyvale.sensorsim.fieldinterppoints import FieldInterpPoints
+from pyvale.sensorsim.fieldtransform import (transform_vector_2d,
+                                   transform_vector_2d_batch,
+                                   transform_vector_3d,
+                                   transform_vector_3d_batch)
 
 class FieldVector(IField):
     """Class for sampling (interpolating) vector fields from simulations to
@@ -23,8 +25,8 @@ class FieldVector(IField):
 
     Implements the `IField` interface.
     """
-    __slots__ = ("_field_key","_components","_spat_dims","_sim_data",
-                 "_pyvista_grid","_pyvista_vis")
+    __slots__ = ("_field_key","_components","_elem_dims","_sim_data",
+                 "_interpolator","_visualiser")
 
     def __init__(self,
                  sim_data: mh.SimData,
@@ -47,14 +49,14 @@ class FieldVector(IField):
         """
         self._field_key = field_key
         self._components = components
-        self._spat_dims = elem_dims
+        self._elem_dims = elem_dims
 
-        self._sim_data = sim_data
-        (self._pyvista_grid,self._pyvista_vis) = simdata_to_pyvista(
-            self._sim_data,
-            self._components,
-            self._spat_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._interpolator = None
+        self._visualiser = None
+        self.set_sim_data(sim_data)
 
     def set_sim_data(self, sim_data: mh.SimData) -> None:
         """Sets the `SimData` object that will be interpolated to obtain sensor
@@ -68,11 +70,15 @@ class FieldVector(IField):
             physical field.
         """
         self._sim_data = sim_data
-        (self._pyvista_grid,self._pyvista_vis) = simdata_to_pyvista(
-            sim_data,
-            self._components,
-            self._spat_dims
-        )
+        
+        self._visualiser = simdata_to_pyvista_vis(sim_data,
+                                                  self._elem_dims)
+        if self._sim_data.connect is None:
+            self._interpolator = None #FieldInterpPoints()
+        else:
+            self._interpolator = FieldInterpMesh(self._sim_data,
+                                                 self._components,
+                                                 self._elem_dims)
 
     def get_sim_data(self) -> mh.SimData:
         """Gets the simulation data object associated with this field. Used by
@@ -106,7 +112,7 @@ class FieldVector(IField):
             Pyvista unstructured grid object containing only a mesh without any
             physical field data attached.
         """
-        return self._pyvista_vis
+        return self._visualiser
 
     def get_all_components(self) -> tuple[str, ...]:
         """Gets the string keys for the component of the physical field. For
@@ -168,11 +174,7 @@ class FieldVector(IField):
             dimensions: shape=(num_points,num_components,num_time_steps).
         """
 
-        field_data = sample_pyvista_grid(self._components,
-                                self._pyvista_grid,
-                                self._sim_data.time,
-                                points,
-                                times)
+        field_data = self._interpolator.interp_field(points,times)
 
         if angles is None:
             return field_data
@@ -189,7 +191,7 @@ class FieldVector(IField):
             rmat = angles[0].as_matrix().T
 
             #TODO: assumes 2D in the x-y plane
-            if self._spat_dims == 2:
+            if self._elem_dims == 2:
                 rmat = rmat[:2,:2]
                 field_data = transform_vector_2d_batch(rmat,field_data)
             else:
@@ -197,7 +199,7 @@ class FieldVector(IField):
 
         else: # Need to rotate each sensor using individual rotation = loop :(
             #TODO: assumes 2D in the x-y plane
-            if self._spat_dims == 2:
+            if self._elem_dims == 2:
                 for ii,rr in enumerate(angles):
                     rmat = rr.as_matrix().T
                     rmat = rmat[:2,:2]

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

@@ -8,6 +8,9 @@
 NOTE: This module is a feature under developement.
 """
 
+# TODO
+# - Update deformation functions to use pyvista a
+
 import time
 import warnings
 from dataclasses import dataclass
@@ -17,10 +20,10 @@ from scipy.interpolate import griddata
 from scipy.interpolate import RectBivariateSpline
 from scipy import ndimage
 
-from pyvale.rasternp import edge_function, RasterNP
-from pyvale.cameradata2d import CameraData2D
-from pyvale.cameratools import CameraTools
-from pyvale.imagetools import ImageTools
+from pyvale.sensorsim.rasternp import edge_function, RasterNP
+from pyvale.sensorsim.cameradata2d import CameraData2D
+from pyvale.sensorsim.cameratools import CameraTools
+from pyvale.sensorsim.imagetools import ImageTools
 
 
 @dataclass(slots=True)
@@ -180,7 +183,7 @@ class ImageDef2D:
             edge_check = np.zeros_like(edge,dtype=np.int8)
             edge_check[edge >= 0.0] = 1
             edge_check = np.sum(edge_check, axis=0)
-            # Create a mask with the check, TODO check the 3 here for non triangles
+            # Create a mask with the check
             edge_mask_flat = edge_check == num_edges
             edge_mask_grid = np.reshape(edge_mask_flat,bound_coords_grid_shape)
 
@@ -536,6 +539,7 @@ def _deform_image_mask(def_image: np.ndarray,
                        ) -> tuple[np.ndarray,np.ndarray]:
 
     # This is slow - might be quicker to just deform an upsampled mask
+    # TODO: use cython image averaging it is way faster!
     px_disp_x = CameraTools.average_subpixel_image(subpx_disp_x,
                                                    cam_data.subsample)
     px_disp_y = CameraTools.average_subpixel_image(subpx_disp_y,

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

@@ -5,12 +5,12 @@
 # ==============================================================================
 
 import numpy as np
-from pyvale.field import IField
-from pyvale.sensordata import SensorData
-from pyvale.integratorspatial import IIntegratorSpatial
-from pyvale.integratortype import EIntSpatialType
-from pyvale.integratorrectangle import Rectangle2D
-from pyvale.integratorquadrature import (Quadrature2D,
+from pyvale.sensorsim.field import IField
+from pyvale.sensorsim.sensordata import SensorData
+from pyvale.sensorsim.integratorspatial import IIntegratorSpatial
+from pyvale.sensorsim.integratortype import EIntSpatialType
+from pyvale.sensorsim.integratorrectangle import Rectangle2D
+from pyvale.sensorsim.integratorquadrature import (Quadrature2D,
                                               create_gauss_weights_2d_4pts,
                                               create_gauss_weights_2d_9pts)
 

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

@@ -6,10 +6,10 @@
 
 from typing import Callable
 import numpy as np
-from pyvale.field import IField
-from pyvale.integratorspatial import (IIntegratorSpatial,
+from pyvale.sensorsim.field import IField
+from pyvale.sensorsim.integratorspatial import (IIntegratorSpatial,
                                       create_int_pt_array)
-from pyvale.sensordata import SensorData
+from pyvale.sensorsim.sensordata import SensorData
 
 
 class Quadrature2D(IIntegratorSpatial):

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

@@ -5,10 +5,10 @@
 # ==============================================================================
 
 import numpy as np
-from pyvale.field import IField
-from pyvale.integratorspatial import (IIntegratorSpatial,
+from pyvale.sensorsim.field import IField
+from pyvale.sensorsim.integratorspatial import (IIntegratorSpatial,
                                            create_int_pt_array)
-from pyvale.sensordata import SensorData
+from pyvale.sensorsim.sensordata import SensorData
 
 #NOTE: code below is very similar to quadrature integrator should be able to
 # refactor into injected classes/functions

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

@@ -6,7 +6,7 @@
 
 from abc import ABC, abstractmethod
 import numpy as np
-from pyvale.sensordata import SensorData
+from pyvale.sensorsim.sensordata import SensorData
 
 
 def create_int_pt_array(sens_data: SensorData,

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

@@ -11,11 +11,11 @@ NOTE: this module is a feature under developement.
 from pathlib import Path
 from multiprocessing.pool import Pool
 import numpy as np
-from pyvale.cameradata import CameraData
-from pyvale.rendermesh import RenderMesh
-from pyvale.renderer import IRenderer
-from pyvale.rasteropts import RasterOpts
-import pyvale.cython.rastercyth as rastercyth
+from pyvale.sensorsim.cameradata import CameraData
+from pyvale.sensorsim.rendermesh import RenderMesh
+from pyvale.sensorsim.renderer import IRenderer
+from pyvale.sensorsim.rasteropts import RasterOpts
+import pyvale.sensorsim.cython.rastercyth as rastercyth
 
 # NOTE: This module is a feature under developement.
 

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

@@ -14,15 +14,15 @@ from multiprocessing.pool import Pool
 import numpy as np
 import numba
 #import matplotlib.pyplot as plt
-from pyvale.dataset import DataSet
-from pyvale.cameradata import CameraData
-from pyvale.cameratools import CameraTools
-from pyvale.rendermesh import RenderMesh
-from pyvale.renderer import IRenderer, RenderScene
-from pyvale.rasteropts import RasterOpts, save_raster
-from pyvale.imagetools import ImageTools
-#from pyvale.visualimages import plot_field_image
-import pyvale.cython.rastercyth as rastercyth
+import pyvale.dataset as dataset
+from pyvale.sensorsim.cameradata import CameraData
+from pyvale.sensorsim.cameratools import CameraTools
+from pyvale.sensorsim.rendermesh import RenderMesh
+from pyvale.sensorsim.renderer import IRenderer, RenderScene
+from pyvale.sensorsim.rasteropts import RasterOpts, save_raster
+from pyvale.sensorsim.imagetools import ImageTools
+#from pyvale.sensorsim.visualimages import plot_field_image
+import pyvale.sensorsim.cython.rastercyth as rastercyth
 
 
 # NOTE: This module is a feature under developement.

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

@@ -6,7 +6,7 @@
 from pathlib import Path
 from dataclasses import dataclass
 import numpy as np
-from pyvale.imagetools import EImageType, ImageTools
+from pyvale.sensorsim.imagetools import EImageType, ImageTools
 
 
 @dataclass(slots=True)

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

@@ -6,7 +6,7 @@
 from abc import ABC, abstractmethod
 from pathlib import Path
 import numpy as np
-from pyvale.renderscene import RenderScene
+from pyvale.sensorsim.renderscene import RenderScene
 
 # NOTE: This module is a feature under developement.
 

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

@@ -10,8 +10,8 @@ NOTE: this module is a feature under developement.
 
 import numpy as np
 from scipy.spatial.transform import Rotation
-import mooseherder as mh
-from pyvale.fieldconverter import simdata_to_pyvista
+import pyvale.mooseherder as mh
+from pyvale.sensorsim.fieldconverter import simdata_to_pyvista_interp
 
 
 # TODO:
@@ -79,9 +79,9 @@ def create_render_mesh(sim_data: mh.SimData,
     if field_disp_keys is not None:
         extract_keys = field_render_keys+field_disp_keys
 
-    (pv_grid,_) = simdata_to_pyvista(sim_data,
-                                     extract_keys,
-                                     elem_dims=sim_spat_dim)
+    pv_grid = simdata_to_pyvista_interp(sim_data,
+                                            extract_keys,
+                                            elem_dims=sim_spat_dim)
 
     pv_surf = pv_grid.extract_surface()
     faces = np.array(pv_surf.faces)

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

@@ -5,8 +5,8 @@
 # Copyright (C) 2025 The Computer Aided Validation Team
 #===============================================================================
 import numpy as np
-from pyvale.cameradata import CameraData
-from pyvale.rendermesh import RenderMesh
+from pyvale.sensorsim.cameradata import CameraData
+from pyvale.sensorsim.rendermesh import RenderMesh
 
 #===============================================================================
 # TODO

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

@@ -6,7 +6,7 @@
 
 from abc import ABC, abstractmethod
 import numpy as np
-from pyvale.field import IField
+from pyvale.sensorsim.field import IField
 
 
 class ISensorArray(ABC):

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

@@ -6,18 +6,18 @@
 
 import numpy as np
 
-import mooseherder as mh
-
-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)
+import pyvale.mooseherder as mh
+
+from pyvale.sensorsim.fieldscalar import FieldScalar
+from pyvale.sensorsim.fieldvector import FieldVector
+from pyvale.sensorsim.fieldtensor import FieldTensor
+from pyvale.sensorsim.sensordescriptor import SensorDescriptorFactory
+from pyvale.sensorsim.sensorarraypoint import SensorArrayPoint, SensorData
+from pyvale.sensorsim.errorintegrator import ErrIntegrator
+from pyvale.sensorsim.errorsysindep import ErrSysUnifPercent
+from pyvale.sensorsim.errorrand import ErrRandNormPercent
+from pyvale.sensorsim.errorsysdep import (ErrSysDigitisation,
+                                ErrSysSaturation)
 
 # TODO:
 # - docstrings

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

@@ -5,12 +5,12 @@
 # ==============================================================================
 
 import numpy as np
-from pyvale.field import IField
-from pyvale.sensorarray import ISensorArray
-from pyvale.errorintegrator import ErrIntegrator
-from pyvale.sensordescriptor import SensorDescriptor
-from pyvale.sensordata import SensorData
-from pyvale.fieldsampler import sample_field_with_sensor_data
+from pyvale.sensorsim.field import IField
+from pyvale.sensorsim.sensorarray import ISensorArray
+from pyvale.sensorsim.errorintegrator import ErrIntegrator
+from pyvale.sensorsim.sensordescriptor import SensorDescriptor
+from pyvale.sensorsim.sensordata import SensorData
+from pyvale.sensorsim.fieldsampler import sample_field_with_sensor_data
 
 
 class SensorArrayPoint(ISensorArray):
@@ -159,15 +159,17 @@ class SensorArrayPoint(ISensorArray):
 
         return self._truth
 
-    def set_error_integrator(self, err_int: ErrIntegrator) -> None:
+    def set_error_integrator(self, err_int: ErrIntegrator | None) -> None:
         """Sets the error intergrator that will be used to calculate the sensor
         array measurement errors when `calc_measurements()` is called. See the
         `ErrIntegrator` class for further detail.
 
         Parameters
         ----------
-        err_int : ErrIntegrator
+        err_int : ErrIntegrator | None
             Error integration object with a chain of user defined sensor errors.
+            If None then no errors are calculated and the sensor performs pure
+            interpolation of the input fields.
         """
         self._error_integrator = err_int
 

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

@@ -7,7 +7,7 @@
 from dataclasses import dataclass
 import numpy as np
 from scipy.spatial.transform import Rotation
-from pyvale.integratortype import EIntSpatialType
+from pyvale.sensorsim.integratortype import EIntSpatialType
 
 
 @dataclass(slots=True)