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

pyvale/examples/mooseherder/ex7d_readconfig_multi_gmshmoose_results.py

@@ -0,0 +1,143 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Using read config to extract specific variables from a sweep
+================================================================================
+
+In this example we are going to use a read configuration object to control what
+variables are read from our simulation output. This is useful for when we might
+only want to read a subset of the simulation data for post-processing. For
+example a post processor like 'max_temp' from 'glob_vars' without reading in the
+full temperature field. This can help save memory when reading in data from
+large sweeps.
+
+**Installing moose**: To run this example you will need to have installed moose
+on your system. As moose supports unix operating systems windows users will need
+to use windows subsystem for linux (WSL). We use the proteus moose build which
+can be found here: https://github.com/aurora-multiphysics/proteus. Build scripts
+for common linux distributions can be found in the 'scripts' directory of the
+repo. You can also create your own moose build using instructions here:
+https://mooseframework.inl.gov/.
+
+We start by importing what we need for this example.
+"""
+
+import time
+from pathlib import Path
+import numpy as np
+
+#pyvale imports
+import pyvale.dataset as dataset
+from pyvale.mooseherder import (MooseHerd,
+                                MooseRunner,
+                                MooseConfig,
+                                InputModifier,
+                                DirectoryManager,
+                                ExodusReader,
+                                SweepReader,
+                                sweep_param_grid)
+
+#%%
+# The first part of this example is the same as our previous example called:
+# 'Using multiple calls to run parallel sweeps'. For a detailed explanation of
+# the code below head to that example. For now we use this to generate multiple
+# sets of outputs and then use a sweep reader to read this all in below.
+
+moose_input = dataset.element_case_input_path(dataset.EElemTest.HEX20)
+moose_modifier = InputModifier(moose_input,'#','')
+
+config = {'main_path': Path.home()/ 'moose',
+        'app_path': Path.home() / 'proteus',
+        'app_name': 'proteus-opt'}
+moose_config = MooseConfig(config)
+
+moose_runner = MooseRunner(moose_config)
+moose_runner.set_run_opts(n_tasks = 1,
+                          n_threads = 2,
+                          redirect_out = True)
+
+num_para_sims: int = 4
+dir_manager = DirectoryManager(n_dirs=num_para_sims)
+herd = MooseHerd([moose_runner],[moose_modifier],dir_manager)
+herd.set_num_para_sims(n_para=num_para_sims)
+
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+dir_manager.set_base_dir(output_path)
+dir_manager.reset_dirs()
+
+moose_params = {"nElemX": (2,3),
+                "lengX": np.array([10e-3,15e-3]),
+                "PRatio":(0.3,)}
+params = [moose_params,]
+sweep_params = sweep_param_grid(params)
+
+print("\nParameter sweep variables by simulation:")
+for ii,pp in enumerate(sweep_params):
+    print(f"Sim: {ii}, Params [moose,]: {pp}")
+
+num_para_runs: int = 3
+if __name__ == '__main__':
+    sweep_times = np.zeros((num_para_runs,),dtype=np.float64)
+    for rr in range(num_para_runs):
+        herd.run_para(sweep_params)
+        sweep_times[rr] = herd.get_sweep_time()
+
+print()
+for ii,ss in enumerate(sweep_times):
+    print(f"Sweep {ii} took: {ss:.3f}seconds")
+print()
+
+
+#%%
+# Now we create a sweep reader as we have done before and we will use this to
+# read the json keys containing the paths to all the output files. The output
+# file paths have the same list of lists structure we get when we read the
+# sweep data where the outer list corresponds to the unique simulation chain and
+# the inner list corresponds to position of the specific simulation tool in the
+# chain.
+#
+
+sweep_reader = SweepReader(dir_manager,num_para_read=4)
+output_file_paths = sweep_reader.read_all_output_file_keys()
+
+
+#%%
+# When we used a read configuration with our exodus reader previously we saw
+# that it can be simpler to get the read configuration that covers everything
+# in our file and then edit it to extract what we want. Here we are use our
+# exodus reader to extract the read configuration fo the first simulation.
+# We also get the original sim data so we can compare to the case when we use
+# a read configuration to control what we read.
+#
+# Now we want to edit the read configuration so that we only read every second
+# time step from our simulation output files. We do this by getting the
+# original time steps with our exodus reader and then using this to change the
+# ``time_inds`` field of our read configuration to extract every second step.
+exodus_reader = ExodusReader(output_file_paths[0][0])
+sim_data_orig = exodus_reader.read_all_sim_data()
+
+read_config = exodus_reader.get_read_config()
+sim_time = exodus_reader.get_time()
+read_config.time_inds = np.arange(0,sim_time.shape[0],2)
+
+#%%
+# Now we read the sweep results using our read configuration and then check
+# extracted simulation data object to see that we have every second time step.
+sweep_results_seq = sweep_reader.read_sequential(read_config=read_config)
+
+print("Comparison of time steps extracted:")
+print()
+print(f"{sim_data_orig.time.shape=}")
+print(f"{sweep_results_seq[0][0].time.shape=}")
+print()
+print(f"{sim_data_orig.node_vars['disp_x'].shape=}")
+print(f"{sweep_results_seq[0][0].node_vars['disp_x'].shape=}")
+print()
+

pyvale/examples/mooseherder/ex8_read_existing_sweep_output.py

@@ -0,0 +1,72 @@
+# =============================================================================="ctrl+p"
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Reading results from a pre-run parameter sweep
+================================================================================
+
+In this example we will read in the output of a parameter sweep performed by the
+'herd' workflow manager specifically showing how we can read a sweep if we don't
+have the original directory manager.
+
+**NOTE**: this example assumes you have run one of the previous examples using
+the herd workflow manager and that there is a series of output simulation
+working directories in the pyvale-output directory. If not please run the
+example called 'Running a parameter sweep of a MOOSE simulation' first.
+
+We start by importing what we need for this example.
+"""
+import time
+from pprint import pprint
+from pathlib import Path
+from pyvale.mooseherder import DirectoryManager
+from pyvale.mooseherder import SweepReader
+
+#%%
+# First we create a directory manager and pass it our standard pyvale output
+# directory where our simulation sweep output is. The number of directories here
+# is not critical as long as it is equal to or larger than the number of working
+# directories you used when you ran your sweep it will find all simulation
+# outputs that exist in the working directories.
+output_base_path = Path.cwd() / "pyvale-output"
+dir_manager = DirectoryManager(n_dirs=4)
+dir_manager.set_base_dir(output_base_path)
+
+#%%
+# We now pass the directory manager into a sweep reader setting the option to
+# read our sweep output in parallel. Note that for small output files reading
+# the output in parallel will probably be slower than reading sequentially so
+# make sure you test the reader for your particular case.
+#
+# We then use the reader extract the list of list of output file paths and the
+# combinations of variables that were used for this parameter sweep.
+sweep_reader = SweepReader(dir_manager,num_para_read=4)
+
+output_files = sweep_reader.read_all_output_file_keys()
+sweep_variables = sweep_reader.read_all_sweep_var_files()
+
+print('Output files in json keys:')
+pprint(sweep_reader.read_all_output_file_keys())
+print()
+
+print('Parameter sweep variables found:')
+pprint(sweep_reader.read_all_sweep_var_files())
+print()
+
+#%%
+# Now we use our sweep reader to read in the existing sweep results. We can also
+# use a read configuration here if we want to filter out specific parts of the
+# simulation output but for now we will read all of the data.
+
+if __name__ == '__main__':
+    start_time = time.perf_counter()
+    sweep_data = sweep_reader.read_results_para()
+    read_time_para = time.perf_counter() - start_time
+
+print("-"*80)
+print(f'Number of simulations outputs read: {len(sweep_data):d}')
+print(f'Read time parallel   = {read_time_para:.6f} seconds')
+print("-"*80)

