pyvale 2025.7.1__cp311-cp311-win_amd64.whl → 2025.8.1__cp311-cp311-win_amd64.whl

pyvale/examples/basics/{ex4_1_expsim2d_thermmech2d.py → ex4a_expsim2d_thermmech2d.py}

@@ -23,8 +23,11 @@ Test case: thermo-mechanical analysis of a 2D plate with a temperature gradient.
 
 import numpy as np
 import matplotlib.pyplot as plt
-import mooseherder as mh
-import pyvale as pyv
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
 
 #%%
 # Here we get a list of paths to a set of 3 simulations in this case the
@@ -32,7 +35,7 @@ import pyvale as pyv
 # coefficient on the other. The mechanical deformation is a result of
 # thermal expansion. The 3 simulation cases cover a nominal thermal
 # and a perturbation of +/-10%.
-data_paths = pyv.DataSet.thermomechanical_2d_experiment_paths()
+data_paths = dataset.thermomechanical_2d_experiment_paths()
 elem_dims: int = 2
 
 #%%
@@ -43,7 +46,7 @@ disp_comps = ("disp_x","disp_y")
 sim_list = []
 for pp in data_paths:
     sim_data = mh.ExodusReader(pp).read_all_sim_data()
-    sim_data = pyv.scale_length_units(scale=1000.0,
+    sim_data = sens.scale_length_units(scale=1000.0,
                                         sim_data=sim_data,
                                         disp_comps=disp_comps)
     sim_list.append(sim_data)
@@ -60,10 +63,10 @@ n_sens = (4,1,1)
 x_lims = (0.0,100.0)
 y_lims = (0.0,50.0)
 z_lims = (0.0,0.0)
-tc_sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+tc_sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
-tc_sens_data = pyv.SensorData(positions=tc_sens_pos,
-                                sample_times=sample_times)
+tc_sens_data = sens.SensorData(positions=tc_sens_pos,
+                              sample_times=sample_times)
 
 #%%
 # We use the sensor array factory to give us thermocouples with basic 2%
@@ -72,7 +75,7 @@ tc_sens_data = pyv.SensorData(positions=tc_sens_pos,
 # we run our experiment the field object that relies on this will switch the
 # sim data for the required simulation in our list.
 tc_field_name = "temperature"
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_basic_errs(sim_list[0],
                                 tc_sens_data,
                                 elem_dims=elem_dims,
@@ -82,8 +85,8 @@ tc_array = pyv.SensorArrayFactory \
 #%%
 # We place 3 strain gauges along the direction of the temperature gradient.
 n_sens = (3,1,1)
-sg_sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
-sg_sens_data = pyv.SensorData(positions=sg_sens_pos,
+sg_sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+sg_sens_data = sens.SensorData(positions=sg_sens_pos,
                                 sample_times=sample_times)
 
 #%%
@@ -91,7 +94,7 @@ sg_sens_data = pyv.SensorData(positions=sg_sens_pos,
 sg_field_name = "strain"
 sg_norm_comps = ("strain_xx","strain_yy")
 sg_dev_comps = ("strain_xy",)
-sg_array = pyv.SensorArrayFactory \
+sg_array = sens.SensorArrayFactory \
     .strain_gauges_basic_errs(sim_list[0],
                                 sg_sens_data,
                                 elem_dims=elem_dims,
@@ -106,7 +109,7 @@ sg_array = pyv.SensorArrayFactory \
 # use this to create an experiment simulator while specifying how many
 # simulate experiments we want to run per simulation and sensor array.
 sensor_arrays = [tc_array,sg_array]
-exp_sim = pyv.ExperimentSimulator(sim_list,
+exp_sim = sens.ExperimentSimulator(sim_list,
                                     sensor_arrays,
                                     num_exp_per_sim=1000)
 
@@ -163,12 +166,12 @@ print(80*"=")
 # deviation. In the next example we will see how to control these plots.
 # For now we will plot the temperature traces for the first simulation and
 # the strain traces for the third simulation in our list of SimData objects.
-(fig,ax) = pyv.plot_exp_traces(exp_sim,
+(fig,ax) = sens.plot_exp_traces(exp_sim,
                                 component="temperature",
                                 sens_array_num=0,
                                 sim_num=0)
 
-(fig,ax) = pyv.plot_exp_traces(exp_sim,
+(fig,ax) = sens.plot_exp_traces(exp_sim,
                                 component="strain_yy",
                                 sens_array_num=1,
                                 sim_num=2)

pyvale/examples/basics/{ex4_2_expsim3d_thermmech3d.py → ex4b_expsim3d_thermmech3d.py}

@@ -20,14 +20,17 @@ Test case: thermo-mechanical analysis of a divertor heatsink in 3D
 from pathlib import Path
 import numpy as np
 import matplotlib.pyplot as plt
-import mooseherder as mh
-import pyvale as pyv
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
 
 #%%
 # First we get the path to simulation output file and then read the
 # simulation into a `SimData`  object. In this case our simulation is a
 # thermomechanical model of a divertor heatsink.
-sim_path = pyv.DataSet.thermomechanical_3d_path()
+sim_path = dataset.thermomechanical_3d_path()
 sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
 elem_dims: int = 3
 
@@ -35,7 +38,7 @@ elem_dims: int = 3
 # We scale our length and displacement units to mm to help with
 # visualisation.
 disp_comps = ("disp_x","disp_y","disp_z")
-sim_data = pyv.scale_length_units(scale=1000.0,
+sim_data = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=disp_comps)
 
@@ -59,15 +62,15 @@ x_lims = (12.5,12.5)
 y_lims = (0.0,33.0)
 z_lims = (0.0,12.0)
 n_sens = (1,4,1)
-tc_sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+tc_sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
-tc_sens_data = pyv.SensorData(positions=tc_sens_pos,
+tc_sens_data = sens.SensorData(positions=tc_sens_pos,
                                 sample_times=sample_times)
 #%%
 # We use the sensor array factory to create our thermocouple array with no
 # errors.
 tc_field_name = "temperature"
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_no_errs(sim_data,
                             tc_sens_data,
                             elem_dims=elem_dims,
@@ -76,30 +79,30 @@ tc_array = pyv.SensorArrayFactory \
 # Now we build our error chain starting with some basic errors on the order
 # of 1 degree.
 tc_err_chain = []
-tc_err_chain.append(pyv.ErrSysUnif(low=1.0,high=1.0))
-tc_err_chain.append(pyv.ErrRandNorm(std=1.0))
+tc_err_chain.append(sens.ErrSysUnif(low=1.0,high=1.0))
+tc_err_chain.append(sens.ErrRandNorm(std=1.0))
 
 #%%
 # Now we add positioning error for our thermocouples.
 tc_pos_uncert = 0.1 # units = mm
-tc_pos_rand = (pyv.GenNormal(std=tc_pos_uncert),
-                pyv.GenNormal(std=tc_pos_uncert),
-                pyv.GenNormal(std=tc_pos_uncert))
+tc_pos_rand = (sens.GenNormal(std=tc_pos_uncert),
+                sens.GenNormal(std=tc_pos_uncert),
+                sens.GenNormal(std=tc_pos_uncert))
 
 #%%
 # We block translation in x so the thermocouples stay attached.
 tc_pos_lock = np.full(tc_sens_pos.shape,False,dtype=bool)
 tc_pos_lock[:,0] = True
 
-tc_field_err_data = pyv.ErrFieldData(pos_rand_xyz=tc_pos_rand,
+tc_field_err_data = sens.ErrFieldData(pos_rand_xyz=tc_pos_rand,
                                         pos_lock_xyz=tc_pos_lock)
-tc_err_chain.append(pyv.ErrSysField(tc_array.get_field(),
+tc_err_chain.append(sens.ErrSysField(tc_array.get_field(),
 
                                     tc_field_err_data))
 #%%
 # We have finished our error chain so we can build our error integrator and
 # attach it to our thermocouple array.
-tc_error_int = pyv.ErrIntegrator(tc_err_chain,
+tc_error_int = sens.ErrIntegrator(tc_err_chain,
                                     tc_sens_data,
                                     tc_array.get_measurement_shape())
 tc_array.set_error_integrator(tc_error_int)
@@ -107,7 +110,7 @@ tc_array.set_error_integrator(tc_error_int)
 #%%
 # We visualise our thermcouple locations on our mesh to make sure they are
 # in the correct positions.
-pv_plot = pyv.plot_point_sensors_on_sim(tc_array,"temperature")
+pv_plot = sens.plot_point_sensors_on_sim(tc_array,"temperature")
 pv_plot.camera_position = [(59.354, 43.428, 69.946),
                             (-2.858, 13.189, 4.523),
                             (-0.215, 0.948, -0.233)]
@@ -127,9 +130,9 @@ x_lims = (9.4,9.4)
 y_lims = (0.0,33.0)
 z_lims = (12.0,12.0)
 n_sens = (1,4,1)
-sg_sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+sg_sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
-sg_sens_data = pyv.SensorData(positions=sg_sens_pos,
+sg_sens_data = sens.SensorData(positions=sg_sens_pos,
                                 sample_times=sample_times)
 
 #%%
@@ -138,7 +141,7 @@ sg_sens_data = pyv.SensorData(positions=sg_sens_pos,
 sg_field_name = "strain"
 sg_norm_comps = ("strain_xx","strain_yy","strain_zz")
 sg_dev_comps = ("strain_xy","strain_yz","strain_xz")
-sg_array = pyv.SensorArrayFactory \
+sg_array = sens.SensorArrayFactory \
     .strain_gauges_no_errs(sim_data,
                             sg_sens_data,
                             elem_dims=elem_dims,
@@ -150,30 +153,30 @@ sg_array = pyv.SensorArrayFactory \
 # Now we build our error chain starting with some basic errors on the order
 # of 1 percent.
 sg_err_chain = []
-sg_err_chain.append(pyv.ErrSysUnifPercent(low_percent=1.0,high_percent=1.0))
-sg_err_chain.append(pyv.ErrRandNormPercent(std_percent=1.0))
+sg_err_chain.append(sens.ErrSysUnifPercent(low_percent=1.0,high_percent=1.0))
+sg_err_chain.append(sens.ErrRandNormPercent(std_percent=1.0))
 
 #%%
 # We are going to add +/-2 degree rotation uncertainty to our strain gauges.
 angle_uncert = 2.0
-angle_rand_zyx = (pyv.GenUniform(low=-angle_uncert,high=angle_uncert), # units = deg
-                    pyv.GenUniform(low=-angle_uncert,high=angle_uncert),
-                    pyv.GenUniform(low=-angle_uncert,high=angle_uncert))
+angle_rand_zyx = (sens.GenUniform(low=-angle_uncert,high=angle_uncert), # units = deg
+                    sens.GenUniform(low=-angle_uncert,high=angle_uncert),
+                    sens.GenUniform(low=-angle_uncert,high=angle_uncert))
 
 #%%
 # We only allow rotation on the face the strain gauges are on
 angle_lock = np.full(sg_sens_pos.shape,True,dtype=bool)
 angle_lock[:,0] = False   # Allow rotation about z
 
-sg_field_err_data = pyv.ErrFieldData(ang_rand_zyx=angle_rand_zyx,
+sg_field_err_data = sens.ErrFieldData(ang_rand_zyx=angle_rand_zyx,
                                         ang_lock_zyx=angle_lock)
-sg_err_chain.append(pyv.ErrSysField(sg_array.get_field(),
+sg_err_chain.append(sens.ErrSysField(sg_array.get_field(),
                                     sg_field_err_data))
 
 #%%
 # We have finished our error chain so we can build our error integrator and
 # attach it to our thermocouple array.
-sg_error_int = pyv.ErrIntegrator(sg_err_chain,
+sg_error_int = sens.ErrIntegrator(sg_err_chain,
                                     sg_sens_data,
                                     sg_array.get_measurement_shape())
 sg_array.set_error_integrator(sg_error_int)
@@ -181,7 +184,7 @@ sg_array.set_error_integrator(sg_error_int)
 #%%
 # Now we visualise the strain gauge locations to make sure they are where
 # we expect them to be.
-pv_plot = pyv.plot_point_sensors_on_sim(sg_array,"strain_yy")
+pv_plot = sens.plot_point_sensors_on_sim(sg_array,"strain_yy")
 pv_plot.camera_position = [(59.354, 43.428, 69.946),
                             (-2.858, 13.189, 4.523),
                             (-0.215, 0.948, -0.233)]
@@ -200,7 +203,7 @@ pv_plot.show()
 # all points on the graph.
 sim_list = [sim_data,]
 sensor_arrays = [tc_array,sg_array]
-exp_sim = pyv.ExperimentSimulator(sim_list,
+exp_sim = sens.ExperimentSimulator(sim_list,
                                     sensor_arrays,
                                     num_exp_per_sim=100)
 
@@ -246,11 +249,11 @@ print(80*"=")
 # the median as the centre line and to fill between the min and max values.
 # Note that the default here is to plot the mean and fill between 3 times
 # the standard deviation.
-trace_opts = pyv.TraceOptsExperiment(plot_all_exp_points=True,
-                                        centre=pyv.EExpVisCentre.MEDIAN,
-                                        fill_between=pyv.EExpVisBounds.MINMAX)
+trace_opts = sens.TraceOptsExperiment(plot_all_exp_points=True,
+                                        centre=sens.EExpVisCentre.MEDIAN,
+                                        fill_between=sens.EExpVisBounds.MINMAX)
 
-(fig,ax) = pyv.plot_exp_traces(exp_sim,
+(fig,ax) = sens.plot_exp_traces(exp_sim,
                                 component="temperature",
                                 sens_array_num=0,
                                 sim_num=0,
@@ -259,7 +262,7 @@ if save_figs:
     fig.savefig(fig_save_path/(save_tag+"_tc_traces.png"),
             dpi=300, format='png', bbox_inches='tight')
 
-(fig,ax) = pyv.plot_exp_traces(exp_sim,
+(fig,ax) = sens.plot_exp_traces(exp_sim,
                                 component="strain_yy",
                                 sens_array_num=1,
                                 sim_num=0,

pyvale/examples/basics/ex5_nomesh.py

@@ -0,0 +1,24 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""Basics: No mesh
+================================================================================
+
+TODO
+"""
+
+import numpy as np
+import pyvale as pyv
+
+# Build an analytic mesh in 2D and create a bi-linear field on the mesh
+
+# Run normal pyvale to see output of a sensor array
+
+
+
+
+
+

pyvale/examples/dic/ex1_2_blenderdeformed.py

@@ -0,0 +1,174 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Deforming a sample with 2D DIC
+===============================================
+
+This example follows a similar workflow to the previous Blender example.
+In this example, defomation is applied to sample, and images are rendered at
+each timestep.
+
+Test case: mechanical analysis of a plate with a hole loaded in tension.
+"""
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+from pathlib import Path
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
+import pyvale.blender as blender
+import pyvale.mooseherder as mh
+
+# %%
+# The simulation results are loaded in here in the same way as the previous
+# example. As mentioned this `data_path` can be replaced with your own MOOSE
+# simulation output in exodus format (*.e).
+
+data_path = dataset.render_mechanical_3d_path()
+sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+
+# %%
+# This is then scaled to mm, as all lengths in Blender are to be set in mm.
+# The `SimData` object is then converted into a `RenderMeshData` object, as
+# this skins the mesh ready to be imported into Blender.
+# The `disp_comps` are the expected direction of displacement. Since this is a
+# 3D deformation test case, displacement is expected in the x, y and z directions.
+
+disp_comps = ("disp_x","disp_y", "disp_z")
+sim_data = sens.scale_length_units(scale=1000.0,
+                                     sim_data=sim_data,
+                                     disp_comps=disp_comps)
+
+render_mesh = sens.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+# %%
+# Firstly, a save path must be set.
+# In order to do this a base path must be set. Then all the generated files will
+# be saved to a subfolder within this specified base directory
+# (e.g. blenderimages).
+# If no base directory is specified, it will be set as your home directory.
+
+base_dir = Path.cwd()
+
+# %%
+# Creating the scene
+# ^^^^^^^^^^^^^^^^^^
+# In order to create a DIC setup in Blender, first a scene must be created.
+# A scene is initialised using the `BlenderScene` class. All the subsequent
+# objects and actions necessary are then methods of this class.
+
+scene = blender.Scene()
+
+# %%
+# The next thing that can be added to the scene is a sample.
+# This is done by passing in the `RenderMeshData` object.
+# It should be noted that the mesh will be centred on the origin to allow for
+# the cameras to be centred on the mesh.
+# Once the part is added to the Blender scene, it can be both moved and rotated.
+
+
+part = scene.add_part(render_mesh, sim_spat_dim=3)
+# Set the part location
+part_location = np.array([0, 0, 0])
+blender.Tools.move_blender_obj(part=part, pos_world=part_location)
+part_rotation = Rotation.from_euler("xyz", [0, 0, 0], degrees=True)
+blender.Tools.rotate_blender_obj(part=part, rot_world=part_rotation)
+
+# %%
+# A camera can then be added to the scene.
+# To initialise a camera, the camera parameters must be specified using the
+# `CameraData` dataclass. Note that all lengths / distances inputted are in mm.
+# This camera can then be added to the Blender scene.
+# The camera can also be moved and rotated.
+
+cam_data = sens.CameraData(pixels_num=np.array([1540, 1040]),
+                             pixels_size=np.array([0.00345, 0.00345]),
+                             pos_world=(0, 0, 400),
+                             rot_world=Rotation.from_euler("xyz", [0, 0, 0]),
+                             roi_cent_world=(0, 0, 0),
+                             focal_length=15.0)
+camera = scene.add_camera(cam_data)
+camera.location = (0, 0, 410)
+camera.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
+
+# %%
+# A light can the be added to the scene.
+# Blender offers different light types: Point, Sun, Spot and Area.
+# The light can also be moved and rotated like the camera.
+
+light_data = blender.LightData(type=blender.LightType.POINT,
+                                     pos_world=(0, 0, 400),
+                                     rot_world=Rotation.from_euler("xyz",
+                                                                   [0, 0, 0]),
+                                     energy=1)
+light = scene.add_light(light_data)
+light.location = (0, 0, 410)
+light.rotation_euler = (0, 0, 0)
+
+# %%
+# A speckle pattern can then be applied to the sample.
+# Firstly, the material properties of the sample must be specified, but these
+# will all be defaulted if no inputs are provided.
+#The speckle pattern can then be specified by providing a path to an image file
+# with the pattern.
+# The mm/px resolution of the camera must also be specified in order to
+# correctly scale the speckle pattern.
+# It should be noted that for a bigger camera or sample you may need to generate
+# a larger speckle pattern.
+
+material_data = blender.MaterialData()
+speckle_path = dataset.dic_pattern_5mpx_path()
+mm_px_resolution = sens.CameraTools.calculate_mm_px_resolution(cam_data)
+scene.add_speckle(part=part,
+                    speckle_path=speckle_path,
+                    mat_data=material_data,
+                    mm_px_resolution=mm_px_resolution)
+
+# %%
+# Deforming the sample and rendering images
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+# Once all the objects have been added to the scene, the sample can be deformed,
+# and images can be rendered.
+# Firstly, all the rendering parameters must be set, including parameters such as
+# the number of threads to use.
+
+render_data = blender.RenderData(cam_data=cam_data,
+                                 base_dir=base_dir,
+                                 threads=8)
+
+# %%
+# A series of deformed images can then be rendered.
+# This is done by passing in rendering parameters, as well as the
+# `RenderMeshData` object, the part(sample) and the spatial dimension of the
+# simulation.
+# This will automatically deform the sample, and render subsequent images at
+# each deformation timestep.
+# If `stage_image` is set to True, the image will be saved to disk, converted to
+# an array, deleted and the image array will be returned. This is due to the
+# fact that an image cannot be saved directly as an array through Blender.
+
+scene.render_deformed_images(render_mesh,
+                             sim_spat_dim=3,
+                             render_data=render_data,
+                             part=part,
+                             stage_image=False)
+
+# %%
+# The rendered image will be saved to this filepath:
+
+print("Save directory of the image:", (render_data.base_dir / "blenderimages"))
+
+# %%
+# There is also the option to save the scene as a Blender project file.
+# This file can be opened with the Blender GUI to view the scene.
+
+blender.Tools.save_blender_file(base_dir)

pyvale/examples/dic/ex1_region_of_interest.py

@@ -15,14 +15,17 @@ This example looks at the current core functionality of the Region of Interest
 """
 
 from pathlib import Path
-import pyvale
+
+# pyvale modules
+import pyvale.dataset as dataset
+import pyvale.dic as dic
 
 # %% 
 # We'll begin by selecting our Region of Interest (ROI) using the interactive selection tool.
 # First, we create an instance of the ROI class. We pass a reference image to it, which is
 # displayed as the underlay during ROI selection.
-ref_img = pyvale.DataSet.dic_plate_with_hole_ref()
-roi = pyvale.DICRegionOfInterest(ref_image=ref_img)
+ref_img = dataset.dic_plate_with_hole_ref()
+roi = dic.RegionOfInterest(ref_image=ref_img)
 roi.interactive_selection(subset_size=31)
 
 # create a directory for the the different outputs

pyvale/examples/dic/ex2_plate_with_hole.py

@@ -16,7 +16,10 @@ allowing for comparison to analytically known values.
 
 import matplotlib.pyplot as plt
 from pathlib import Path
-import pyvale
+
+# pyvale modules
+import pyvale.dataset as dataset
+import pyvale.dic as dic
 
 # %%
 # We'll start by defining some variables that will be reused throughout the example:
@@ -29,8 +32,8 @@ import pyvale
 # The images used here are included in the `data <https://github.com/Computer-Aided-Validation-Laboratory/pyvale/tree/main/src/pyvale/data>`_ folder.
 # We've provided helper functions to load them regardless of your installation path.
 subset_size = 31
-ref_img = pyvale.DataSet.dic_plate_with_hole_ref()
-def_img = pyvale.DataSet.dic_plate_with_hole_def()
+ref_img = dataset.dic_plate_with_hole_ref()
+def_img = dataset.dic_plate_with_hole_def()
 
 # create a directory for the the different outputs
 output_path = Path.cwd() / "pyvale-output"
@@ -42,7 +45,7 @@ if not output_path.is_dir():
 # Create an instance of the ROI class and pass the reference image
 # as input. This image will be shown as the underlay during any ROI selection or
 # visualization.
-roi = pyvale.DICRegionOfInterest(ref_img)
+roi = dic.RegionOfInterest(ref_img)
 roi.interactive_selection(subset_size)
 
 # %%
@@ -77,22 +80,22 @@ roi.read_array(filename=roi_file, binary=False)
 # At present, the DIC engine doesn't return any results to the user, instead the results are saved to disk.
 # You can customize the filename, location, format, and delimiter using 
 # the options options `output_basepath`, `output_prefix`, `output_delimiter`, and `output_binary`.
-# More info on these options can be found in the documentation for :func:`pyvale.dic_2d`.
+# More info on these options can be found in the documentation for :func:`dic.two_dimensional`.
 # By default, the results will be saved with the prefix `dic_results_` followed
 # by the original filename. The file extension will be replaced will either ".csv" or "dic2d"
 # depending on whether the results are being saved in human-readable or binary format.
-pyvale.dic_2d(reference=ref_img,
-              deformed=def_img,
-              roi_mask=roi.mask,
-              seed=roi.seed,
-              subset_size=subset_size,
-              subset_step=10,
-              shape_function="AFFINE",
-              max_displacement=10,
-              correlation_criteria="ZNSSD",
-              output_basepath=output_path,
-              output_delimiter=",",
-              output_prefix="dic_results_")
+dic.two_dimensional(reference=ref_img,
+                    deformed=def_img,
+                    roi_mask=roi.mask,
+                    seed=roi.seed,
+                    subset_size=subset_size,
+                    subset_step=10,
+                    shape_function="AFFINE",
+                    max_displacement=10,
+                    correlation_criteria="ZNSSD",
+                    output_basepath=output_path,
+                    output_delimiter=",",
+                    output_prefix="dic_results_")
 
 # %%
 # If you saved the results in a human-readable format, you can use any tool
@@ -104,7 +107,7 @@ pyvale.dic_2d(reference=ref_img,
 # The returned object is an instance of :class:`pyvale.DICResults`. If the results
 # were saved in binary format or with a custom delimiter, be sure to specify those parameters.
 dic_files = output_path / "dic_results_*.csv"
-dicdata = pyvale.dic_data_import(data=dic_files, delimiter=",", binary=False)
+dicdata = dic.data_import(data=dic_files, delimiter=",", binary=False)
 
 # %%
 # As an example, here's a simple visualization of the displacement (u, v) and

pyvale/examples/dic/ex3_plate_with_hole_strain.py

@@ -17,7 +17,9 @@ be used for strain calculations.
 
 import matplotlib.pyplot as plt
 from pathlib import Path
-import pyvale
+
+# pyvale modules
+import pyvale.dic as dic
 
 # %%
 # We'll start by importing the DIC data from the previous example.
@@ -46,8 +48,8 @@ input_data = output_path / "dic_results_*.csv"
 # The output will always include the window coordinates and the full deformation
 # gradient tensor. If you also specify a `strain_formulation`, the corresponding
 # 2D strain tensor will be included in the output.
-pyvale.strain_2d(data=input_data, window_size=5, window_element=4,
-                 output_basepath=output_path)
+dic.strain_two_dimensional(data=input_data, window_size=5, window_element=4,
+                           output_basepath=output_path)
 
 # %%
 # Once the strain calculation is complete, you can import the results using
@@ -55,9 +57,9 @@ pyvale.strain_2d(data=input_data, window_size=5, window_element=4,
 #
 # Be sure to specify the delimiter, format (binary or not), and layout.
 strain_output = output_path / "strain_dic_results_*.csv"
-straindata = pyvale.strain_data_import(data=strain_output,
-                                       binary=False, delimiter=",",
-                                       layout="matrix")
+straindata = dic.strain_data_import(data=strain_output,
+                                    binary=False, delimiter=",",
+                                    layout="matrix")
 
 # %%
 # Here's a simple example of how to visualize the deformation gradient components