pyvale 2025.4.0__py3-none-any.whl

pyvale/__init__.py

@@ -0,0 +1,75 @@
+"""
+`pyvale`: the python validation engine. Used to simulate experimental data from
+an input multi-physics simulation by explicitly modelling sensors with realistic
+uncertainties. Useful for experimental design, sensor placement optimisation,
+testing simulation validation metrics and testing digital shadows/twins.
+"""
+
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+# NOTE: this simplifies and decouples how the user calls pyvale from the
+# underlying project structure: the user should be able to use 'pyvale.'
+# and access everything in one layer without multiple import dots
+
+from pyvale.core.dataset import *
+
+from pyvale.core.field import *
+from pyvale.core.fieldscalar import *
+from pyvale.core.fieldvector import *
+from pyvale.core.fieldtensor import *
+from pyvale.core.fieldconverter import *
+from pyvale.core.fieldtransform import *
+
+from pyvale.core.integratorspatial import *
+from pyvale.core.integratorquadrature import *
+from pyvale.core.integratorrectangle import *
+from pyvale.core.integratorfactory import *
+
+from pyvale.core.sensordescriptor import *
+from pyvale.core.sensortools import *
+from pyvale.core.sensorarray import *
+from pyvale.core.sensorarrayfactory import *
+from pyvale.core.sensorarraypoint import *
+from pyvale.core.sensordata import *
+
+from pyvale.core.camera import *
+from pyvale.core.cameradata import *
+from pyvale.core.cameradata2d import *
+from pyvale.core.cameratools import *
+
+import pyvale.core.cython.rastercyth as rastercyth
+from pyvale.core.rastercy import *
+
+from pyvale.core.rendermesh import *
+from pyvale.core.rasternp import *
+
+from pyvale.core.imagedef2d import *
+
+from pyvale.core.errorintegrator import *
+from pyvale.core.errorrand import *
+from pyvale.core.errorsysindep import *
+from pyvale.core.errorsysdep import *
+from pyvale.core.errorsysfield import *
+from pyvale.core.errordriftcalc import *
+
+from pyvale.core.generatorsrandom import *
+
+from pyvale.core.visualopts import *
+from pyvale.core.visualtools import *
+from pyvale.core.visualsimplotter import *
+from pyvale.core.visualsimanimator import *
+from pyvale.core.visualexpplotter import *
+from pyvale.core.visualtraceplotter import *
+from pyvale.core.visualimages import *
+from pyvale.core.visualimagedef import *
+
+from pyvale.core.analyticmeshgen import *
+from pyvale.core.analyticsimdatagenerator import *
+from pyvale.core.analyticsimdatafactory import *
+
+from pyvale.core.experimentsimulator import *

pyvale/core/__init__.py

@@ -0,0 +1,7 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""

pyvale/core/analyticmeshgen.py

@@ -0,0 +1,59 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+import numpy as np
+
+# NOTE: This module is a feature under developement.
+
+def rectangle_mesh_2d(leng_x: float,
+                      leng_y: float,
+                      n_elem_x: int,
+                      n_elem_y: int) -> tuple[np.ndarray,np.ndarray]:
+
+    n_elems = n_elem_x*n_elem_y
+    n_node_x = n_elem_x+1
+    n_node_y = n_elem_y+1
+    nodes_per_elem = 4
+
+    coord_x = np.linspace(0,leng_x,n_node_x)
+    coord_y = np.linspace(0,leng_y,n_node_y)
+    (coord_grid_x,coord_grid_y) = np.meshgrid(coord_x,coord_y)
+
+    coord_x = np.atleast_2d(coord_grid_x.flatten()).T
+    coord_y = np.atleast_2d(coord_grid_y.flatten()).T
+    coord_z = np.zeros_like(coord_x)
+    coords = np.hstack((coord_x,coord_y,coord_z))
+
+    connect = np.zeros((n_elems,nodes_per_elem)).astype(np.int64)
+    row = 1
+    nn = 0
+    for ee in range(n_elems):
+        nn += 1
+        if nn >= row*n_node_x:
+            row += 1
+            nn += 1
+
+        connect[ee,:] = np.array([nn,nn+1,nn+n_node_x+1,nn+n_node_x])
+    connect = connect.T
+
+    return (coords,connect)
+
+
+def fill_dims(coord_x: np.ndarray,
+              coord_y: np.ndarray,
+              time: np.ndarray) -> tuple[np.ndarray,np.ndarray,np.ndarray]:
+
+    full_x = np.repeat(np.atleast_2d(coord_x).T,
+                       time.shape[0],
+                       axis=1)
+    full_y = np.repeat(np.atleast_2d(coord_y).T,
+                       time.shape[0],
+                       axis=1)
+    full_time = np.repeat(np.atleast_2d(time),
+                          coord_x.shape[0],
+                          axis=0)
+    return (full_x,full_y,full_time)

