pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.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,
+                                ExodusLoader,
+                                SweepLoader,
+                                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 = SweepLoader(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 = ExodusLoader(output_file_paths[0][0])
+sim_data_orig = exodus_reader.load_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 SweepLoader
+
+#%%
+# 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 = SweepLoader(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/rasterimagedef/ex_rastenp.py

@@ -0,0 +1,194 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from pathlib import Path
+import copy
+import time
+import numpy as np
+from scipy.spatial.transform import Rotation
+import matplotlib.pyplot as plt
+
+# pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
+
+# 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:
+    """Basics rasterisation field renderer
+    ----------------------------------------------------------------------------
+    """
+    # 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 = sens.DataSet.render_mechanical_3d_path()
+
+    disp_comps = ("disp_x","disp_y","disp_z")
+
+    sim_data = mh.ExodusLoader(sim_path).load_all_sim_data()
+
+    # Scale m -> mm
+    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 = sens.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+    #===========================================================================
+    # render_mesh.fields_render = render_mesh.fields_render[:,-2:-1,:]
+    # render_mesh.fields_disp = render_mesh.fields_disp[:,-2:-1,:]
+    # render_mesh.fields_disp = None
+    #===========================================================================
+
+    meshes = [render_mesh,copy.deepcopy(render_mesh)]
+    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 = sens.get_all_coords_world(meshes)
+
+    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, 0.0, -30.0),degrees=True)
+    fov_scale_factor: float = 1.0
+
+    (roi_pos_world,
+     cam_pos_world) = sens.CameraTools.pos_fill_frame(
+         coords_world=coords_all,
+         pixel_num=pixel_num,
+         pixel_size=pixel_size,
+         focal_leng=focal_leng,
+         cam_rot=cam_rot,
+         frame_fill=fov_scale_factor,
+     )
+
+    cam_data = sens.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*"-")
+
+    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])
+    frames_total = frames_per_camera*len(scene.cameras)
+
+    print(80*"-")
+    print("RENDER SCENE:")
+    print(f"Cameras #: {len(scene.cameras)}")
+    print(f"Meshes #:  {len(scene.meshes)}")
+    print()
+    print(f"Time steps: {scene.meshes[0].fields_render.shape[1]}")
+    print(f"Field #:    {scene.meshes[0].fields_render.shape[2]}")
+    print()
+    print(f"Frames per camera: {frames_per_camera}")
+    print(f"Frames total:      {frames_total}")
+    print(80*"-")
+
+
+    #===========================================================================
+    print()
+    print(80*"=")
+    print("IN MEM: Raster Loop start")
+
+    raster_opts = sens.RasterOpts(parallel=8)
+    renderer = sens.RasterNumpy(raster_opts)
+
+    time_start_loop = time.perf_counter()
+
+    images = renderer.render_all(scene)
+
+    time_end_loop = time.perf_counter()
+    time_inmem = time_end_loop - time_start_loop
+
+    print(f"{images[0].shape=}")
+    print(f"{images[1].shape=}")
+    print("IN MEM: Raster Loop End")
+    print(80*"=")
+
+
+    print(80*"=")
+    print("TO DISK: Raster Loop start")
+    save_path = Path.cwd()/"pyvale-output"
+    if not save_path.is_dir():
+        save_path.mkdir(parents=True, exist_ok=True)
+
+    time_start_loop = time.perf_counter()
+
+    renderer.render_all_to_disk(scene,save_path)
+
+    time_end_loop = time.perf_counter()
+    time_to_disk = time_end_loop - time_start_loop
+
+    print("TO DISK: Raster Loop End")
+    print(80*"=")
+
+
+    print("PERFORMANCE")
+    print(f"Total frames = {frames_total}")
+    print(f"IN MEM: Total render time = {time_inmem:.4f} s")
+    print(f"IN MEM: Time per frame = {(time_inmem/frames_total):.4f} s")
+    print(f"TO DISK: Total render time = {time_to_disk:.4f} s")
+    print(f"TO DISK: Time per frame = {(time_to_disk/frames_total):.4f} s")
+    print(80*"=")
+
+
+    plot_on = True
+    if plot_on:
+        (fig,ax) = sens.plot_field_image(images[1][:,:,-1,0],
+                                        title_str="Disp. y, [mm]")
+
+    plt.show()
+
+if __name__ == "__main__":
+    main()

pyvale/examples/rasterimagedef/ex_rastercyth_oneframe.py