pyvale/examples/renderblender/ex1_1_blenderscene.py

@@ -5,7 +5,7 @@
 # ==============================================================================
 
 """
-Blender example: Creating a scene with 2D DIC
+Creating a scene with 2D DIC
 ---------------------------------------------
 
 This example takes you through creating a scene and adding all the necessary
@@ -18,8 +18,12 @@ 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
-import pyvale
-import mooseherder as mh
+
+#pyvale modules
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
+import pyvale.blender as blender
+import pyvale.mooseherder as mh
 
 # %%
 # Here we load in a pre-generated MOOSE finite element simulation dataset that
@@ -29,7 +33,7 @@ import mooseherder as mh
 # format (*.e). `mooseherder` is then used to convert the simulation output
 # into a `SimData` object.
 
-data_path = pyvale.DataSet.render_mechanical_3d_path()
+data_path = dataset.render_mechanical_3d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 # %%
@@ -40,11 +44,11 @@ sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 # 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 = pyvale.scale_length_units(scale=1000.0,
+sim_data = sens.scale_length_units(scale=1000.0,
                                      sim_data=sim_data,
                                      disp_comps=disp_comps)
 
-render_mesh = pyvale.create_render_mesh(sim_data,
+render_mesh = sens.create_render_mesh(sim_data,
                                         ("disp_y","disp_x"),
                                         sim_spat_dim=3,
                                         field_disp_keys=disp_comps)
@@ -64,10 +68,10 @@ base_dir = Path.cwd()
 # In order to create a DIC setup in Blender, first a scene must be created.
 # A scene is a holding space for all of your objects (e.g. camera(s), light(s)
 # and sample(s)).
-# A scene is initialised using the `BlenderScene` class. All the subsequent
+# A scene is initialised using the `blender.Scene` class. All the subsequent
 # objects and actions necessary are then methods of this class.
 
-scene = pyvale.BlenderScene()
+scene = blender.Scene()
 
 # %%
 # The next thing that can be added to the scene is a sample.
@@ -79,10 +83,10 @@ scene = pyvale.BlenderScene()
 part = scene.add_part(render_mesh, sim_spat_dim=3)
 # Set the part location
 part_location = np.array([0, 0, 0])
-pyvale.BlenderTools.move_blender_obj(part=part, pos_world=part_location)
+blender.Tools.move_blender_obj(part=part, pos_world=part_location)
 # Set part rotation
 part_rotation = Rotation.from_euler("xyz", [0, 0, 0], degrees=True)
-pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
+blender.Tools.rotate_blender_obj(part=part, rot_world=part_rotation)
 
 # %%
 # A camera can then be added to the scene.
@@ -91,7 +95,7 @@ pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
 # This camera can then be added to the Blender scene.
 # The camera can also be moved and rotated.
 
-cam_data = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
+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]),
@@ -106,10 +110,10 @@ camera.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
 # Blender offers different light types: Point, Sun, Spot and Area.
 # The light can also be moved and rotated like the camera.
 
-light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
-                                     pos_world=(0, 0, 400),
-                                     rot_world=Rotation.from_euler("xyz",
-                                                                   [0, 0, 0]),
+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)
@@ -126,10 +130,10 @@ light.rotation_euler = (0, 0, 0)
 # It should be noted that for a bigger camera or sample you may need to generate
 # a larger speckle pattern.
 
-material_data = pyvale.BlenderMaterialData()
-speckle_path = pyvale.DataSet.dic_pattern_5mpx_path()
+material_data = blender.MaterialData()
+speckle_path = dataset.dic_pattern_5mpx_path()
 
-mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data)
+mm_px_resolution = sens.CameraTools.calculate_mm_px_resolution(cam_data)
 scene.add_speckle(part=part,
                   speckle_path=speckle_path,
                   mat_data=material_data,
@@ -142,7 +146,7 @@ scene.add_speckle(part=part,
 # Firstly, all the rendering parameters must be set, including parameters such as
 # the number of threads to use.
 
-render_data = pyvale.RenderData(cam_data=cam_data,
+render_data = blender.RenderData(cam_data=cam_data,
                                 base_dir=base_dir,
                                 threads=8)
 
@@ -164,5 +168,5 @@ 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.
 
-pyvale.BlenderTools.save_blender_file(base_dir)
+blender.Tools.save_blender_file(base_dir)
 

pyvale/examples/renderblender/ex1_2_blenderdeformed.py

@@ -5,7 +5,7 @@
 # ==============================================================================
 
 """