pyvale/core/analyticsimdatafactory.py

@@ -0,0 +1,63 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+import numpy as np
+import sympy
+import mooseherder as mh
+from pyvale.core.analyticsimdatagenerator import (AnalyticCaseData2D,
+                                                  AnalyticSimDataGenerator)
+
+# NOTE: This module is a feature under developement.
+
+def standard_case_2d() -> AnalyticCaseData2D:
+    case_data = AnalyticCaseData2D()
+    case_data.length_x = 10.0
+    case_data.length_y = 7.5
+    n_elem_mult = 10
+    case_data.num_elem_x = 4*n_elem_mult
+    case_data.num_elem_y = 3*n_elem_mult
+    case_data.time_steps = np.linspace(0.0,1.0,11)
+    return case_data
+
+
+class AnalyticCaseFactory:
+
+    @staticmethod
+    def scalar_linear_2d() -> tuple[mh.SimData,AnalyticSimDataGenerator]:
+
+        case_data = standard_case_2d()
+        (sym_y,sym_x,sym_t) = sympy.symbols("y,x,t")
+        case_data.funcs_x = (20.0/case_data.length_x * sym_x,)
+        case_data.funcs_y = (10.0/case_data.length_y * sym_y,)
+        case_data.funcs_t = (sym_t,)
+        case_data.offsets_space = (20.0,)
+        case_data.offsets_time = (0.0,)
+
+        data_gen = AnalyticSimDataGenerator(case_data)
+
+        sim_data = data_gen.generate_sim_data()
+
+        return (sim_data,data_gen)
+
+    @staticmethod
+    def scalar_quadratic_2d() -> tuple[mh.SimData,AnalyticSimDataGenerator]:
+
+        case_data = standard_case_2d()
+        (sym_y,sym_x,sym_t) = sympy.symbols("y,x,t")
+        case_data.funcs_x = (sym_x*(sym_x - case_data.length_x),)
+        case_data.funcs_y = (sym_y*(sym_y - case_data.length_y),)
+        case_data.funcs_t = (sym_t,)
+
+        data_gen = AnalyticSimDataGenerator(case_data)
+
+        sim_data = data_gen.generate_sim_data()
+
+        return (sim_data,data_gen)
+
+
+
+

pyvale/core/analyticsimdatagenerator.py

