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

pyvale/examples/renderblender/ex2_2_stereodeformed.py

@@ -5,7 +5,7 @@
 # ==============================================================================
 
 """
-Blender example: Deforming a sample with stereo DIC
+Deforming a sample with stereo DIC
 ===================================================
 
 This example takes you through creating stereo DIC scene, applying deformation
@@ -17,15 +17,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()
 
 # %%
@@ -36,11 +40,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)
@@ -60,7 +64,7 @@ base_dir = Path.cwd()
 # 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 = pyvale.BlenderScene()
+scene = blender.Scene()
 
 # %%
 # The next thing that can be added to the scene is a sample.
@@ -72,10 +76,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
@@ -94,7 +98,7 @@ 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]),
+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]),
@@ -104,13 +108,16 @@ cam_data_0 = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
 # "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)
 
 # %%
@@ -128,7 +135,7 @@ stereo_system.save_calibration(base_dir)
 # 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 = 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]),
@@ -138,8 +145,8 @@ light.location = (0, 0, 410)
 light.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
 
 # Apply the 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()
 # NOTE: If you wish to use a bigger camera, you will need to generate a
 # bigger speckle pattern generator
 
@@ -154,7 +161,7 @@ speckle_path = pyvale.DataSet.dic_pattern_5mpx_path()
 # It should be noted that for a bigger camera or sample you may need to generate
 # a larger speckle pattern.
 
-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,
@@ -169,7 +176,7 @@ scene.add_speckle(part=part,
 # the number of threads to use.
 # 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)
@@ -200,5 +207,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/ex3_1_blendercalibration.py

@@ -5,7 +5,7 @@
 # ==============================================================================
 
 """
-Blender example: Rendering calibration images
+Rendering calibration images
 ---------------------------------------------
 
 This example takes you through how to render calibration images for a given DIC
@@ -14,7 +14,11 @@ setup.
 import numpy as np
 from scipy.spatial.transform import Rotation
 from pathlib import Path
-import pyvale
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.blender as blender
+import pyvale.dataset as dataset
 
 # %%
 # Firstly, a save path must be set.
@@ -31,7 +35,7 @@ base_dir = Path.cwd()
 # 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 = pyvale.BlenderScene()
+scene = blender.Scene()
 
 # %%
 # The next thing to add to the scene is the calibration target.
@@ -57,7 +61,7 @@ target = scene.add_cal_target(target_size=np.array([150, 100, 10]))
 # are the camera parameters for the first camera, and the desired stereo angle
 # 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]),
+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]),
@@ -67,13 +71,16 @@ cam_data_0 = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
 # "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}")
+
 scene.add_stereo_system(stereo_system)
 
 # %%
@@ -95,7 +102,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, 200),
                                      rot_world=Rotation.from_euler("xyz",
                                                                   [0, 0, 0]),
@@ -112,11 +119,11 @@ light.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
 # calibration target pattern will not be scaled in the same way as a speckle
 # pattern.
 
-material_data = pyvale.BlenderMaterialData()
-speckle_path = Path.cwd() / "src/pyvale/data/cal_target.tiff"
-mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data_0)
+material_data = blender.MaterialData()
+cal_target = dataset.cal_target()
+mm_px_resolution = sens.CameraTools.calculate_mm_px_resolution(cam_data_0)
 scene.add_speckle(part=target,
-                  speckle_path=speckle_path,
+                  speckle_path=cal_target,
                   mat_data=material_data,
                   mm_px_resolution=mm_px_resolution,
                   cal=True)
@@ -128,7 +135,7 @@ scene.add_speckle(part=target,
 # rendered.Firstly, all the rendering parameters must be set, including
 # parameters such as the number of threads to use.
 
-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)
 
