pyvale 2025.4.0__py3-none-any.whl

pyvale/examples/features/ex_calibration_error.py

@@ -0,0 +1,108 @@
+'''
+================================================================================
+DEV: calibration check
+
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+'''
+import matplotlib.pyplot as plt
+import numpy as np
+import mooseherder as mh
+import pyvale
+
+
+def assumed_calib(signal: np.ndarray) -> np.ndarray:
+    return 24.3*signal + 0.616
+
+
+def truth_calib(signal: np.ndarray) -> np.ndarray:
+    return -0.01897 + 25.41881*signal - 0.42456*signal**2 + 0.04365*signal**3
+
+
+def main() -> None:
+    """pyvale example: sensor calibration error
+    Based on K-type thermocouple calibration
+    """
+    n_divs = 10000
+    signal_calib_range = np.array((0,6))
+    v = np.linspace(signal_calib_range[0],signal_calib_range[1],n_divs)
+
+    temp_truth = -0.01897 + 25.41881*v - 0.42456*v**2 + 0.04365*v**3
+    temp_assumed = 24.3*v + 0.616
+    calib_error = temp_assumed - temp_truth
+    print()
+    print(80*"-")
+    print(f"Calibration error over signal:"+\
+          f" {signal_calib_range[0]} to {signal_calib_range[1]} mV")
+    print(calib_error)
+    print(f"Max calib error: {np.max(calib_error)}")
+    print(f"Min calib error: {np.min(calib_error)}")
+    print()
+
+    data_path = pyvale.DataSet.thermal_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    # Scale to mm to make 3D visualisation scaling easier
+    sim_data.coords = sim_data.coords*1000.0
+
+    descriptor = pyvale.SensorDescriptorFactory.temperature_descriptor()
+
+    field_key = 'temperature'
+    t_field = pyvale.FieldScalar(sim_data,
+                                 field_key=field_key,
+                                 spat_dims=2)
+
+    n_sens = (4,1,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,50.0)
+    z_lims = (0.0,0.0)
+    sens_pos = pyvale.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    use_sim_time = False
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sens_data = pyvale.SensorData(positions=sens_pos,
+                                  sample_times=sample_times)
+
+    tc_array = pyvale.SensorArrayPoint(sens_data,
+                                       t_field,
+                                       descriptor)
+
+    cal_err = pyvale.ErrSysCalibration(assumed_calib,
+                                        truth_calib,
+                                        signal_calib_range,
+                                        n_cal_divs=10000)
+    sys_err_int = pyvale.ErrIntegrator([cal_err],
+                                       sens_data,
+                                       tc_array.get_measurement_shape())
+    tc_array.set_error_integrator(sys_err_int)
+
+    measurements = tc_array.get_measurements()
+
+    print('\n'+80*'-')
+    print('For a sensor: measurement = truth + sysematic error + random error')
+    print(f'measurements.shape = {measurements.shape} = '+
+          '(n_sensors,n_field_components,n_timesteps)\n')
+    print("The truth, systematic error and random error arrays have the same "+
+          "shape.")
+
+    print(80*'-')
+    print('Looking at the last 5 time steps (measurements) of sensor 0:')
+    pyvale.print_measurements(tc_array,
+                              (0,1),
+                              (0,1),
+                              (measurements.shape[2]-5,measurements.shape[2]))
+    print(80*'-')
+
+    pyvale.plot_time_traces(tc_array,field_key)
+    plt.show()
+
+
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/features/ex_chain_field_errs.py