@@ -0,0 +1,160 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from dataclasses import dataclass
+import numpy as np
+import sympy
+import mooseherder as mh
+from pyvale.core.analyticmeshgen import rectangle_mesh_2d, fill_dims
+
+# NOTE: This module is a feature under developement.
+
+@dataclass
+class AnalyticCaseData2D:
+    length_x: float = 10.0
+    length_y: float = 7.5
+    num_elem_x: int = 4
+    num_elem_y: int = 3
+    time_steps: np.ndarray | None = None
+    field_keys: tuple[str,...] = ('scalar',)
+    funcs_x: tuple[sympy.Expr,...] | None = None
+    funcs_y: tuple[sympy.Expr,...] | None = None
+    funcs_t: tuple[sympy.Expr,...] | None = None
+    symbols: tuple[sympy.Symbol,...] = (sympy.Symbol("y"),
+                                        sympy.Symbol("x"),
+                                        sympy.Symbol("t"))
+    offsets_space: tuple[float,...] = (0.0,)
+    offsets_time: tuple[float,...] = (0.0,)
+    nodes_per_elem: int = 4
+
+
+class AnalyticSimDataGenerator:
+    def __init__(self, case_data: AnalyticCaseData2D
+                 ) -> None:
+
+        self._case_data = case_data
+        (self._coords,self._connect) = rectangle_mesh_2d(case_data.length_x,
+                                                         case_data.length_y,
+                                                         case_data.num_elem_x,
+                                                         case_data.num_elem_y)
+
+        self._field_sym_funcs = dict()
+        self._field_lam_funcs = dict()
+        for ii,kk in enumerate(case_data.field_keys):
+            self._field_sym_funcs[kk] = ((case_data.funcs_x[ii] *
+                                          case_data.funcs_y[ii] +
+                                          case_data.offsets_space[ii]) *
+                                        (case_data.funcs_t[ii] +
+                                         case_data.offsets_time[ii]))
+
+            self._field_lam_funcs[kk] = sympy.lambdify(case_data.symbols,
+                                                self._field_sym_funcs[kk],
+                                                'numpy')
+        self._field_eval = dict()
+
+
+    def evaluate_field_truth(self,
+                       field_key: str,
+                       coords: np.ndarray,
+                       time_steps: np.ndarray | None = None) -> np.ndarray:
+
+        if time_steps is None:
+            time_steps = self._case_data.time_steps
+
+        (x_eval,y_eval,t_eval) = fill_dims(coords[:,0],
+                                            coords[:,1],
+                                            time_steps)
+
+        field_vals = self._field_lam_funcs[field_key](y_eval,
+                                                x_eval,
+                                                t_eval)
+        return field_vals
+
+
+    def evaluate_all_fields_truth(self,
+                       coords: np.ndarray,
+                       time_steps: np.ndarray | None = None) -> np.ndarray:
+
+        if time_steps is None:
+            time_steps = self._case_data.time_steps
+
+        (x_eval,y_eval,t_eval) = fill_dims(coords[:,0],
+                                            coords[:,1],
+                                            time_steps)
+
+        eval_comps = dict()
+        for kk in  self._case_data.field_keys:
+            eval_comps[kk] = self._field_lam_funcs[kk](y_eval,
+                                                        x_eval,
+                                                        t_eval)
+        return eval_comps
+
+
+    def evaluate_field_at_nodes(self, field_key: str) -> np.ndarray:
+        (x_eval,y_eval,t_eval) = fill_dims(self._coords[:,0],
+                                           self._coords[:,1],
+                                           self._case_data.time_steps)
+
+        self._field_eval[field_key] = self._field_lam_funcs[field_key](y_eval,
+                                                                        x_eval,
+                                                                        t_eval)
+        return self._field_eval[field_key]
+
+    def evaluate_all_fields_at_nodes(self) -> dict[str,np.ndarray]:
+        (x_eval,y_eval,t_eval) = fill_dims(self._coords[:,0],
+                                           self._coords[:,1],
+                                           self._case_data.time_steps)
+        eval_comps = dict()
+        for kk in  self._case_data.field_keys:
+            eval_comps[kk] = self._field_lam_funcs[kk](y_eval,
+                                                        x_eval,
+                                                        t_eval)
+        self._field_eval = eval_comps
+        return self._field_eval
+
+
+    def generate_sim_data(self) -> mh.SimData:
+
+        sim_data = mh.SimData()
+        sim_data.num_spat_dims = 2
+        sim_data.time = self._case_data.time_steps
+        sim_data.coords = self._coords
+        sim_data.connect = {'connect1': self._connect}
+
+        if not self._field_eval:
+            self.evaluate_all_fields_at_nodes()
+        sim_data.node_vars = self._field_eval
+
+        return sim_data
+
+
+    def get_visualisation_grid(self,
+                               field_key: str | None = None,
+                               time_step: int = -1
+                               ) -> tuple[np.ndarray,np.ndarray,np.ndarray]:
+
+        if field_key is None:
+            field_key = self._case_data.field_keys[0]
+
+        grid_shape = (self._case_data.num_elem_y+1,
+                      self._case_data.num_elem_x+1)
+
+        grid_x = np.atleast_2d(self._coords[:,0]).T.reshape(grid_shape)
+        grid_y = np.atleast_2d(self._coords[:,1]).T.reshape(grid_shape)
+
+        if not self._field_eval:
+            self.evaluate_all_fields_at_nodes()
+
+        scalar_grid = np.reshape(self._field_eval[field_key][:,time_step],grid_shape)
+
+        return (grid_x,grid_y,scalar_grid)
+
+
+
+
+
+

pyvale/core/camera.py

