pyvale 2025.4.0__py3-none-any.whl

pyvale/core/rendermesh.py

@@ -0,0 +1,156 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from enum import Enum
+from dataclasses import dataclass, field
+import numpy as np
+import mooseherder as mh
+from pyvale.core.fieldconverter import simdata_to_pyvista
+
+
+# class ImageFormat(Enum):
+#     NPY = 0
+#     TIFF = 1
+
+# @dataclass(slots=True)
+# class RenderOpts:
+#     image_tag: str = "image"
+#     image_formats: tuple[ImageFormat,...]
+#     bits_per_unit: int = 1
+#     parallel: int | None = None
+
+
+@dataclass(slots=True)
+class RenderMeshData:
+    coords: np.ndarray
+    connectivity: np.ndarray
+    fields_render: np.ndarray
+
+    # If this is None then the mesh is not deformable
+    fields_disp: np.ndarray | None = None
+
+    node_count: int = field(init=False)
+    elem_count: int = field(init=False)
+    nodes_per_elem: int = field(init=False)
+
+    coord_cent: np.ndarray = field(init=False)
+    coord_bound_min: np.ndarray = field(init=False)
+    coord_bound_max: np.ndarray = field(init=False)
+
+    def __post_init__(self) -> None:
+        # C format: num_nodes/num_elems first as it is the largest dimension
+        self.node_count = self.coords.shape[0]
+        self.elem_count = self.connectivity.shape[0]
+        self.nodes_per_elem = self.connectivity.shape[1]
+
+        self.coord_bound_min = np.min(self.coords,axis=0)
+        self.coord_bound_max = np.max(self.coords,axis=0)
+        self.coord_cent = (self.coord_bound_max + self.coord_bound_min)/2.0
+
+
+def create_render_mesh(sim_data: mh.SimData,
+                       field_render_keys: tuple[str,...],
+                       sim_spat_dim: int,
+                       field_disp_keys: tuple[str,...] | None = None,
+                       ) -> RenderMeshData:
+
+    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(sim_data,
+                                     extract_keys,
+                                     spat_dim=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 RenderMeshData(coords=coords_world,
+                          connectivity=connectivity,
+                          fields_render=fields_render_by_node,
+                          fields_disp=field_disp_by_node)
+
+
+def slice_mesh_data_by_elem(coords_world: np.ndarray,
+                            connectivity: np.ndarray,
+                            field_by_node: np.ndarray,
+                            ) -> tuple[np.ndarray,np.ndarray]:
+    """_summary_
+
+    Parameters
+    ----------
+    coords_world : np.ndarray
+        _description_
+    connectivity : np.ndarray
+        _description_
+    field_by_node : np.ndarray
+        _description_
+
+    Returns
+    -------
+    tuple[np.ndarray,np.ndarray]
+        _description_
+    """
+    # shape=(coord[X,Y,Z,W],node_per_elem,elem_num)
+    elem_world_coords = np.copy(coords_world[connectivity,:])
+
+    # shape=(elem_num,nodes_per_elem,coord[X,Y,Z,W]), C memory format
+    # elem_world_coords = np.ascontiguousarray(np.swapaxes(elem_world_coords,0,2))
+    elem_world_coords = np.ascontiguousarray(elem_world_coords)
+
+    # shape=(nodes_per_elem,elem_num,time_steps)
+    field_by_elem = np.copy(field_by_node[connectivity,:])
+
+    # shape=(elem_num,nodes_per_elem,time_steps), C memory format
+    # field_by_elem = np.ascontiguousarray(np.swapaxes(field_by_elem,0,1))
+    field_by_elem = np.ascontiguousarray(field_by_elem)
+
+    return (elem_world_coords,field_by_elem)

pyvale/core/sensorarray.py

@@ -0,0 +1,179 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from abc import ABC, abstractmethod
+import numpy as np
+from pyvale.core.field import IField
+
+
+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 `IErrCalculator`
+    interface). Further information can be found in the `ErrIntegrator` class
+    and in implementations of the `IErrCalculator` 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 `calc_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 `calc_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_values()` 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 calc_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 'calc' 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
+        'calc_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/core/sensorarrayfactory.py

@@ -0,0 +1,210 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+import numpy as np
+
+import mooseherder as mh
+
+from pyvale.core.fieldscalar import FieldScalar
+from pyvale.core.fieldvector import FieldVector
+from pyvale.core.fieldtensor import FieldTensor
+from pyvale.core.sensordescriptor import SensorDescriptorFactory
+from pyvale.core.sensorarraypoint import SensorArrayPoint, SensorData
+from pyvale.core.errorintegrator import ErrIntegrator
+from pyvale.core.errorsysindep import ErrSysUniformPercent
+from pyvale.core.errorrand import ErrRandNormPercent
+from pyvale.core.errorsysdep import (ErrSysDigitisation,
+                                     ErrSysSaturation)
+
+#TODO: Docstrings
+
+class SensorArrayFactory:
+    """Namespace for static methods used to build common types of sensor arrays
+    simplifying sensor array creation for users.
+    """
+
+    @staticmethod
+    def thermocouples_no_errs(sim_data: mh.SimData,
+                              sensor_data: SensorData,
+                              field_name: str = "temperature",
+                              spat_dims: int = 3,
+                              ) -> SensorArrayPoint:
+        """Builds and returns a point sensor array with common parameters used
+        for thermocouples applied to a temperature field without any simulated
+        measurement errors. Allows the user to build and attach their own error
+        chain or use this for fast interpolation to sensor locations without
+        errors.
+
+        Parameters
+        ----------
+        sim_data : mh.SimData
+            Simulation data containing a mesh and a temperature field for the
+            thermocouple array to sample.
+        sensor_data : SensorData
+            _description_
+        field_name : str, optional
+            _description_, by default "temperature"
+        spat_dims : int, optional
+            , by default 3
+
+        Returns
+        -------
+        SensorArrayPoint
+            _description_
+        """
+        descriptor = SensorDescriptorFactory.temperature_descriptor()
+
+        t_field = FieldScalar(sim_data,field_name,spat_dims)
+
+        sens_array = SensorArrayPoint(sensor_data,
+                                      t_field,
+                                      descriptor)
+
+        return sens_array
+
+    @staticmethod
+    def thermocouples_basic_errs(sim_data: mh.SimData,
+                                 sensor_data: SensorData,
+                                 field_name: str = "temperature",
+                                 spat_dims: int = 3,
+                                 errs_pc: float = 1.0
+                                 ) -> SensorArrayPoint:
+
+        sens_array = SensorArrayFactory.thermocouples_no_errs(sim_data,
+                                                              sensor_data,
+                                                              field_name,
+                                                              spat_dims)
+
+        err_int = basic_err_integrator(sens_array.get_measurement_shape(),
+                                       sensor_data,
+                                       errs_pc)
+
+        # Normal thermcouple amp = 5mV / K
+        err_int._err_chain.append(ErrSysDigitisation(bits_per_unit=2**16/1000))
+        err_int._err_chain.append(ErrSysSaturation(meas_min=0.0,meas_max=1000.0))
+
+        sens_array.set_error_integrator(err_int)
+        return sens_array
+
+    @staticmethod
+    def disp_sensors_no_errs(sim_data: mh.SimData,
+                            sensor_data: SensorData,
+                            field_name: str = "displacement",
+                            spat_dims: int = 3,
+                            ) -> SensorArrayPoint:
+
+        descriptor = SensorDescriptorFactory.displacement_descriptor()
+
+        disp_field = FieldVector(sim_data,
+                                 field_name,
+                                 ('disp_x','disp_y'),
+                                 spat_dims)
+
+        sens_array = SensorArrayPoint(sensor_data,
+                                      disp_field,
+                                      descriptor)
+        return sens_array
+
+
+    @staticmethod
+    def disp_sensors_basic_errs(sim_data: mh.SimData,
+                                sensor_data: SensorData,
+                                field_name: str = "displacement",
+                                spat_dims: int = 3,
+                                errs_pc: float = 1
+                                ) -> SensorArrayPoint:
+
+        sens_array = SensorArrayFactory.disp_sensors_no_errs(sim_data,
+                                                            sensor_data,
+                                                            field_name,
+                                                            spat_dims)
+        err_int = basic_err_integrator(sens_array.get_measurement_shape(),
+                                       sensor_data,
+                                       errs_pc)
+        sens_array.set_error_integrator(err_int)
+
+        return sens_array
+
+    @staticmethod
+    def strain_gauges_no_errs(sim_data: mh.SimData,
+                              sensor_data: SensorData,
+                              field_name: str = "strain",
+                              spat_dims: int = 3
+                              ) -> SensorArrayPoint:
+        descriptor = SensorDescriptorFactory.strain_descriptor(spat_dims)
+
+        if spat_dims == 2:
+            norm_components = ('strain_xx','strain_yy')
+            dev_components = ('strain_xy',)
+        else:
+            norm_components = ('strain_xx','strain_yy','strain_zz')
+            dev_components = ('strain_xy','strain_yz','strain_xz')
+
+        strain_field = FieldTensor(sim_data,
+                                 field_name,
+                                 norm_components,
+                                 dev_components,
+                                 spat_dims)
+
+        sens_array = SensorArrayPoint(sensor_data,
+                                      strain_field,
+                                      descriptor)
+
+        return sens_array
+
+
+    @staticmethod
+    def strain_gauges_basic_errs(sim_data: mh.SimData,
+                                sensor_data: SensorData,
+                                field_name: str = "strain",
+                                spat_dims: int = 3,
+                                errs_pc: float = 1.0
+                                ) -> SensorArrayPoint:
+
+        sens_array = SensorArrayFactory.strain_gauges_no_errs(sim_data,
+                                                              sensor_data,
+                                                              field_name,
+                                                              spat_dims)
+
+        err_int = basic_err_integrator(sens_array.get_measurement_shape(),
+                                       sensor_data,
+                                       errs_pc)
+        sens_array.set_error_integrator(err_int)
+
+        return sens_array
+
+
+def basic_err_integrator(meas_shape: np.ndarray,
+                         sensor_data: SensorData,
+                         sys_err_pc: float = 1.0,
+                         rand_err_pc: float = 1.0) -> ErrIntegrator:
+    """Builds a basic error integrator with uniform percentage systematic error
+    calculator and a percentage normal random error calculator.
+
+    Parameters
+    ----------
+    meas_shape : np.ndarray
+        Shape of the measurement array which is (num_sensors,
+        num_field_components,num_time_steps)
+    sensor_data : SensorData
+        Sensor array parameters for feeding through the error chain.
+    sys_err_pc : float, optional
+        Percentage systematic error, by default 1.0.
+    rand_err_pc : float, optional
+        Percentage random error, by default 1.0.
+
+    Returns
+    -------
+    ErrIntegrator
+        A basic error integrator with a uniform percentage systematic error and
+        a normal percentage random error.
+    """
+    err_chain = []
+    err_chain.append(ErrSysUniformPercent(-sys_err_pc,sys_err_pc))
+    err_chain.append(ErrRandNormPercent(rand_err_pc))
+    err_int = ErrIntegrator(err_chain,sensor_data,meas_shape)
+    return err_int