@@ -0,0 +1,206 @@
+# ==============================================================================
+# 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
+
+# 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(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 = Path.home()/"pyvale"/"src"/"pyvale"/"simcases"/"case26_out.e"
+
+    #sim_path = sens.dataset.render_simple_block_path()
+    #sim_path = sens.dataSet.render_mechanical_3d_path()
+    sim_data = mh.ExodusLoader(sim_path).load_all_sim_data()
+
+    disp_comps = ("disp_x","disp_y","disp_z")
+
+    # Scale m -> mm
+    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']))=}")
+    print(f"{np.max(np.abs(sim_data.node_vars['disp_y']))=}")
+    print(f"{np.max(np.abs(sim_data.node_vars['disp_z']))=}")
+    print()
+
+    # Extracts the surface mesh from a full 3d simulation for rendering
+    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
+    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) = sens.CameraTools.pos_fill_frame(
+        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 = sens.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,
+    )
+
+    # case_ind = 0
+    # (case_ident,render_mesh,cam_data) = ib.load_benchmark_by_index(case_ind)
+    # print(80*"=")
+    # print("BENCHMARK IDENTIFIER:")
+    # print(f"{case_ident}")
+    # print(80*"=")
+
+
+    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()
+
+    print(80*"-")
+    print("CAMERA DATA:")
+    print(80*"-")
+    print(f"{cam_data.image_dist=}")
+    print(f"{cam_data.roi_cent_world=}")
+    print(f"{cam_data.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(80*"=")
+    print("RASTER ELEMENT LOOP START")
+    print(80*"=")
+
+    num_loops = 1
+
+    loop_times = np.zeros((num_loops,),dtype=np.float64)
+
+    frame = -1
+    fields_render = render_mesh.fields_render[:,frame,:]
+    total_frames = fields_render.shape[1]
+
+    print()
+    print("Running raster loop.")
+    for nn in range(num_loops):
+        print(f"Running loop {nn}")
+        loop_start = time.perf_counter()
+
+        (image_buffer,
+         depth_buffer,
+         elems_in_image) = sens.rastercyth.raster_static_frame(
+                                                render_mesh.coords,
+                                                render_mesh.connectivity,
+                                                fields_render,
+                                                cam_data)
+
+        loop_times[nn] = time.perf_counter() - loop_start
+
+    print()
+    print(80*"=")
+    print("PERFORMANCE TIMERS")
+    print(f"Elements in image = {elems_in_image}")
+    print(f"Image buffer shape = {image_buffer.shape}")
+    print(f"Avg. total render time = {np.mean(loop_times):.4f} seconds")
+    print(f"Avg. render time per frame = {(np.mean(loop_times)/total_frames):.4f} seconds")
+    print(80*"=")
+
+
+    #===========================================================================
+    # PLOTTING
+    plot_on = True
+    plot_field = 0
+
+    # depth_to_plot = np.copy(np.asarray(depth_buffer[:,:,plot_frame]))
+    # depth_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
+    # image_to_plot = np.copy(np.asarray(image_buffer[:,:,plot_frame,plot_field]))
+    # image_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
+
+    if plot_on:
+        plot_opts = sens.PlotOptsGeneral()
+
+
+        (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,
+                                layout='constrained')
+        fig.set_dpi(plot_opts.resolution)
+        cset = plt.imshow(depth_buffer[:,:],
+                        cmap=plt.get_cmap(plot_opts.cmap_seq))
+                        #origin='lower')
+        ax.set_aspect('equal','box')
+        fig.colorbar(cset)
+        ax.set_title(f"Depth buffer",fontsize=plot_opts.font_head_size)
+        ax.set_xlabel(r"x ($px$)",
+                    fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+        ax.set_ylabel(r"y ($px$)",
+                    fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+        (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,
+                                layout='constrained')
+        fig.set_dpi(plot_opts.resolution)
+        cset = plt.imshow(image_buffer[:,:,plot_field],
+                        cmap=plt.get_cmap(plot_opts.cmap_seq))
+                        #origin='lower')
+        ax.set_aspect('equal','box')
+        fig.colorbar(cset)
+        ax.set_title(f"Field Image",fontsize=plot_opts.font_head_size)
+        ax.set_xlabel(r"x ($px$)",
+                    fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+        ax.set_ylabel(r"y ($px$)",
+                    fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+        plt.show()
+
+
+if __name__ == "__main__":
+    main()