@@ -0,0 +1,146 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+import numpy as np
+from pyvale.core.field import IField
+from pyvale.core.sensorarray import ISensorArray
+from pyvale.core.errorintegrator import ErrIntegrator
+from pyvale.core.sensordescriptor import SensorDescriptor
+from pyvale.core.fieldsampler import sample_field_with_sensor_data
+from pyvale.core.cameradata2d import CameraData2D
+from pyvale.core.cameratools import CameraTools
+
+
+# NOTE: This module is a feature under developement.
+
+
+class CameraBasic2D(ISensorArray):
+    __slots__ = ("_cam_data","_field","_error_integrator","_descriptor",
+                 "_sensor_data","_truth","_measurements")
+
+    def __init__(self,
+                 cam_data: CameraData2D,
+                 field: IField,
+                 descriptor: SensorDescriptor | None = None,
+                 ) -> None:
+
+        self._cam_data = cam_data
+        self._field = field
+        self._error_integrator = None
+
+        self._descriptor = SensorDescriptor()
+        if descriptor is not None:
+            self._descriptor = descriptor
+
+        self._sensor_data = CameraTools.build_sensor_data_from_camera_2d(self._cam_data)
+
+        self._truth = None
+        self._measurements = None
+
+    #---------------------------------------------------------------------------
+    # Accessors
+    def get_sample_times(self) -> np.ndarray:
+        if self._sensor_data.sample_times is None:
+            #shape=(n_time_steps,)
+            return self._field.get_time_steps()
+
+        #shape=(n_time_steps,)
+        return self._sensor_data.sample_times
+
+    def get_measurement_shape(self) -> tuple[int,int,int]:
+        return (self._sensor_data.positions.shape[0],
+                len(self._field.get_all_components()),
+                self.get_sample_times().shape[0])
+
+    def get_image_measurements_shape(self) -> tuple[int,int,int,int]:
+        return (self._cam_data.num_pixels[1],
+                self._cam_data.num_pixels[0],
+                len(self._field.get_all_components()),
+                self.get_sample_times().shape[0])
+
+    def get_field(self) -> IField:
+        return self._field
+
+    def get_descriptor(self) -> SensorDescriptor:
+        return self._descriptor
+
+    #---------------------------------------------------------------------------
+    # Truth calculation from simulation
+    def calc_truth_values(self) -> np.ndarray:
+        self._truth = sample_field_with_sensor_data(self._field,
+                                                    self._sensor_data)
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._truth
+
+    def get_truth(self) -> np.ndarray:
+        if self._truth is None:
+            self._truth = self.calc_truth_values()
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._truth
+
+    #---------------------------------------------------------------------------
+    # Errors
+    def set_error_integrator(self, err_int: ErrIntegrator) -> None:
+        self._error_integrator = err_int
+
+    def get_errors_systematic(self) -> np.ndarray | None:
+        if self._error_integrator is None:
+            return None
+
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._error_integrator.get_errs_systematic()
+
+    def get_errors_random(self) -> np.ndarray | None:
+        if self._error_integrator is None:
+            return None
+
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._error_integrator.get_errs_random()
+
+    def get_errors_total(self) -> np.ndarray | None:
+        if self._error_integrator is None:
+            return None
+
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._error_integrator.get_errs_total()
+
+    #---------------------------------------------------------------------------
+    # Measurements
+    def calc_measurements(self) -> np.ndarray:
+        if self._error_integrator is None:
+            self._measurements = self.get_truth()
+        else:
+            self._measurements = self.get_truth() + \
+                self._error_integrator.calc_errors_from_chain(self.get_truth())
+
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._measurements
+
+    def get_measurements(self) -> np.ndarray:
+        if self._measurements is None:
+            self._measurements = self.calc_measurements()
+
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._measurements
+
+    #---------------------------------------------------------------------------
+    # Images
+    def calc_measurement_images(self) -> np.ndarray:
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        self._measurements = self.calc_measurements()
+        image_shape = self.get_image_measurements_shape()
+        #shape=(n_pixels_y,n_pixels_x,n_field_comps,n_time_steps)
+        return np.reshape(self._measurements,image_shape)
+
+    def get_measurement_images(self) -> np.ndarray:
+        self._measurements = self.get_measurements()
+        image_shape = self.get_image_measurements_shape()
+        #shape=(n_pixels_y,n_pixels_x,n_field_comps,n_time_steps)
+        return np.reshape(self._measurements,image_shape)
+
+
+

pyvale/core/cameradata.py

