pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/sensorsim/renderer.py

@@ -0,0 +1,47 @@
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+from abc import ABC, abstractmethod
+from pathlib import Path
+import numpy as np
+from pyvale.sensorsim.renderscene import RenderScene
+
+# NOTE: This module is a feature under developement.
+
+class IRenderer(ABC):
+    @abstractmethod
+    def render(self,
+               scene: RenderScene,
+               cam_ind: int = 0,
+               frame_ind: int = 0,
+               field_ind: int = 0) -> np.ndarray:
+        pass
+
+    @abstractmethod
+    def render_to_disk(self,
+                       scene: RenderScene,
+                       cam_ind: int = 0,
+                       frame_ind: int = 0,
+                       field_ind: int = 0,
+                       save_path: Path | None = None,
+                       ) -> None:
+        pass
+
+    @abstractmethod
+    def render_all(self, scene: RenderScene) -> list[np.ndarray]:
+        pass
+
+    @abstractmethod
+    def render_all_to_disk(self,
+                          scene: RenderScene,
+                          save_path: Path | None = None) -> None:
+        pass
+
+
+
+
+
+
+

pyvale/sensorsim/rendermesh.py

@@ -0,0 +1,137 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+NOTE: this module is a feature under developement.
+"""
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+import pyvale.mooseherder as mh
+from pyvale.sensorsim.fieldconverter import simdata_to_pyvista_interp
+from pyvale.sensorsim.enums import EDim
+
+# TODO:
+# - Store the render field keys and match them between meshes?
+
+
+class RenderMesh:
+    __slots__ = ("coords","connectivity","fields_render","fields_disp",
+                 "pos_world","rot_world","node_count","elem_count",
+                 "nodes_per_elem","mesh_to_world_mat","world_to_mesh_mat")
+
+    def __init__(self,
+                 coords: np.ndarray,
+                 connectivity: np.ndarray,
+                 fields_render: np.ndarray,
+                 fields_disp: np.ndarray | None = None,
+                 pos_world: np.ndarray | None = None,
+                 rot_world: Rotation | None = None) -> None:
+
+        self.coords = coords
+        self.connectivity = connectivity
+        self.fields_render = fields_render
+        self.fields_disp = fields_disp
+
+        self.node_count = self.coords.shape[0]
+        self.elem_count = self.connectivity.shape[0]
+        self.nodes_per_elem = self.connectivity.shape[1]
+
+        if pos_world is None:
+            self.pos_world = np.array((0.0,0.0,0.0),dtype=np.float64)
+
+        if rot_world is None:
+            self.rot_world = Rotation.from_euler("zyx",(0.0,0.0,0.0),degrees=True)
+
+        self.mesh_to_world_mat = np.zeros((4,4),dtype=np.float64)
+        self.world_to_mesh_mat = np.zeros((4,4),dtype=np.float64)
+        self._build_transform_mats()
+
+    def _build_transform_mats(self) -> None:
+        self.mesh_to_world_mat = np.zeros((4,4))
+        self.mesh_to_world_mat[0:3,0:3] = self.rot_world.as_matrix()
+        self.mesh_to_world_mat[-1,-1] = 1.0
+        self.mesh_to_world_mat[0:3,-1] = self.pos_world
+        self.world_to_mesh_mat = np.linalg.inv(self.mesh_to_world_mat)
+
+    def set_pos(self, pos_world: np.ndarray) -> None:
+        self.pos_world = pos_world
+        self._build_transform_mats()
+
+    def set_rot(self, rot_world: Rotation) -> None:
+        self.rot_world = rot_world
+        self._build_transform_mats()
+
+
+
+def create_render_mesh(sim_data: mh.SimData,
+                       field_render_keys: tuple[str,...],
+                       sim_spat_dim: EDim,
+                       field_disp_keys: tuple[str,...] | None = None,
+                       pos_world: np.ndarray | None  = None,
+                       rot_world: Rotation | None = None
+                       ) -> RenderMesh:
+
+    extract_keys = field_render_keys
+    if field_disp_keys is not None:
+        extract_keys = field_render_keys+field_disp_keys
+
+    pv_grid = simdata_to_pyvista_interp(sim_data,
+                                        extract_keys,
+                                        spatial_dims=sim_spat_dim)
+
+    pv_surf = pv_grid.extract_surface()
+    faces = np.array(pv_surf.faces)
+
+    first_elem_nodes_per_face = faces[0]
+    nodes_per_face_vec = faces[0::(first_elem_nodes_per_face+1)]
+
+    # TODO: CHECKS
+    # - Number of displacement keys match the spat_dim parameter
+    assert np.all(nodes_per_face_vec == first_elem_nodes_per_face), \
+    "Not all elements in the simdata object have the same number of nodes per element"
+
+    nodes_per_face = first_elem_nodes_per_face
+    num_faces = int(faces.shape[0] / (nodes_per_face+1))
+
+    # Reshape the faces table and slice off the first column which is just the
+    # number of nodes per element and should be the same for all elements
+    connectivity = np.reshape(faces,(num_faces,nodes_per_face+1))
+    # shape=(num_elems,nodes_per_elem), C format
+    connectivity = np.ascontiguousarray(connectivity[:,1:],dtype=np.uintp)
+
+    # shape=(num_nodes,3), C format
+    coords_world = np.array(pv_surf.points)
+
+    # Add w coord=1, shape=(num_nodes,3+1)
+    coords_world= np.hstack((coords_world,np.ones([coords_world.shape[0],1])))
+
+    # shape=(num_nodes,num_time_steps,num_components)
+    field_render_shape = np.array(pv_surf[field_render_keys[0]]).shape
+    fields_render_by_node = np.zeros(field_render_shape+(len(field_render_keys),),
+                                     dtype=np.float64)
+    for ii,cc in enumerate(field_render_keys):
+        fields_render_by_node[:,:,ii] = np.ascontiguousarray(
+            np.array(pv_surf[cc]))
+
+
+    field_disp_by_node = None
+    if field_disp_keys is not None:
+        field_disp_shape = np.array(pv_surf[field_disp_keys[0]]).shape
+        # shape=(num_nodes,num_time_steps,num_components)
+        field_disp_by_node = np.zeros(field_disp_shape+(len(field_disp_keys),),
+                                       dtype=np.float64)
+        for ii,cc in enumerate(field_disp_keys):
+            field_disp_by_node[:,:,ii] = np.ascontiguousarray(
+                np.array(pv_surf[cc]))
+
+    return RenderMesh(coords=coords_world,
+                          connectivity=connectivity,
+                          fields_render=fields_render_by_node,
+                          fields_disp=field_disp_by_node,
+                          pos_world=pos_world,
+                          rot_world=rot_world)
+

pyvale/sensorsim/renderscene.py

@@ -0,0 +1,51 @@
+
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+import numpy as np
+from pyvale.sensorsim.cameradata import CameraData
+from pyvale.sensorsim.rendermesh import RenderMesh
+
+#===============================================================================
+# TODO
+# - How do we match render fields between meshes?
+# - How do we check displacement fields are the same between meshes?
+# - Eventually this will need to take render times and do the field interpolations
+# - Check all render meshes to see if any are deformable
+
+
+class RenderScene:
+    __slots__ = ("cameras","meshes")
+
+    def __init__(self,
+                 cameras: list[CameraData] | None = None,
+                 meshes: list[RenderMesh] | None = None,
+                 ) -> None:
+        if cameras is None:
+            self.cameras = []
+        else:
+            self.cameras = cameras
+
+        if meshes is None:
+            self.meshes = []
+        else:
+            self.meshes = meshes
+
+    def is_deformable(self) -> bool:
+        for mm in self.meshes:
+            if mm.fields_disp is not None:
+                return True
+
+        return False
+
+def get_all_coords_world(meshes: list[RenderMesh]) -> np.ndarray:
+    coords_all = []
+    for mm in meshes:
+        coords_all.append(np.matmul(mm.coords,mm.mesh_to_world_mat.T))
+
+    return np.vstack(coords_all)
+
+
+

pyvale/sensorsim/sensorarray.py

@@ -0,0 +1,178 @@
+# ==============================================================================
+# 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.sensorsim.field import IField
+
+
+#TODO: when cameras, line, area and volume sensors are implemented this will 
+# need to be refactored. 
+class ISensorArray(ABC):
+    """Interface (abstract base class) for an array of sensors of the same
+    type sampling a given physical field.
+
+    This class implements the `pyvale` sensor measurement simulation model. Here
+    a measurement is taken as: measurement = truth + random errors + systematic
+    errors. The truth value for each sensor is interpolated from the physical
+    field (an implementation of the `IField` interface, nominally a
+    `FieldScalar`, `FieldVector` or `FieldTensor` object).
+
+    The random and systematic errors are calculated by a user specified error
+    integrator (`ErrIntegrator` class). This class contains a chain of different
+    types of user selected errors (implementations of the `IErrSimulator`
+    interface). Further information can be found in the `ErrIntegrator` class
+    and in implementations of the `IErrSimulator` interface.
+
+    In `pyvale`, function and methods with `calc` in their name will cause
+    probability distributions to be resampled and any additional calculations,
+    such as interpolation, to be performed. Functions and methods with `get` in
+    the name will directly return the previously calculated values without
+    resampling probability distributions.
+
+    Calling the class method `sim_measurements()` will create and return an
+    array of simulated sensor measurements with the following shape=(num_sensors
+    ,num_field_component,num_time_steps). When calling `sim_measurements()` all
+    sensor errors that are based on probability distributions are resampled and
+    any required interpolations are performed (e.g. a random perturbation of the
+    sensor positions requiring interpolation at the perturbed sensor location).
+
+    Calling the class method `get_measurements()` just returns the previously
+    calculated set of sensor measurements without resampling of probability.
+    Distributions.
+
+    Without an error integrator this class can be used for interpolating
+    simulated physical fields quickly using finite element shape functions.
+    """
+
+    @abstractmethod
+    def get_measurement_shape(self) -> tuple[int,int,int]:
+        """Abstract method. Gets the shape of the measurement array:
+        shape=(num_sensors,num_field_components,num_time_steps).
+
+        The number of sensors is specified by the user with a SensorData object.
+        The number of field components is dependent on the field being sampled
+        (i.e. 1 for a scalar field and 3 for a vector field in 3D). The number
+        of time steps is specified by the user in the SensorData object or
+        defaults to the time steps taken from the simulation.
+
+        Returns
+        -------
+        tuple[int,int,int]
+            Shape of the measurement array as (num_sensors,
+            num_field_components,num_time_steps)
+        """
+        pass
+
+    @abstractmethod
+    def get_field(self) -> IField:
+        """Abstract method. Gets the field object that this array of sensors is
+        sampling to simulate measurements.
+
+        Returns
+        -------
+        IField
+            A field object interface.
+        """
+        pass
+
+    @abstractmethod
+    def get_truth(self) -> np.ndarray:
+        """Abstract method. Gets the ground truth sensor values that were
+        calculated previously. If the ground truth values have not been
+        calculated then `calc_truth()` is called first.
+
+        Returns
+        -------
+        np.ndarray
+            Array of ground truth sensor values. shape=(num_sensors,
+            num_field_components,num_time_steps).
+        """
+        pass
+
+    @abstractmethod
+    def get_errors_systematic(self) -> np.ndarray | None:
+        """Abstract method. Gets the systematic error array from the previously
+        calculated sensor measurements. Returns None is no error integrator has
+        been specified.
+
+        Returns
+        -------
+        np.ndarray | None
+            Array of systematic errors for this sensor array. shape=(num_sensors
+            ,num_field_components,num_time_steps). Returns None if no error
+            integrator has been set.
+        """
+        pass
+
+    @abstractmethod
+    def get_errors_random(self) -> np.ndarray | None:
+        """Abstract method. Gets the random error array from the previously
+        calculated sensor measurements. Returns None is no error integrator has
+        been specified.
+
+        Returns
+        -------
+        np.ndarray | None
+            Array of random errors for this sensor array. shape=(num_sensors
+            ,num_field_components,num_time_steps). Returns None if no error
+            integrator has been set.
+        """
+        pass
+
+    @abstractmethod
+    def get_errors_total(self) -> np.ndarray | None:
+        """Abstract method. Gets the total error array from the previously
+        calculated sensor measurements. Returns None is no error integrator has
+        been specified.
+
+        Returns
+        -------
+        np.ndarray | None
+            Array of total errors for this sensor array. shape=(num_sensors
+            ,num_field_components,num_time_steps). Returns None if no error
+            integrator has been set.
+        """
+        pass
+
+    @abstractmethod
+    def sim_measurements(self) -> np.ndarray:
+        """Abstract method. Calculates measurements as: measurement = truth +
+        systematic errors + random errors. The truth is calculated once and is
+        interpolated from the input simulation field. The errors are calculated
+        based on the user specified error chain.
+
+        NOTE: this is a 'sim' method and will sample all probability
+        distributions in the error chain returning a new simulated experiment
+        for this sensor array.
+
+        Returns
+        -------
+        np.ndarray
+            The calculated measurements for this sensor array with shape:
+            (num_sensors,num_field_components,num_time_steps)
+        """
+        pass
+
+    @abstractmethod
+    def get_measurements(self) -> np.ndarray:
+        """Abstract method. Returns the current set of simulated measurements if
+        theses have been calculated. If these have not been calculated then
+        'sim_measurements()' is called and a set of measurements in then
+        returned.
+
+        NOTE: this is a 'get' method and does not sample from probability
+        distributions in the error chain and directly returns the current set of
+        measurements if they exist.
+
+        Returns
+        -------
+        np.ndarray
+            The calculated measurements for this sensor array with shape:
+            (num_sensors,num_field_components,num_time_steps)
+        """
+        pass
+

pyvale/sensorsim/sensordata.py

@@ -0,0 +1,74 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from dataclasses import dataclass
+import numpy as np
+from scipy.spatial.transform import Rotation
+from pyvale.sensorsim.integratortype import EIntSpatialType
+
+
+@dataclass(slots=True)
+class SensorData:
+    """Data class used for specifying sensor array parameters including:
+    position, sample times, angles (for vector/tensor fields), spatial averaging
+    and spatial dimensions of the sensor for spatial averaging. The number of
+    sensor positions specified determines the number of sensors in the array.
+    """
+
+    positions: np.ndarray | None = None
+    """Numpy array of sensor positions where each row is for an individual
+    sensor and the columns specify the X, Y and Z coordinates respectively. To
+    create a sensor array the positions must be specified and the number of rows
+    of the position array determines the number of sensors in the array.
+
+    Should only be None if this is representing perturbed sensor positions and
+    the sensors are not being perturbed.
+
+    shape=(num_sensors,3)
+    """
+
+    sample_times: np.ndarray | None = None
+    """Numpy array of times at which the sensors will take measurements (sample
+    the field). This does not need to be specified to create a sensor array and
+    if it is set to None then the sample times will be assumed to be the same as
+    the simulation time steps.
+
+    shape=(num_time_steps,)
+    """
+
+    angles: tuple[Rotation,...] | None = None
+    """The angles for each sensor in the array specified using scipy Rotation
+    objects. For scalar fields the rotation only has an effect if a spatial
+    averager is specified and the locations of the integration points are
+    rotated. For vector and tensor fields the field is transformed using this
+    rotation as well as rotating the positions of the integration points if a
+    spatial averager is specified.
+
+    Specifying a single rotation in the tuple will cause all sensors to have the
+    same rotation and they will be batch processed increasing speed. Otherwise
+    this tuple must have a length equal to the number of sensors (i.e. the
+    number of rows in the position array above).
+
+    shape=(num_sensor,) or (1,)
+    """
+
+    spatial_averager: EIntSpatialType | None = None
+    """Type of spatial averaging to use for this sensor array. If None then no
+    spatial averaging is performed and sensor values are taken directly from the
+    specified positions.
+    """
+
+    spatial_dims: np.ndarray | None = None
+    """The spatial dimension of the sensor array in its local X,Y,Z coordinates.
+    Only used if spatial averager is specified above.
+
+    shape=(3,)
+    """
+
+
+
+
+