-Blender example: Deforming a sample with 2D DIC
+Deforming a sample with 2D DIC
 ===============================================
 
 This example follows a similar workflow to the previous Blender example.
@@ -18,15 +18,19 @@ 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
-import pyvale
-import mooseherder as mh
+
+# 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 = pyvale.DataSet.render_mechanical_3d_path()
+data_path = dataset.render_mechanical_3d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 # %%
@@ -37,11 +41,11 @@ sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 # 3D deformation test case, displacement is expected in the x, y and z directions.
 
 disp_comps = ("disp_x","disp_y", "disp_z")
-sim_data = pyvale.scale_length_units(scale=1000.0,
+sim_data = sens.scale_length_units(scale=1000.0,
                                      sim_data=sim_data,
                                      disp_comps=disp_comps)
 
-render_mesh = pyvale.create_render_mesh(sim_data,
+render_mesh = sens.create_render_mesh(sim_data,
                                         ("disp_y","disp_x"),
                                         sim_spat_dim=3,
                                         field_disp_keys=disp_comps)
@@ -62,7 +66,7 @@ base_dir = Path.cwd()
 # A scene is initialised using the `BlenderScene` class. All the subsequent
 # objects and actions necessary are then methods of this class.
 
-scene = pyvale.BlenderScene()
+scene = blender.Scene()
 
 # %%
 # The next thing that can be added to the scene is a sample.
@@ -75,9 +79,9 @@ scene = pyvale.BlenderScene()
 part = scene.add_part(render_mesh, sim_spat_dim=3)
 # Set the part location
 part_location = np.array([0, 0, 0])
-pyvale.BlenderTools.move_blender_obj(part=part, pos_world=part_location)
+blender.Tools.move_blender_obj(part=part, pos_world=part_location)
 part_rotation = Rotation.from_euler("xyz", [0, 0, 0], degrees=True)
-pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
+blender.Tools.rotate_blender_obj(part=part, rot_world=part_rotation)
 
 # %%
 # A camera can then be added to the scene.
@@ -86,7 +90,7 @@ pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
 # This camera can then be added to the Blender scene.
 # The camera can also be moved and rotated.
 
-cam_data = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
+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]),
@@ -101,7 +105,7 @@ camera.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
 # Blender offers different light types: Point, Sun, Spot and Area.
 # The light can also be moved and rotated like the camera.
 