@@ -0,0 +1,64 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from dataclasses import dataclass, field
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+
+# NOTE: This module is a feature under developement.
+#
+# - Camera Local Coords: Pixel positions in pixels/meters
+# - Global Sim Coords: Transform from local pixel positions to sim coords in meters
+# - For this transformation we need user to specify center of ROI in sim coords
+# - There are going to be different ways to specify the camera properties
+
+# For thin lens theory will need to know some combination of:
+#   - The focal length of the lense
+#   - The working distance
+
+# Will need to create different ways for the user to automatically position the
+# camera
+
+
+@dataclass(slots=True)
+class CameraData:
+    pixels_num: np.ndarray
+    pixels_size: np.ndarray
+
+    pos_world: np.ndarray
+    rot_world: Rotation
+    roi_cent_world: np.ndarray
+
+    focal_length: float = 50.0
+    sub_samp: int = 2
+
+    back_face_removal: bool = True
+
+    sensor_size: np.ndarray = field(init=False)
+    image_dims: np.ndarray = field(init=False)
+    image_dist: float = field(init=False)
+    cam_to_world_mat: np.ndarray = field(init=False)
+    world_to_cam_mat: np.ndarray = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.image_dist = np.linalg.norm(self.pos_world - self.roi_cent_world)
+        self.sensor_size = self.pixels_num*self.pixels_size
+        self.image_dims = (self.image_dist
+                           *self.sensor_size/self.focal_length)
+
+        self.cam_to_world_mat = np.zeros((4,4))
+        self.cam_to_world_mat[0:3,0:3] = self.rot_world.as_matrix()
+        self.cam_to_world_mat[-1,-1] = 1.0
+        self.cam_to_world_mat[0:3,-1] = self.pos_world
+        self.world_to_cam_mat = np.linalg.inv(self.cam_to_world_mat)
+
+
+
+
+
+

pyvale/core/cameradata2d.py

@@ -0,0 +1,82 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from dataclasses import dataclass, field
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+
+@dataclass(slots=True)
+class CameraData2D:
+    pixels_count: np.ndarray | None = None
+    leng_per_px: float = 1.0e-3
+    bits: int = 8
+    roi_cent_world: np.ndarray | None = None
+
+    background: float = 0.5
+    sample_times: np.ndarray | None = None
+    angle: Rotation | None = None
+
+    subsample: int = 2
+
+    field_of_view: np.ndarray = field(init=False)
+    dynamic_range: int = field(init=False)
+
+    world_to_cam: np.ndarray = field(init=False)
+    cam_to_world: np.ndarray = field(init=False)
+
+    def __post_init__(self) -> None:
+
+        if self.pixels_count is None:
+            self.pixels_count = np.array((1000,1000),dtype=np.int32)
+
+        if self.roi_cent_world is None:
+            self.roi_cent_world = np.array((0.0,0.0,0.0),dtype=np.float64)
+
+        self.field_of_view = self.leng_per_px*(self.pixels_count.astype(np.float64))
+        self.dynamic_range = 2**self.bits
+        self.background = self.background*float(self.dynamic_range)
+
+        self.world_to_cam = self.field_of_view/2 - self.roi_cent_world[:-1]
+        self.cam_to_world = -self.world_to_cam
+
+
+#@dataclass(slots=True)
+#class CameraData2D:
+#     #shape=(n_px_X,n_px_Y)
+#     num_pixels: np.ndarray
+
+#     # Center location of the region of interest in world coords
+#     #shape=(3,) as (x,y,z)
+#     roi_center_world: np.ndarray
+
+#     # Converts pixels to length units to align with global coords
+#     leng_per_px: float
+
+#     #shape=(n_time_steps,)
+#     sample_times: np.ndarray | None = None
+
+#     #TODO: this only works for flat surfaces aligned with the axis
+#     view_axes: tuple[int,int] = (0,1)
+
+#     bits_sensor: int = 16
+#     bits_file: int = 16
+
+#     angle: Rotation | None = None
+
+#     field_of_view_center_local: np.ndarray = field(init=False)
+#     field_of_view_local: np.ndarray = field(init=False)
+#     roi_shift_world: np.ndarray = field(init=False)
+
+#     def __post_init__(self) -> None:
+#         self.field_of_view_local = self.num_pixels*self.leng_per_px
+#         self.field_of_view_center_local = self.field_of_view_local/2
+
+#         self.roi_shift_world = np.zeros_like(self.roi_center_world)
+#         for ii,vv in enumerate(self.view_axes):
+#             self.roi_shift_world[vv] = self.roi_center_world[vv] - \
+#                 self.field_of_view_center_local[ii]