@@ -0,0 +1,141 @@
+"""
+================================================================================
+example: displacement sensors on a 2d plate
+
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale
+
+def main() -> None:
+    data_path = pyvale.DataSet.mechanical_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    # Scale to mm to make 3D visualisation scaling easier
+    sim_data.coords = sim_data.coords*1000.0 # type: ignore
+
+    descriptor = pyvale.SensorDescriptorFactory.displacement_descriptor()
+
+    spat_dims = 2
+    field_key = "disp"
+    components = ("disp_x","disp_y")
+    disp_field = pyvale.FieldVector(sim_data,field_key,components,spat_dims)
+
+    n_sens = (2,3,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,150.0)
+    z_lims = (0.0,0.0)
+    sensor_positions = pyvale.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    use_sim_time = True
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sensor_data = pyvale.SensorData(positions=sensor_positions,
+                                    sample_times=sample_times)
+
+    disp_sens_array = pyvale.SensorArrayPoint(sensor_data,
+                                              disp_field,
+                                              descriptor)
+
+    pos_offset = -1.0*np.ones_like(sensor_positions)
+    pos_offset[:,2] = 0 # in 2d we only have offset in x and y so zero z
+    pos_error_data = pyvale.ErrFieldData(pos_offset_xyz=pos_offset)
+
+    angle_offset = np.zeros_like(sensor_positions)
+    angle_offset[:,0] = 1.0 # only rotate about z in 2D
+    angle_error_data = pyvale.ErrFieldData(ang_offset_zyx=angle_offset)
+
+    time_offset = 2.0*np.ones_like(disp_sens_array.get_sample_times())
+    time_error_data = pyvale.ErrFieldData(time_offset=time_offset)
+
+    field_errs = []
+    field_errs.append(pyvale.ErrSysField(disp_field,
+                                         time_error_data))
+    field_errs.append(pyvale.ErrSysField(disp_field,
+                                        time_error_data))
+
+    field_errs.append(pyvale.ErrSysField(disp_field,
+                                        pos_error_data))
+    field_errs.append(pyvale.ErrSysField(disp_field,
+                                        pos_error_data))
+
+    field_errs.append(pyvale.ErrSysField(disp_field,
+                                        angle_error_data))
+    field_errs.append(pyvale.ErrSysField(disp_field,
+                                        angle_error_data))
+
+    err_int_opts = pyvale.ErrIntOpts(force_dependence=True,
+                                     store_all_errs=True)
+    error_int = pyvale.ErrIntegrator(field_errs,
+                                     sensor_data,
+                                     disp_sens_array.get_measurement_shape(),
+                                     err_int_opts)
+    disp_sens_array.set_error_integrator(error_int)
+
+    measurements = disp_sens_array.calc_measurements()
+
+    sens_data_by_chain = error_int.get_sens_data_by_chain()
+    if sens_data_by_chain is not None:
+        for ii,ss in enumerate(sens_data_by_chain):
+            print(80*"-")
+            if ss is not None:
+                print(f"SensorData @ [{ii}]")
+                print("TIME")
+                print(ss.sample_times)
+                print()
+                print("POSITIONS")
+                print(ss.positions)
+                print()
+                print("ANGLES")
+                for aa in ss.angles:
+                    print(aa.as_euler("zyx",degrees=True))
+                print()
+            print(80*"-")
+
+    print()
+    print(80*"=")
+    sens_data_accumulated = error_int.get_sens_data_accumulated()
+    print("TIME")
+    print(sens_data_accumulated.sample_times)
+    print()
+    print("POSITIONS")
+    print(sens_data_accumulated.positions)
+    print()
+    print("ANGLES")
+    for aa in sens_data_accumulated.angles:
+        print(aa.as_euler("zyx",degrees=True))
+    print()
+    print(80*"=")
+
+    print(80*"-")
+    sens_num = 4
+    print("The last 5 time steps (measurements) of sensor {sens_num}:")
+    pyvale.print_measurements(disp_sens_array,
+                              (sens_num-1,sens_num),
+                              (0,1),
+                              (measurements.shape[2]-5,measurements.shape[2]))
+    print(80*"-")
+
+    plot_field = "disp_x"
+
+    if plot_field == "disp_x":
+        pv_plot = pyvale.plot_point_sensors_on_sim(disp_sens_array,"disp_x")
+        pv_plot.show()
+    elif plot_field == "disp_y":
+        pv_plot = pyvale.plot_point_sensors_on_sim(disp_sens_array,"disp_y")
+        pv_plot.show()
+
+    pyvale.plot_time_traces(disp_sens_array,"disp_x")
+    pyvale.plot_time_traces(disp_sens_array,"disp_y")
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/features/ex_field_errs.py

@@ -0,0 +1,78 @@
+'''
+================================================================================
+Example: thermocouples on a 2d plate
+
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+'''
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale
+
+
+def main() -> None:
+    """pyvale example: point sensors on a 2D thermal simulation
+    ----------------------------------------------------------------------------
+    """
+    data_path = pyvale.DataSet.thermal_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    field_key = list(sim_data.node_vars.keys())[0] # type: ignore
+    # Scale to mm to make 3D visualisation scaling easier
+    sim_data.coords = sim_data.coords*1000.0 # type: ignore
+
+    n_sens = (4,1,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,50.0)
+    z_lims = (0.0,0.0)
+    sens_pos = pyvale.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    sample_times = np.linspace(0.0,np.max(sim_data.time),50) # | None
+
+    sensor_data = pyvale.SensorData(positions=sens_pos,
+                                    sample_times=sample_times)
+
+    tc_array = pyvale.SensorArrayFactory \
+        .thermocouples_no_errs(sim_data,
+                               sensor_data,
+                               field_key,
+                               spat_dims=2)
+
+    #---------------------------------------------------------------------------
+    # Standard independent systematic errors
+    pos_rand = pyvale.GeneratorNormal(std=1.0) # mm
+    pos_lock = np.full_like(sensor_data.positions,False,dtype=bool)
+    pos_lock[:,2] = True
+    field_err_data = pyvale.ErrFieldData(
+        pos_rand_xyz=(pos_rand,pos_rand,pos_rand),
+        pos_lock_xyz=pos_lock
+    )
+
+    err_chain = []
+    err_chain.append(pyvale.ErrSysField(tc_array.get_field(),
+                                        field_err_data))
+    err_int = pyvale.ErrIntegrator(err_chain,
+                                   sensor_data,
+                                   tc_array.get_measurement_shape())
+    tc_array.set_error_integrator(err_int)
+
+
+    #---------------------------------------------------------------------------
+    measurements = tc_array.calc_measurements()
+    print(80*'-')
+    sens_num = 4
+    print('The last 5 time steps (measurements) of sensor {sens_num}:')
+    pyvale.print_measurements(tc_array,
+                              (sens_num-1,sens_num),
+                              (0,1),
+                              (measurements.shape[2]-5,measurements.shape[2]))
+    print(80*'-')
+
+    pyvale.plot_time_traces(tc_array,field_key)
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()

pyvale/examples/features/ex_sensor_single_angle_batch.py

@@ -0,0 +1,110 @@
+"""
+================================================================================
+Example: displacement sensors on a 2d plate
+
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.spatial.transform import Rotation
+import mooseherder as mh
+import pyvale
+
+def main() -> None:
+    """pyvale example: single rotation batch processing
+    ----------------------------------------------------------------------------
+    - Tests that when only one sensor rotation is provided that
+      all sensors are assumed to have the same rotation and batch processed.
+    """
+    data_path = pyvale.DataSet.mechanical_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    # Scale to mm to make 3D visualisation scaling easier
+    sim_data.coords = sim_data.coords*1000.0 # type: ignore
+
+    descriptor = pyvale.SensorDescriptorFactory.displacement_descriptor()
+
+    spat_dims = 2
+    field_key = "disp"
+    components = ("disp_x","disp_y")
+    disp_field = pyvale.FieldVector(sim_data,field_key,components,spat_dims)
+
+    #---------------------------------------------------------------------------
+    n_sens = (2,3,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,150.0)
+    z_lims = (0.0,0.0)
+    sensor_positions = pyvale.create_sensor_pos_array(n_sens,
+                                                      x_lims,
+                                                      y_lims,
+                                                      z_lims)
+
+    use_sim_time = False
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    # Provide only a single rotation for the 6 sensors
+    sensor_angles = (Rotation.from_euler("zyx", [180, 0, 0], degrees=True),)
+
+    sensor_data_norot = pyvale.SensorData(positions=sensor_positions,
+                                          sample_times=sample_times)
+
+
+    sensor_data_rot = pyvale.SensorData(positions=sensor_positions,
+                                  sample_times=sample_times,
+                                  angles=sensor_angles)
+
+    #---------------------------------------------------------------------------
+    disp_sensors_norot = pyvale.SensorArrayPoint(sensor_data_norot,
+                                                disp_field,
+                                                descriptor)
+
+
+    disp_sensors_rot = pyvale.SensorArrayPoint(sensor_data_rot,
+                                               disp_field,
+                                               descriptor)
+
+
+
+    measurements_norot = disp_sensors_norot.calc_measurements()
+    measurements_rot = disp_sensors_rot.calc_measurements()
+
+    #---------------------------------------------------------------------------
+    sens_to_print = 1
+    print(80*"-")
+    print(f"The last 5 time steps (measurements) of non-rotated sensor {sens_to_print}:")
+    pyvale.print_measurements(disp_sensors_norot,
+                              (sens_to_print-1,sens_to_print),
+                              (0,1),
+                              (measurements_norot.shape[2]-5,measurements_norot.shape[2]))
+    print(80*"-")
+    print(f"The last 5 time steps (measurements) of rotated sensor {sens_to_print}:")
+    pyvale.print_measurements(disp_sensors_rot,
+                              (sens_to_print-1,sens_to_print),
+                              (0,1),
+                              (measurements_rot.shape[2]-5,measurements_rot.shape[2]))
+    print(80*"-")
+
+    #---------------------------------------------------------------------------
+    plot_field = "disp_x"
+
+    if plot_field == "disp_x":
+        pv_plot = pyvale.plot_point_sensors_on_sim(disp_sensors_rot,"disp_x")
+        pv_plot.show(cpos="xy")
+    elif plot_field == "disp_y":
+        pv_plot = pyvale.plot_point_sensors_on_sim(disp_sensors_rot,"disp_y")
+        pv_plot.show(cpos="xy")
+
+    (fig,ax) = pyvale.plot_time_traces(disp_sensors_norot,plot_field)
+    ax.set_title("No rotation")
+    (fig,ax) = pyvale.plot_time_traces(disp_sensors_rot,plot_field)
+    ax.set_title("Rotated")
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/imagedef2d/ex_imagedef2d_todisk.py

