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

pyvale/examples/mooseherder/ex7b_read_multi_herd_results.py

@@ -0,0 +1,116 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Read parameter sweep results for a MOOSE simulation
+================================================================================
+
+In this example we read the all the simulation results from multiple calls to
+her workflow manager and verify that we correctly read all of the simulation
+outputs.
+
+**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,
+                                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()
+
+#%%
+# Here we will just read all the results sequentially and verify that we have
+# the number of simulation results we expect for the multiple calls above.
+# Looking at our parameter sweep we have 4 unique combination of variables and
+# we ran this 3 times so we expect to have a total of 12 simulation results in
+# our outer list which we print below. Note that our inner list still has a
+# single ``SimData`` object as we only have a single moose simulation in our
+# simulation chain.
+sweep_reader = SweepReader(dir_manager)
+start_time = time.perf_counter()
+sweep_results_seq = sweep_reader.read_sequential()
+read_time_seq = time.perf_counter() - start_time
+
+print("Outer list = unique simulation chain:")
+print(f"    {len(sweep_results_seq)=}")
+print("Inner list = particular simulation tool in the chain:")
+print(f"    {len(sweep_results_seq[0])=}")
+print("'SimData' object for the particular simulation tool:")
+print(f"    {type(sweep_results_seq[0][0])=}")
+print()
+
+print(f'Read time (sequential) = {read_time_seq:.6f} seconds')
+

pyvale/examples/mooseherder/ex7c_read_multi_gmshmoose_results.py

@@ -0,0 +1,127 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Read parameter sweep results for a Gmsh and MOOSE simulation
+================================================================================
+
+In this example we will read the results from a sweep that includes gmsh and
+moose in the simulation chain. A key difference here in the results output is
+that gmsh does not create output we want to read so the inner list of our
+results list of lists will have 'None' in its 0 index and then the ``SimData``
+data object from our moose simulation in the 1 index.
+
+**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/.
+
+**Installing gmsh**: For this example you will need to have a gmsh executable
+which can be downloaded and installed from here: https://gmsh.info/#Download
+
+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,
+                                GmshRunner,
+                                MooseConfig,
+                                InputModifier,
+                                DirectoryManager,
+                                SweepReader,
+                                sweep_param_grid)
+
+#%%
+# The first part of this example is the same as the previous example we have
+# seen running a parallel parameter sweep for gmsh+moose using the herd workflow
+# manager. If you are not familiar with the code below go back to the example
+# entitled 'Running a parameter sweep of a Gmsh and MOOSE simulation'.
+# Otherwise you can skip down to the next code block where we will read the
+# output of the sweep and compare it to what we have seen previously.
+sim_case: int = 17
+
+gmsh_input = dataset.sim_case_gmsh_file_path(case_num=sim_case)
+gmsh_modifier = InputModifier(gmsh_input,"//",";")
+
+gmsh_runner = GmshRunner(gmsh_path=(Path.home() / "gmsh/bin/gmsh"))
+gmsh_runner.set_input_file(gmsh_input)
+
+moose_input = dataset.sim_case_input_file_path(case_num=sim_case)
+moose_modifier = InputModifier(moose_input,"#","")
+
+moose_config = MooseConfig({'main_path': Path.home()/ 'moose',
+                            'app_path': Path.home() / 'proteus',
+                            'app_name': 'proteus-opt'})
+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([gmsh_runner,moose_runner],
+                 [gmsh_modifier,moose_modifier],
+                 dir_manager,
+                 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()
+
+gmsh_params = {"plate_width": np.array([150e-3,100e-3]),
+               "plate_height": ("plate_width + 100e-3",
+                                "plate_width + 50e-3")}
+moose_params = None
+sweep_params = sweep_param_grid([gmsh_params,moose_params])
+
+if __name__ == "__main__":
+    herd.run_para(sweep_params)
+    time_run_para = herd.get_sweep_time()
+
+
+print(f'Sweep run time (para) = {time_run_para:.3f} seconds\n')
+
+#%%
+# We now pass the directory manager we used for the sweep to our sweep reader
+# and then we read in the sweep results sequentially. As we have seen before
+# our sweep results are given as a list of lists where the outer list is the
+# unique simulation chain in our parameter sweep and the inner list corresponds
+# to each simulation tool in the chain. In this case we have gmsh and moose so
+# our inner list should have a length of 2.
+
+sweep_reader = SweepReader(dir_manager,num_para_read=4)
+
+start_time = time.perf_counter()
+sweep_results_seq = sweep_reader.read_sequential()
+read_time_seq = time.perf_counter() - start_time
+
+print(f'Read time sequential = {read_time_seq:.6f} seconds\n')
+
+print("Outer list = unique simulation chain:")
+print(f"    {len(sweep_results_seq)=}")
+print("Inner list = particular simulation tool in the chain:")
+print(f"    {len(sweep_results_seq[0])=}")
+print()
+
+#%%
+# As gmsh does not have any simulation output we can read as a ``SimData``
+# object we see that our inner sweep results list has 'None' in the position
+# corresponding to gmsh (the 0 index). We also see we have our moose output as
+# a ``SimData`` object at the 1 index of the inner list.
+print(f"{type(sweep_results_seq[0][0])=}")
+print(f"{type(sweep_results_seq[0][1])=}")

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)