@@ -141,7 +148,7 @@ render_data = pyvale.RenderData(cam_data=(stereo_system.cam_data_0,
 # passed in they will be initialised from the FOV to cover the whole FOV of the
 # cameras.
 
-calibration_data = pyvale.CalibrationData(angle_lims=(-10, 10),
+calibration_data = blender.CalibrationData(angle_lims=(-10, 10),
                                           angle_step=5,
                                           plunge_lims=(-5, 5),
                                           plunge_step=5)
@@ -151,7 +158,7 @@ calibration_data = pyvale.CalibrationData(angle_lims=(-10, 10),
 # rendered before rendering them. The only input that is needed is the
 # `calibration_data` specified above.
 
-number_calibration_images = pyvale.BlenderTools.number_calibration_images(calibration_data)
+number_calibration_images = blender.Tools.number_calibration_images(calibration_data)
 print("Number of calibration images to be rendered:", number_calibration_images)
 
 # %%
@@ -159,7 +166,7 @@ print("Number of calibration images to be rendered:", number_calibration_images)
 # calibration target according to movement limits set above, and will also move
 # the target rigidly across the FOV of the camera, in order to characterise the
 # entire FOV of the cameras.
-pyvale.BlenderTools.render_calibration_images(render_data,
+blender.Tools.render_calibration_images(render_data,
                                               calibration_data,
                                               target)
 
@@ -172,4 +179,4 @@ print("Save directory of the images:", (render_data.base_dir / "calimages"))
 # 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/renderrasterisation/ex_rastenp.py

@@ -10,8 +10,10 @@ 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
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
 
 # TODO
 # - Fix the image averaging function to use cython
@@ -34,17 +36,17 @@ def main() -> None:
     # 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()
+    #sim_path = sens.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(1000.0,sim_data,disp_comps)
+    sim_data = sens.scale_length_units(1000.0,sim_data,disp_comps)
 
     # Extracts the surface mesh from a full 3d simulation for rendering
-    render_mesh = pyv.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,7 +61,7 @@ def main() -> None:
     meshes[1].set_pos(np.array((0.0,12.5,0.0)))
     meshes[1].set_rot(Rotation.from_euler("zyx",(0.0, 0.0, 0.0),degrees=True))
     meshes[1].fields_disp = None
-    coords_all = pyv.get_all_coords_world(meshes)
+    coords_all = sens.get_all_coords_world(meshes)
 
     print()
     print(80*"-")
@@ -85,7 +87,7 @@ def main() -> None:
     fov_scale_factor: float = 1.0
 
     (roi_pos_world,
-     cam_pos_world) = pyv.CameraTools.pos_fill_frame(
+     cam_pos_world) = sens.CameraTools.pos_fill_frame(
          coords_world=coords_all,
          pixel_num=pixel_num,
          pixel_size=pixel_size,
@@ -94,7 +96,7 @@ def main() -> None:
          frame_fill=fov_scale_factor,
      )
 
-    cam_data = pyv.CameraData(
+    cam_data = sens.CameraData(
         pixels_num=pixel_num,
         pixels_size=pixel_size,
         pos_world=cam_pos_world,
@@ -115,7 +117,7 @@ def main() -> None:
     print(cam_data.world_to_cam_mat)
     print(80*"-")
 
-    scene = pyv.RenderScene([cam_data,cam_data],meshes)
+    scene = sens.RenderScene([cam_data,cam_data],meshes)
 
     frames_per_camera = (scene.meshes[0].fields_render.shape[1]
                         *scene.meshes[0].fields_render.shape[2])
@@ -139,8 +141,8 @@ def main() -> None:
     print(80*"=")
     print("IN MEM: Raster Loop start")
 
-    raster_opts = pyv.RasterOpts(parallel=8)
-    renderer = pyv.RasterNumpy(raster_opts)
+    raster_opts = sens.RasterOpts(parallel=8)
+    renderer = sens.RasterNumpy(raster_opts)
 
     time_start_loop = time.perf_counter()
 
@@ -183,7 +185,7 @@ def main() -> None:
 
     plot_on = True
     if plot_on:
-        (fig,ax) = pyv.plot_field_image(images[1][:,:,-1,0],
+        (fig,ax) = sens.plot_field_image(images[1][:,:,-1,0],
                                         title_str="Disp. y, [mm]")
 
     plt.show()

pyvale/examples/renderrasterisation/ex_rastercyth_oneframe.py

@@ -8,15 +8,17 @@ 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
 import imagebenchmarks as ib
 
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
+
 def main() -> None:
     print()
     print(80*"=")
     print("RASTER CYTHON FILE (should be *.so on Linux):")
-    print(pyv.rastercyth.__file__)
+    print(sens.rastercyth.__file__)
     print(80*"=")
     print()
 
@@ -26,14 +28,14 @@ def main() -> None:
         # replaced with a path to your own simulation file
         #sim_path = Path.home()/"pyvale"/"src"/"pyvale"/"simcases"/"case26_out.e"
 
-        sim_path = pyv.DataSet.render_simple_block_path()
-        #sim_path = pyv.DataSet.render_mechanical_3d_path()
+        sim_path = sens.DataSet.render_simple_block_path()
+        #sim_path = sens.DataSet.render_mechanical_3d_path()
         sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
 
         disp_comps = ("disp_x","disp_y","disp_z")
 
         # Scale m -> mm
-        sim_data = pyv.scale_length_units(1000.0,sim_data,disp_comps)
+        sim_data = sens.scale_length_units(1000.0,sim_data,disp_comps)
 
         print()
         print(f"{np.max(np.abs(sim_data.node_vars['disp_x']))=}")
@@ -42,15 +44,12 @@ def main() -> None:
         print()
 
         # Extracts the surface mesh from a full 3d simulation for rendering
-        render_mesh = pyv.create_render_mesh(sim_data,
+        render_mesh = sens.create_render_mesh(sim_data,
                                             ("disp_y","disp_x","disp_z"),
                                             sim_spat_dim=3,
                                             field_disp_keys=disp_comps)
 
 
-
-
-
         pixel_num = np.array((960,1280),dtype=np.int32)
         pixel_size = np.array((5.3e-3,5.3e-3),dtype=np.float64)
         focal_leng: float = 50.0
@@ -58,7 +57,7 @@ def main() -> None:
         fov_scale_factor: float = 1.1
 
         (roi_pos_world,
-        cam_pos_world) = pyv.CameraTools.pos_fill_frame(
+        cam_pos_world) = sens.CameraTools.pos_fill_frame(
             coords_world=render_mesh.coords,
             pixel_num=pixel_num,
             pixel_size=pixel_size,
@@ -67,7 +66,7 @@ def main() -> None:
             frame_fill=fov_scale_factor,
         )
 
-        cam_data = pyv.CameraData(
+        cam_data = sens.CameraData(
             pixels_num=pixel_num,
             pixels_size=pixel_size,
             pos_world=cam_pos_world,
@@ -144,7 +143,7 @@ def main() -> None:
 
         (image_buffer,
          depth_buffer,
-         elems_in_image) = pyv.rastercyth.raster_static_frame(
+         elems_in_image) = sens.rastercyth.raster_static_frame(
                                                 render_mesh.coords,
                                                 render_mesh.connectivity,
                                                 fields_render,
@@ -164,7 +163,7 @@ def main() -> None:
 
     #===========================================================================
     # PLOTTING
-    plot_on = False
+    plot_on = True
     plot_field = 0
 
     # depth_to_plot = np.copy(np.asarray(depth_buffer[:,:,plot_frame]))
@@ -173,7 +172,7 @@ def main() -> None:
     # image_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
 
     if plot_on:
-        plot_opts = pyv.PlotOptsGeneral()
+        plot_opts = sens.PlotOptsGeneral()
 
 
         (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,

pyvale/examples/renderrasterisation/ex_rastercyth_static_cypara.py

@@ -9,26 +9,28 @@ 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
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
 
 def main() -> None:
     print()
     print(80*"=")
     print("RASTER CYTHON FILE (should be *.so on Linux):")
-    print(pyv.rastercyth.__file__)
+    print(sens.rastercyth.__file__)
     print(80*"=")
     print()
 
-    sim_path = pyv.DataSet.render_mechanical_3d_path()
-    #sim_path = pyv.DataSet.render_simple_block_path()
+    sim_path = sens.DataSet.render_mechanical_3d_path()
+    #sim_path = sens.DataSet.render_simple_block_path()
     #sim_path = Path.home()/"pyvale"/"src"/"pyvale"/"simcases"/"case26_out.e"
     sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
 
     disp_comps = ("disp_x","disp_y","disp_z")
 
     # Scale m -> mm
-    sim_data = pyv.scale_length_units(1000.0,sim_data,disp_comps)
+    sim_data = sens.scale_length_units(1000.0,sim_data,disp_comps)
 
     print()
     print(f"{np.max(np.abs(sim_data.node_vars['disp_x']))=}")
@@ -37,7 +39,7 @@ def main() -> None:
     print()
 
     # Extracts the surface mesh from a full 3d simulation for rendering
-    render_mesh = pyv.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)
@@ -66,7 +68,7 @@ def main() -> None:
     fov_scale_factor: float = 1.1
 
     (roi_pos_world,
-     cam_pos_world) = pyv.CameraTools.pos_fill_frame(
+     cam_pos_world) = sens.CameraTools.pos_fill_frame(
          coords_world=render_mesh.coords,
          pixel_num=pixel_num,
          pixel_size=pixel_size,
@@ -75,7 +77,7 @@ def main() -> None:
          frame_fill=fov_scale_factor,
      )
 
-    cam_data = pyv.CameraData(
+    cam_data = sens.CameraData(
         pixels_num=pixel_num,
         pixels_size=pixel_size,
         pos_world=cam_pos_world,
@@ -120,7 +122,7 @@ def main() -> None:
 
         (image_buffer,
          depth_buffer,
-         elems_in_image) = pyv.rastercyth.raster_static_mesh(
+         elems_in_image) = sens.rastercyth.raster_static_mesh(
                                                 render_mesh,
                                                 cam_data,
                                                 0)
@@ -149,7 +151,7 @@ def main() -> None:
     # image_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
 
     if plot_on:
-        plot_opts = pyv.PlotOptsGeneral()
+        plot_opts = sens.PlotOptsGeneral()
 
         for ff in plot_frames:
             (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,

pyvale/examples/renderrasterisation/ex_rastercyth_static_pypara.py

@@ -8,29 +8,31 @@ 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
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
 
 
 def main() -> None:
     print()
     print(80*"=")
     print("RASTER CYTHON FILE (should be *.so on Linux):")
-    print(pyv.rastercyth.__file__)
+    print(sens.rastercyth.__file__)
     print(80*"=")
     print()
 
     # 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 = pyv.DataSet.render_mechanical_3d_path()
-    #sim_path = pyv.DataSet.render_simple_block_path()
+    sim_path = sens.DataSet.render_mechanical_3d_path()
+    #sim_path = sens.DataSet.render_simple_block_path()
     #sim_path = Path.home()/"pyvale"/"src"/"pyvale"/"simcases"/"case26_out.e"
     sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
 
     disp_comps = ("disp_x","disp_y","disp_z")
 
     # Scale m -> mm
-    sim_data = pyv.scale_length_units(1000.0,sim_data,disp_comps)
+    sim_data = sens.scale_length_units(1000.0,sim_data,disp_comps)
 
     print()
     print(f"{np.max(np.abs(sim_data.node_vars['disp_x']))=}")
@@ -39,7 +41,7 @@ def main() -> None:
     print()
 
     # Extracts the surface mesh from a full 3d simulation for rendering
-    render_mesh = pyv.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)
@@ -68,7 +70,7 @@ def main() -> None:
     fov_scale_factor: float = 1.1
 
     (roi_pos_world,
-     cam_pos_world) = pyv.CameraTools.pos_fill_frame(
+     cam_pos_world) = sens.CameraTools.pos_fill_frame(
          coords_world=render_mesh.coords,
          pixel_num=pixel_num,
          pixel_size=pixel_size,
@@ -77,7 +79,7 @@ def main() -> None:
          frame_fill=fov_scale_factor,
      )
 
-    cam_data = pyv.CameraData(
+    cam_data = sens.CameraData(
         pixels_num=pixel_num,
         pixels_size=pixel_size,
         pos_world=cam_pos_world,
@@ -122,7 +124,7 @@ def main() -> None:
 
         (image_buffer,
          depth_buffer,
-         elems_in_images) = pyv.RasterCY.raster_static_mesh(cam_data,
+         elems_in_images) = sens.RasterCY.raster_static_mesh(cam_data,
                                                             render_mesh,
                                                             16)
 
@@ -150,7 +152,7 @@ def main() -> None:
     # image_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
 
     if plot_on:
-        plot_opts = pyv.PlotOptsGeneral()
+        plot_opts = sens.PlotOptsGeneral()
 
         for ff in plot_frames:
             (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,

pyvale/mooseherder/__init__.py

@@ -0,0 +1,32 @@
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+
+from .inputmodifier import InputModifier
+from .simrunner import SimRunner
+from .mooserunner import MooseRunner
+from .gmshrunner import GmshRunner
+from .exodusreader import ExodusReader
+from .mooseherd import MooseHerd
+from .directorymanager import DirectoryManager
+from .sweepreader import SweepReader
+from .simdata import SimData
+from .simdata import SimReadConfig
+from .mooseconfig import MooseConfig
+from .sweeptools import sweep_param_grid
+
+
+__all__ = ["InputModifier",
+            "SimRunner",
+            "MooseRunner",
+            "GmshRunner",
+            "ExodusReader",
+            "mooseherd",
+            "DirectoryManager",
+            "SweepReader",
+            "SimData",
+            "SimReadConfig",
+            "MooseConfig",
+            "sweep_param_grid"]