-light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
+light_data = blender.LightData(type=blender.LightType.POINT,
                                      pos_world=(0, 0, 400),
                                      rot_world=Rotation.from_euler("xyz",
                                                                    [0, 0, 0]),
@@ -121,9 +125,9 @@ light.rotation_euler = (0, 0, 0)
 # It should be noted that for a bigger camera or sample you may need to generate
 # a larger speckle pattern.
 
-material_data = pyvale.BlenderMaterialData()
-speckle_path = pyvale.DataSet.dic_pattern_5mpx_path()
-mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data)
+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,
@@ -137,9 +141,9 @@ scene.add_speckle(part=part,
 # Firstly, all the rendering parameters must be set, including parameters such as
 # the number of threads to use.
 
-render_data = pyvale.RenderData(cam_data=cam_data,
-                                base_dir=base_dir,
-                                threads=8)
+render_data = blender.RenderData(cam_data=cam_data,
+                                 base_dir=base_dir,
+                                 threads=8)
 
 # %%
 # A series of deformed images can then be rendered.
@@ -167,4 +171,4 @@ 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.
 
-pyvale.BlenderTools.save_blender_file(base_dir)
+blender.Tools.save_blender_file(base_dir)

pyvale/examples/renderblender/ex2_1_stereoscene.py

@@ -5,7 +5,7 @@
 # ==============================================================================
 
 """
-Blender example: Creating a scene with stereo DIC
+Creating a scene with stereo DIC
 -------------------------------------------------
 
 This example takes you through creating a scene and adding all the necessary
@@ -18,15 +18,19 @@ 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
-import pyvale
-import mooseherder as mh
+
+# 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 = pyvale.DataSet.render_mechanical_3d_path()
+data_path = dataset.render_mechanical_3d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 # %%
@@ -37,11 +41,11 @@ sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 # 3D deformation test case, displacement is expected in the x, y and z directions.
 
 disp_comps = ("disp_x","disp_y", "disp_z")
-sim_data = pyvale.scale_length_units(scale=1000.0,
-                                        sim_data=sim_data,
-                                        disp_comps=disp_comps)
+sim_data = sens.scale_length_units(scale=1000.0,
+                                  sim_data=sim_data,
+                                  disp_comps=disp_comps)
 
-render_mesh = pyvale.create_render_mesh(sim_data,
+render_mesh = sens.create_render_mesh(sim_data,
                                     ("disp_y","disp_x"),
                                     sim_spat_dim=3,
                                     field_disp_keys=disp_comps)
@@ -59,9 +63,9 @@ 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
+# A scene is initialised using the `blender.Scene` class. All the subsequent
 # objects and actions necessary are then methods of this class.
-scene = pyvale.BlenderScene()
+scene = blender.Scene()
 
 # %%
 # The next thing that can be added to the scene is a sample.
@@ -73,10 +77,10 @@ scene = pyvale.BlenderScene()
 part = scene.add_part(render_mesh, sim_spat_dim=3)
 # Set the part location
 part_location = np.array([0, 0, 0])
-pyvale.BlenderTools.move_blender_obj(part=part, pos_world=part_location)
+blender.Tools.move_blender_obj(part=part, pos_world=part_location)
 # Set part rotation
 part_rotation = Rotation.from_euler("xyz", [0, 0, 0], degrees=True)
-pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
+blender.Tools.rotate_blender_obj(part=part, rot_world=part_rotation)
 
 # %%
 # The cameras can then be initialised. A stereo camera system is defined by a
@@ -95,23 +99,26 @@ pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
 # between the two. The cameras can then be added to the Blender scene using the
 # `add_stereo_system` method.
 
-cam_data_0 = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
-                                pixels_size=np.array([0.00345, 0.00345]),
-                                pos_world=np.array([0, 0, 400]),
-                                rot_world=Rotation.from_euler("xyz", [0, 0, 0]),
-                                roi_cent_world=(0, 0, 0),
-                                focal_length=15.0)
+cam_data_0 = sens.CameraData(pixels_num=np.array([1540, 1040]),
+                            pixels_size=np.array([0.00345, 0.00345]),
+                            pos_world=np.array([0, 0, 400]),
+                            rot_world=Rotation.from_euler("xyz", [0, 0, 0]),
+                            roi_cent_world=(0, 0, 0),
+                            focal_length=15.0)
 # Set this to "symmetric" to get a symmetric stereo system or set this to
 # "faceon" to get a face-on stereo system
 stereo_setup = "faceon"
 if stereo_setup == "symmetric":
-    stereo_system = pyvale.CameraTools.symmetric_stereo_cameras(
+    stereo_system = sens.CameraTools.symmetric_stereo_cameras(
         cam_data_0=cam_data_0,
         stereo_angle=15.0)
-if stereo_setup == "faceon":
-    stereo_system = pyvale.CameraTools.faceon_stereo_cameras(
+elif stereo_setup == "faceon":
+    stereo_system = sens.CameraTools.faceon_stereo_cameras(
         cam_data_0=cam_data_0,
         stereo_angle=15.0)
+else:
+    raise ValueError(f"Unknown stereo_setup: {stereo_setup}")
+
 cam0, cam1 = scene.add_stereo_system(stereo_system)
 
 # %%
@@ -130,7 +137,7 @@ stereo_system.save_calibration(base_dir)
 # Blender offers different light types: Point, Sun, Spot and Area.
 # The light can also be moved and rotated like the camera.
 
-light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
+light_data = blender.LightData(type=blender.LightType.POINT,
                                      pos_world=(0, 0, 400),
                                      rot_world=Rotation.from_euler("xyz",
                                                                    [0, 0, 0]),
@@ -150,10 +157,10 @@ light.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
 # It should be noted that for a bigger camera or sample you may need to generate
 # a larger speckle pattern.
 
-material_data = pyvale.BlenderMaterialData()
-speckle_path = pyvale.DataSet.dic_pattern_5mpx_path()
+material_data = blender.MaterialData()
+speckle_path = dataset.dic_pattern_5mpx_path()
 
-mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data_0)
+mm_px_resolution = sens.CameraTools.calculate_mm_px_resolution(cam_data_0)
 scene.add_speckle(part=part,
                   speckle_path=speckle_path,
                   mat_data=material_data,
@@ -168,10 +175,10 @@ scene.add_speckle(part=part,
 # Differently to a 2D DIC system, both cameras' parameters must be specified in
 # the `RenderData` object.
 
-render_data = pyvale.RenderData(cam_data=(stereo_system.cam_data_0,
+render_data = blender.RenderData(cam_data=(stereo_system.cam_data_0,
                                             stereo_system.cam_data_1),
-                                base_dir=base_dir,
-                                threads=8)
+                                 base_dir=base_dir,
+                                 threads=8)
 
 # %%
 # A single set of images of the scene can then be rendered.
@@ -192,4 +199,4 @@ 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.
 
-pyvale.BlenderTools.save_blender_file(base_dir)
+blender.Tools.save_blender_file(base_dir)