@@ -0,0 +1,86 @@
+"""
+================================================================================
+pyvale: the python computer aided validation engine
+
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+
+from pathlib import Path
+import numpy as np
+import mooseherder as mh
+import pyvale as pyv
+
+
+def main() -> None:
+    #---------------------------------------------------------------------------
+    # LOAD FILES
+    sim_path = pyv.DataSet.mechanical_2d_path()
+    sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
+
+    image_path = pyv.DataSet.dic_pattern_5mpx_path()
+    image_speckle = pyv.CameraTools.load_image(image_path)
+
+    save_path = Path.cwd()/"exampleoutput"
+
+    coords = sim_data.coords
+    connectivity = (sim_data.connect["connect1"]-1).T # Beware 0 indexing here
+    disp_x = sim_data.node_vars["disp_x"][:,:]
+    disp_y = sim_data.node_vars["disp_y"][:,:]
+
+    print()
+    print(80*"-")
+    print(f"{coords.shape=}")
+    print(f"{connectivity.shape=}")
+    print(f"{disp_x.shape=}")
+    print(f"{disp_y.shape=}")
+    print(80*"-")
+
+    #---------------------------------------------------------------------------
+    # INPUT DATA
+    cam_data = pyv.CameraData2D(pixels_count=np.array((1040,1540)),
+                                   leng_per_px=0.1e-3,
+                                   bits=8,
+                                   roi_cent_world=np.mean(coords,axis=0),
+                                   subsample=3)
+    id_opts = pyv.ImageDefOpts(save_path=save_path,
+                                  crop_on=True,
+                                  add_static_ref=True)
+
+
+    #---------------------------------------------------------------------------
+    # PRE-PROCESS IMAGES
+    (upsampled_image,
+     image_mask,
+     image_input,
+     disp_x,
+     disp_y) = pyv.ImageDef2D.preprocess(cam_data,
+                                            image_speckle,
+                                            coords,
+                                            connectivity,
+                                            disp_x,
+                                            disp_y,
+                                            id_opts,
+                                            print_on=True)
+
+    ff = -1
+    disp = np.array((disp_x[:,ff],disp_y[:,ff])).T
+    print(f"{disp.shape=}")
+
+    #---------------------------------------------------------------------------
+    # DEFORM IMAGES AND SAVE
+    pyv.ImageDef2D.deform_images_to_disk(cam_data,
+                                            upsampled_image,
+                                            coords,
+                                            connectivity,
+                                            disp_x,
+                                            disp_y,
+                                            image_mask,
+                                            id_opts,
+                                            print_on=True)
+
+
+if __name__ == "__main__":
+    main()
+

pyvale/examples/rasterisation/ex_rastenp.py

@@ -0,0 +1,154 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from pathlib import Path
+import time
+import numpy as np
+from scipy.spatial.transform import Rotation
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+# TODO
+# - Fix the image averaging function to use cython
+# - Saving of the rendered images for post processing or analysis
+# - Collapse image display functions into visual to simplify code
+#
+# CAMERA:
+# - Need option to work camera rotation based on a given position
+#   - The z axis is easy as we can just do roi-cam_pos but what about x and y
+#
+# SCENE OBJECT:
+# - Allow multiple objects in the scene with their own transformations
+# - Allow multiple cameras in the scene
+
+
+def main() -> None:
+    """pyvale example: rasterisation field renderer
+    ----------------------------------------------------------------------------
+    - TODO
+    """
+    # This a path to an exodus *.e output file from MOOSE, this can be
+    # replaced with a path to your own simulation file
+    #sim_path = Path.home()/"pyvale"/"src"/"pyvale"/"simcases"/"case21_out.e"
+    sim_path = pyv.DataSet.render_mechanical_3d_path()
+
+    disp_comps = ("disp_x","disp_y","disp_z")
+
+    sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
+
+    # Scale m -> mm
+    sim_data = pyv.scale_length_units(sim_data,disp_comps,1000.0)
+
+    # Extracts the surface mesh from a full 3d simulation for rendering
+    render_mesh = pyv.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+    print()
+    print(80*"-")
+    print("MESH DATA:")
+    print(80*"-")
+    print("connectivity.shape=(num_elems,num_nodes_per_elem)")
+    print(f"{render_mesh.connectivity.shape=}")
+    print()
+    print("coords.shape=(num_nodes,coord[x,y,z])")
+    print(f"{render_mesh.coords.shape=}")
+    print()
+    print("fields.shape=(num_coords,num_time_steps,num_components)")
+    print(f"{render_mesh.fields_render.shape=}")
+    if render_mesh.fields_disp is not None:
+        print(f"{render_mesh.fields_disp.shape=}")
+    print(80*"-")
+    print()
+
+
+    pixel_num = np.array((960,1280))
+    pixel_size = np.array((5.3e-3,5.3e-3))
+    focal_leng: float = 50
+    cam_rot = Rotation.from_euler("zyx",(0.0,-30.0,-10.0),degrees=True)
+    fov_scale_factor: float = 1.1
+
+    (roi_pos_world,
+     cam_pos_world) = pyv.CameraTools.pos_fill_frame_from_rotation(
+         coords_world=render_mesh.coords,
+         pixel_num=pixel_num,
+         pixel_size=pixel_size,
+         focal_leng=focal_leng,
+         cam_rot=cam_rot,
+         frame_fill=fov_scale_factor,
+     )
+
+    cam_data = pyv.CameraData(
+        pixels_num=pixel_num,
+        pixels_size=pixel_size,
+        pos_world=cam_pos_world,
+        rot_world=cam_rot,
+        roi_cent_world=roi_pos_world,
+        focal_length=focal_leng,
+        sub_samp=2,
+        back_face_removal=True,
+    )
+
+    print(80*"-")
+    print("CAMERA DATA:")
+    print(80*"-")
+    print(f"{roi_pos_world=}")
+    print(f"{cam_pos_world=}")
+    print()
+    print("World to camera matrix:")
+    print(cam_data.world_to_cam_mat)
+    print(80*"-")
+    print()
+
+    print(80*"-")
+    total_frames = render_mesh.fields_render.shape[1]*render_mesh.fields_render.shape[2]
+    print(f"Time steps to render: {render_mesh.fields_render.shape[1]}")
+    print(f"Fields to render: {render_mesh.fields_render.shape[2]}")
+    print(f"Total frames to render: {total_frames}")
+    print(80*"-")
+
+    print()
+    print(80*"=")
+    print("RASTER LOOP START")
+
+    #save_path = Path.cwd()/"example_output"
+    save_path = None
+    static_mesh = False
+
+    time_start_loop = time.perf_counter()
+    if static_mesh:
+        images = pyv.RasterNP.raster_static_mesh(
+            cam_data,render_mesh,save_path,threads_num=8
+        )
+    else:
+        time_start_loop = time.perf_counter()
+        images = pyv.RasterNP.raster_deformed_mesh(
+            cam_data,render_mesh,save_path,parallel=8
+        )
+
+    time_end_loop = time.perf_counter()
+    render_time = time_end_loop - time_start_loop
+
+
+    print("RASTER LOOP END")
+    print(80*"=")
+    print("PERFORMANCE")
+    print(f"Total frames = {total_frames}")
+    print(f"Total render time = {render_time:.4f} seconds")
+    print(f"Time per frame = {(render_time/total_frames):.4f} seconds")
+    print(80*"=")
+
+    plot_on = True
+    if plot_on:
+        (fig,ax) = pyv.plot_field_image(images[:,:,-1,0],
+                                        title_str="Disp. y, [mm]")
+        plt.show()
+
+if __name__ == "__main__":
+    main()