pyvale 2025.5.3__cp311-cp311-win_amd64.whl → 2025.7.0__cp311-cp311-win_amd64.whl

pyvale/rasteropts.py

@@ -0,0 +1,58 @@
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+from pathlib import Path
+from dataclasses import dataclass
+import numpy as np
+from pyvale.imagetools import EImageType, ImageTools
+
+
+@dataclass(slots=True)
+class RasterOpts:
+
+    image_min_frac: float = 0.0
+    image_max_frac: float = 1.0
+    image_background_frac: float = 0.5
+    image_bits: int = 16
+    image_type: EImageType = EImageType.TIFF
+
+    subsample: int = 2
+    parallel: int = 4
+
+    force_static: bool = False
+    save_depth_array: bool = False
+    save_depth_image: EImageType | None = None
+    save_image_array: bool = False
+
+    def __post_init__(self) -> None:
+        assert self.image_bits > 0, "Image bits must be greater than 0."
+        assert self.subsample > 0, "Subsampling must be larger than 0."
+        assert self.parallel > 0, "Number of parallel renders must be larger than 0"
+
+def save_raster(save_file: Path,
+                image_buff: np.ndarray,
+                depth_buff: np.ndarray,
+                opts: RasterOpts) -> None:
+
+    ImageTools.scale_digitise_save(save_file,
+                                   image_buff,
+                                   opts.image_type,
+                                   opts.image_bits,
+                                   opts.image_min_frac,
+                                   opts.image_max_frac,
+                                   opts.image_background_frac)
+
+    if opts.save_image_array:
+        np.save(save_file.with_suffix(".npy"),image_buff)
+
+    if opts.save_depth_image is not None:
+        depth_path = save_file.with_stem(f"{save_file.stem}_depth")
+        ImageTools.scale_digitise_save(depth_path,
+                                       depth_buff,
+                                       opts.save_depth_image)
+
+    if opts.save_depth_array:
+        depth_path = save_file.with_stem(f"{save_file.stem}_depth")
+        np.save(depth_path.with_suffix(".npy"),depth_buff)

pyvale/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.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/rendermesh.py

@@ -8,46 +8,72 @@
 NOTE: this module is a feature under developement.
 """
 
-from enum import Enum
-from dataclasses import dataclass, field
 import numpy as np
+from scipy.spatial.transform import Rotation
 import mooseherder as mh
 from pyvale.fieldconverter import simdata_to_pyvista
 
 
-@dataclass(slots=True)
-class RenderMeshData:
-    coords: np.ndarray
-    connectivity: np.ndarray
-    fields_render: np.ndarray
+# TODO:
+# - Store the render field keys and match them between meshes?
 
-    # 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)
+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")
 
-    coord_cent: np.ndarray = field(init=False)
-    coord_bound_min: np.ndarray = field(init=False)
-    coord_bound_max: np.ndarray = field(init=False)
+    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
 
-    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
+        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: int,
                        field_disp_keys: tuple[str,...] | None = None,
-                       ) -> RenderMeshData:
+                       pos_world: np.ndarray | None  = None,
+                       rot_world: Rotation | None = None
+                       ) -> RenderMesh:
 
     extract_keys = field_render_keys
     if field_disp_keys is not None:
@@ -102,46 +128,10 @@ def create_render_mesh(sim_data: mh.SimData,
             field_disp_by_node[:,:,ii] = np.ascontiguousarray(
                 np.array(pv_surf[cc]))
 
-
-
-    return RenderMeshData(coords=coords_world,
+    return RenderMesh(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)
+                          fields_disp=field_disp_by_node,
+                          pos_world=pos_world,
+                          rot_world=rot_world)
+

pyvale/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.cameradata import CameraData
+from pyvale.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/sensorarrayfactory.py

@@ -64,8 +64,8 @@ class SensorArrayFactory:
                                        rand_err_pc=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))
+        #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

pyvale/sensortools.py

@@ -3,7 +3,6 @@
 # License: MIT
 # Copyright (C) 2025 The Computer Aided Validation Team
 # ==============================================================================
-
 import numpy as np
 import mooseherder as mh
 from pyvale.sensorarray import ISensorArray
@@ -60,9 +59,9 @@ def create_sensor_pos_array(num_sensors: tuple[int,int,int],
 
 
 def print_measurements(sens_array: ISensorArray,
-                       sensors: tuple[int,int],
-                       components: tuple[int,int],
-                       time_steps: tuple[int,int])  -> None:
+                       sensors: int | slice,
+                       components: int | slice,
+                       time_steps: int | slice)  -> None:
     """Diagnostic function to print sensor measurements to the console. Also
     prints the ground truth, the random and the systematic errors for the
     specified sensor array. The sensors, components and time steps are specified
@@ -71,17 +70,18 @@ def print_measurements(sens_array: ISensorArray,
     Parameters
     ----------
     sens_array : ISensorArray
-        Sensor array to print measurement for.
-    sensors : tuple[int,int]
-        Range of sensors to print from the measurement array using the slice
-        specified by this tuple.
-    components : tuple[int,int]
-        Range of field components to print based on slicing the measurement
-        array with this tuple.
-    time_steps : tuple[int,int]
-        Range of time steps to print based on slicing the measurement array with
-        this tuple.
+        Sensor array to print measurements for.
+    sensors : int | slice
+        Index for the sensor or slice of range of sensors to be printed to the
+        console.
+    components : int | slice
+        Index for the field component or slice of range of field components to
+        be printed to the console
+    time_steps : int | slice
+        Index for the time step or slice of time steps to be printed to the
+        console.
     """
+
     measurement =  sens_array.get_measurements()
     truth = sens_array.get_truth()
     rand_errs = sens_array.get_errors_random()
@@ -89,33 +89,17 @@ def print_measurements(sens_array: ISensorArray,
     tot_errs = sens_array.get_errors_total()
 
     print(f"\nmeasurement.shape = \n    {measurement.shape}")
-    print_meas = measurement[sensors[0]:sensors[1],
-                             components[0]:components[1],
-                             time_steps[0]:time_steps[1]]
-    print(f"measurement = \n    {print_meas}")
-
-    print_truth = truth[sensors[0]:sensors[1],
-                        components[0]:components[1],
-                        time_steps[0]:time_steps[1]]
-    print(f"truth = \n    {print_truth}")
+    print(f"measurement = \n    {measurement[sensors,components,time_steps]}")
+    print(f"truth = \n    {truth[sensors,components,time_steps]}")
 
     if rand_errs is not None:
-        print_randerrs = rand_errs[sensors[0]:sensors[1],
-                                    components[0]:components[1],
-                                    time_steps[0]:time_steps[1]]
-        print(f"random errors = \n    {print_randerrs}")
+        print(f"random errors = \n    {rand_errs[sensors,components,time_steps]}")
 
     if sys_errs is not None:
-        print_syserrs = sys_errs[sensors[0]:sensors[1],
-                                        components[0]:components[1],
-                                        time_steps[0]:time_steps[1]]
-        print(f"systematic errors = \n    {print_syserrs}")
+        print(f"systematic errors = \n    {sys_errs[sensors,components,time_steps]}")
 
     if tot_errs is not None:
-        print_toterrs = tot_errs[sensors[0]:sensors[1],
-                                        components[0]:components[1],
-                                        time_steps[0]:time_steps[1]]
-        print(f"total errors = \n    {print_toterrs}")
+        print(f"total errors = \n    {tot_errs[sensors,components,time_steps]}")
 
     print()
 

pyvale/simcases/case21.i

@@ -9,7 +9,7 @@ endTime = 10
 timeStep = 1
 
 # Mechanical Loads/BCs
-topDispRate = ${fparse -1.5e-3 / endTime}  # m/s
+topDispRate = ${fparse -5e-3 / endTime}  # m/s
 
 # Mechanical Props: SS316L @ 20degC
 ss316LEMod = 200e9       # Pa

pyvale/simcases/run_1case.py

@@ -15,7 +15,15 @@ from mooseherder import (MooseConfig,
 
 #===============================================================================
 # Change this to run a different case
+<<<<<<< HEAD
+<<<<<<< HEAD
+CASE_STR = 'case21'
+=======
+CASE_STR = 'case16'
+>>>>>>> deploy
+=======
 CASE_STR = 'case00_HEX27'
+>>>>>>> main
 #===============================================================================
 
 CASE_FILES = (CASE_STR+'.geo',CASE_STR+'.i')

pyvale/simtools.py

@@ -4,7 +4,7 @@
 # Copyright (C) 2025 The Computer Aided Validation Team
 # ==============================================================================
 import numpy as np
-from pyvale.rendermesh import RenderMeshData
+from pyvale.rendermesh import RenderMesh
 
 class SimTools:
     """Namespace for tools required for analysing simulation results.
@@ -37,7 +37,7 @@ class SimTools:
 
     @staticmethod
     def get_deformed_nodes(timestep: int,
-                           render_mesh: RenderMeshData) -> np.ndarray | None:
+                           render_mesh: RenderMesh) -> np.ndarray | None:
         """A method to obtain the deformed locations of all the nodes at a given
             timestep.
 

pyvale/visualsimplotter.py

@@ -0,0 +1,180 @@
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+# import vtk #NOTE: has to be here to fix latex bug in pyvista/vtk
+# See: https://github.com/pyvista/pyvista/discussions/2928
+#NOTE: causes output to console to be suppressed unfortunately
+import pyvista as pv
+
+import mooseherder as mh
+
+from pyvale.sensorarraypoint import SensorArrayPoint
+from pyvale.fieldconverter import simdata_to_pyvista
+from pyvale.visualopts import (VisOptsSimSensors,VisOptsImageSave)
+from pyvale.visualtools import (create_pv_plotter,
+                                     get_colour_lims,
+                                     save_image)
+
+
+#TODO: Docstrings
+
+def add_sim_field(pv_plot: pv.Plotter,
+                  sensor_array: SensorArrayPoint,
+                  component: str,
+                  time_step: int,
+                  vis_opts: VisOptsSimSensors,
+                  ) -> tuple[pv.Plotter,pv.UnstructuredGrid]:
+
+    sim_vis = sensor_array.field.get_visualiser()
+    sim_data = sensor_array.field.get_sim_data()
+    sim_vis[component] = sim_data.node_vars[component][:,time_step]
+    comp_ind = sensor_array.field.get_component_index(component)
+
+    scalar_bar_args = {"title":sensor_array.descriptor.create_label(comp_ind),
+                        "vertical":vis_opts.colour_bar_vertical,
+                        "title_font_size":vis_opts.colour_bar_font_size,
+                        "label_font_size":vis_opts.colour_bar_font_size}
+
+    pv_plot.add_mesh(sim_vis,
+                     scalars=component,
+                     label="sim-data",
+                     show_edges=vis_opts.show_edges,
+                     show_scalar_bar=vis_opts.colour_bar_show,
+                     scalar_bar_args=scalar_bar_args,
+                     lighting=False,
+                     clim=vis_opts.colour_bar_lims)
+
+    if vis_opts.time_label_show:
+        pv_plot.add_text(f"Time: {sim_data.time[time_step]} " + \
+                            f"{sensor_array.descriptor.time_units}",
+                            position=vis_opts.time_label_position,
+                            font_size=vis_opts.time_label_font_size,
+                            name='time-label')
+
+    return (pv_plot,sim_vis)
+
+
+def add_sensor_points_nom(pv_plot: pv.Plotter,
+                          sensor_array: SensorArrayPoint,
+                          vis_opts: VisOptsSimSensors,
+                          ) -> pv.Plotter:
+
+    vis_sens_nominal = pv.PolyData(sensor_array.sensor_data.positions)
+    vis_sens_nominal["labels"] = sensor_array.descriptor.create_sensor_tags(
+    sensor_array.get_measurement_shape()[0])
+
+    # Add points to show sensor locations
+    pv_plot.add_point_labels(vis_sens_nominal,"labels",
+                            font_size=vis_opts.sens_label_font_size,
+                            shape_color=vis_opts.sens_label_colour,
+                            point_color=vis_opts.sens_colour_nom,
+                            render_points_as_spheres=True,
+                            point_size=vis_opts.sens_point_size,
+                            always_visible=True)
+
+    return pv_plot
+
+
+def add_sensor_points_pert(pv_plot: pv.Plotter,
+                           sensor_array: SensorArrayPoint,
+                           vis_opts: VisOptsSimSensors,
+                           ) -> pv.Plotter:
+
+    sens_data_perturbed = sensor_array.get_sensor_data_perturbed()
+
+    if sens_data_perturbed is not None and vis_opts.show_perturbed_pos:
+        vis_sens_perturbed = pv.PolyData(sens_data_perturbed.positions)
+        vis_sens_perturbed["labels"] = ["",]*sensor_array.get_measurement_shape()[0]
+
+        pv_plot.add_point_labels(vis_sens_perturbed,"labels",
+                                font_size=vis_opts.sens_label_font_size,
+                                shape_color=vis_opts.sens_label_colour,
+                                point_color=vis_opts.sens_colour_pert,
+                                render_points_as_spheres=True,
+                                point_size=vis_opts.sens_point_size,
+                                always_visible=True)
+
+    return pv_plot
+
+
+def plot_sim_mesh(sim_data: mh.SimData,
+                  vis_opts: VisOptsSimSensors | None = None,
+                  ) -> pv.Plotter:
+
+    if vis_opts is None:
+        vis_opts = VisOptsSimSensors()
+
+    pv_simdata = simdata_to_pyvista(sim_data,
+                                         None,
+                                         sim_data.num_spat_dims)
+
+    pv_plot = create_pv_plotter(vis_opts)
+
+    pv_plot.add_mesh(pv_simdata,
+                     label='sim-data',
+                     show_edges=True,
+                     show_scalar_bar=False)
+
+    return pv_plot
+
+
+def plot_sim_data(sim_data: mh.SimData,
+                  component: str,
+                  time_step: int = -1,
+                  vis_opts: VisOptsSimSensors | None = None
+                  ) -> pv.Plotter:
+
+    if vis_opts is None:
+        vis_opts = VisOptsSimSensors()
+
+    pv_simdata = simdata_to_pyvista(sim_data,
+                                        (component,),
+                                         sim_data.num_spat_dims)
+
+    pv_plot = create_pv_plotter(vis_opts)
+
+    pv_plot.add_mesh(pv_simdata,
+                     scalars=pv_simdata[component][:,time_step],
+                     label="sim-data",
+                     show_edges=True,
+                     show_scalar_bar=True,
+                     scalar_bar_args={"title":component},)
+
+
+    return pv_plot
+
+
+def plot_point_sensors_on_sim(sensor_array: SensorArrayPoint,
+                              component: str,
+                              time_step: int = -1,
+                              vis_opts: VisOptsSimSensors | None = None,
+                              image_save_opts: VisOptsImageSave | None = None,
+                              ) -> pv.Plotter:
+
+    if vis_opts is None:
+        vis_opts = VisOptsSimSensors()
+
+    sim_data = sensor_array.field.get_sim_data()
+    vis_opts.colour_bar_lims = get_colour_lims(
+        sim_data.node_vars[component][:,time_step],
+        vis_opts.colour_bar_lims)
+
+    pv_plot = create_pv_plotter(vis_opts)
+
+    pv_plot = add_sensor_points_pert(pv_plot,sensor_array,vis_opts)
+    pv_plot = add_sensor_points_nom(pv_plot,sensor_array,vis_opts)
+    (pv_plot,_) = add_sim_field(pv_plot,
+                                sensor_array,
+                                component,
+                                time_step,
+                                vis_opts)
+
+    pv_plot.camera_position = vis_opts.camera_position
+
+    if image_save_opts is not None:
+        save_image(pv_plot,image_save_opts)
+
+    return pv_plot
+