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

pyvale/examples/imagedef2d/ex_imagedef2d_todisk.py

@@ -7,16 +7,19 @@
 
 from pathlib import Path
 import numpy as np
-import mooseherder as mh
-import pyvale as pyv
+
+# Pyvale Imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
+import pyvale.dataset as dataset
 
 
 def main() -> None:
-    sim_path = pyv.DataSet.mechanical_2d_path()
+    sim_path = dataset.mechanical_2d_path()
     sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
 
-    image_path = pyv.DataSet.dic_pattern_5mpx_path()
-    image_speckle = pyv.ImageTools.load_image_greyscale(image_path)
+    image_path = dataset.dic_pattern_5mpx_path()
+    image_speckle = sens.ImageTools.load_image_greyscale(image_path)
 
     save_path = Path.cwd()/"pyvale-output"
     if not save_path.is_dir():
@@ -36,12 +39,12 @@ def main() -> None:
     print(80*"-")
 
 
-    cam_data = pyv.CameraData2D(pixels_count=np.array((1040,1540)),
+    cam_data = sens.CameraData2D(pixels_count=np.array((1040,1540)),
                                    leng_per_px=0.1e-3,
                                    bits=8,
                                    roi_cent_world=np.mean(coords,axis=0),
                                    subsample=3)
-    id_opts = pyv.ImageDefOpts(save_path=save_path,
+    id_opts = sens.ImageDefOpts(save_path=save_path,
                                   crop_on=True,
                                   add_static_ref=True)
 
@@ -51,7 +54,7 @@ def main() -> None:
      image_mask,
      image_input,
      disp_x,
-     disp_y) = pyv.ImageDef2D.preprocess(cam_data,
+     disp_y) = sens.ImageDef2D.preprocess(cam_data,
                                             image_speckle,
                                             coords,
                                             connectivity,
@@ -65,7 +68,7 @@ def main() -> None:
     print(f"{disp.shape=}")
 
 
-    pyv.ImageDef2D.deform_images_to_disk(cam_data,
+    sens.ImageDef2D.deform_images_to_disk(cam_data,
                                             upsampled_image,
                                             coords,
                                             connectivity,

pyvale/examples/mooseherder/ex0_create_moose_config.py

@@ -0,0 +1,65 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Creating a configuration file
+================================================================================
+
+In this example we generate a json config file which help mooseherder find the
+paths to moose apps we want to use in the future.
+
+
+**Installing moose**: To run future examples you will need to have 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.
+"""
+
+#%%#
+# We start with imports for paths and for our moose configuration object.
+from pathlib import Path
+
+# Pyvale imports
+from pyvale.mooseherder import MooseConfig
+
+#%%
+# A moose configuration is a dictionary with these three keys "main_path",
+# "app_path" and "app_name". The first two keys retur resolved paths for moose
+# and the app you are using. The last key returns the string used call your
+# moose app on the command line. Once we have this dictionary we can build our
+# moose config object which will perform some checks for us to see if the
+# configuration is valid.
+config = {'main_path': Path.home()/ 'moose',
+          'app_path': Path.home() / 'proteus',
+          'app_name': 'proteus-opt'}
+
+moose_config = MooseConfig(config)
+
+#%%
+# We are going to save our moose configuration to the default output path for
+# pyvale so if this default output path does not exist we create it. Then all we
+# need to do is call the save configuration method and give it a path and file
+# name for the json we want to save.
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+config_path = Path.cwd() / 'moose-config.json'
+moose_config.save_config(config_path)
+
+#%%
+# Now we have our moose configuration we can use it to run moose with
+# mooseherder's mooserunner and mooseherd classes which we will see in later
+# examples. For now we will move on to demonstrate how mooseherder modifies
+# input files for gmsh and moose.
+
+
+

pyvale/examples/mooseherder/ex1a_modify_moose_input.py

@@ -0,0 +1,71 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Modifying moose input files
+================================================================================
+
+In this example we will use mooseherder's input modifier to programmatically
+change variables in a moose .i input script.
+
+We start by importing the packages we need for this example.
+"""
+
+from pathlib import Path
+
+# Pyvale imports
+import pyvale.dataset as dataset
+from pyvale.mooseherder import InputModifier
+
+#%%
+# We use the input file for a simple thermo-mechanical cube with higher order
+# quads. We pass this to our input modifier specifying the moose comment
+# character(s) as '#' and moose input files do not have a line end character so
+# we pass an empty string. In the next example we will modify a gmsh script
+# where we will need to specify a line ending character.
+moose_input = dataset.element_case_input_path(dataset.EElemTest.HEX20)
+moose_mod = InputModifier(moose_input, comment_chars="#", end_chars="")
+
+#%%
+# Note that the input modifier class only looks for variables between specified
+# sentinel characters in comment lines which starts with '_*' and ends with '**'
+# . An example of what variable block can be found in the moose input file.
+#
+# We then print the variables found in the moose input file to the console which
+# are returned to us as a dictionary keyed by the variables string name in the
+# file:
+print(moose_mod.get_vars())
+print()
+
+#%%
+# We can update variables using the input modifier, we just need to create a
+# dictionary keyed by the variable name we want to change and the value we want
+# the variable to take. If the variable does not exist in the input file then an
+# error will be raised. Here we will change the number of elements in 'x' and
+# the elastic modulus.
+new_vars = {"nElemX": 4, "EMod": 3.3e9}
+moose_mod.update_vars(new_vars)
+
+
+#%%
+# Let's check that the variables in the dictionary have been updated to match
+# what we have changed:
+print(moose_mod.get_vars())
+print()
+
+#%%
+# Now we want to save the modified input file so we first create the standard
+# pyvale-output directory if it does not exist. Then we write the file to that
+# directory with suitable file name. Have a look at the file in the
+# pyvale-output directory to verify the variables have been changed.
+
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+moose_save = output_path/"moose-mod-vars.i"
+moose_mod.write_file(moose_save)
+

pyvale/examples/mooseherder/ex1b_modify_gmsh_input.py

@@ -0,0 +1,69 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Modifying gmsh input files
+================================================================================
+
+In this example we will use mooseherder's input modifier to programmatically
+change variables in a gmsh .geo script.
+
+We start by importing the packages we need for this example.
+"""
+
+from pathlib import Path
+
+# Pyvale imports
+import pyvale.dataset as dataset
+from pyvale.mooseherder import InputModifier
+
+#%%
+# We are going to use a gmsh geo file that is for a 2D rectangular plate with a
+# hole in the center which we retrieve from pyvale's simulation library. We then
+# use this to create an input modifier which has the correct comment string '//'
+# for gmsh and the required line terminator ";".
+gmsh_input = dataset.sim_case_gmsh_file_path(case_num=17)
+gmsh_mod = InputModifier(gmsh_input, "//", ";")
+
+#%%
+# Note that the input modifier class only looks for variables between specified
+# sentinel characters in comment lines which starts with '_*' and ends with '**'
+# . An example variable block can be found in the gmsh input file.
+#
+# We then print the variables found in the gmsh input file to the console which
+# are returned to us as a dictionary keyed by the variables string name in the
+# file:
+print(gmsh_mod.get_vars())
+print()
+
+#%%
+# We can update the variables in the input modifier using a dictionary keyed by
+# the variable names we want to change and the values being what we want to
+# change them to. We do not have to use numeric values for these we can use
+# expressions in strings.
+new_vars = {"plate_width": 150e-3, "plate_height": "plate_width + 100e-3"}
+gmsh_mod.update_vars(new_vars)
+
+#%%
+# Now we print the variables that are currently in the input modifier to check
+# our modification worked.
+print(gmsh_mod.get_vars())
+print()
+
+#%%
+# Finally we want to save the modified input file to disk so we can run it with
+# gmsh. First we create the standard pyvale-output directory so we can save the
+# file there. Then we save the gmsh input file to the directory with a suitable
+# name. Have a look at the file in the directory to ensure our modifications
+# have worked.
+
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+gmsh_save = output_path/"gmsh-mod-vars.geo"
+gmsh_mod.write_file(gmsh_save)
+

pyvale/examples/mooseherder/ex2a_run_moose_once.py

@@ -0,0 +1,80 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Running MOOSE once
+================================================================================
+
+In this example we will run a single moose simulation from a moose input .i file
+using a 'runner' object.
+
+**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
+
+#pyvale imports
+import pyvale.dataset as dataset
+from pyvale.mooseherder import (MooseConfig,
+                                MooseRunner)
+
+
+#%%
+# First we build our moose configuration which gives the location of our main
+# moose build, our moose app and the name of the app to use when called on the
+# command line.
+config = {'main_path': Path.home()/ 'moose',
+          'app_path': Path.home() / 'proteus',
+          'app_name': 'proteus-opt'}
+moose_config = MooseConfig(config)
+
+#%%
+# We can now build a runner object using our configuration. We can then set some
+# options for the run including parallelisation and if we should redirect
+# terminal output to file. For smaller simulations we are better off using
+# threads for paralleisation as they reduce overhead compared to MPI tasks.
+moose_runner = MooseRunner(moose_config)
+
+moose_runner.set_run_opts(n_tasks = 1,
+                          n_threads = 8,
+                          redirect_out = False)
+
+#%%
+# Let's grab a simple thermo-mechanical cube test case from pyvale's moose
+# simulation library and we will set this as the input file to run with our
+# 'runner'.
+moose_input = dataset.element_case_input_path(dataset.EElemTest.HEX20)
+moose_runner.set_input_file(moose_input)
+
+#%%
+# Our moose runner will pass a list of strings which form the command line to
+# run our moose simulation. We print the list of command line arguments here so
+# we can check we are correctly calling our input file with the run options we
+# want.
+print(moose_runner.get_arg_list())
+print()
+
+#%%
+# To run our moose simulation we just need to call 'run', here we will time our
+# moose run and then print the solve time to the terminal
+start_time = time.perf_counter()
+moose_runner.run()
+run_time = time.perf_counter() - start_time
+
+print()
+print("-"*80)
+print(f'MOOSE run time = {run_time:.3f} seconds')
+print("-"*80)
+print()

pyvale/examples/mooseherder/ex2b_run_gmsh_once.py

@@ -0,0 +1,64 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Running Gmsh once
+================================================================================
+
+In this example we will run a gmsh script to generate a mesh file using the
+GmshRunner class.
+
+**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
+
+#pyvale imports
+import pyvale.dataset as dataset
+from pyvale.mooseherder import GmshRunner
+
+#%%
+# First we need to create a 'runner' for gmsh which needs to know the path to
+# the gmsh executable. You will need to replace this path with the path to where
+# you have install gmsh on your system.
+gmsh_path = Path.home() / 'gmsh/bin/gmsh'
+gmsh_runner = GmshRunner(gmsh_path)
+
+#%%
+# Next we grab a gmsh file from pyvale simulation library and we set this as the
+# input file for our runner.
+gmsh_input = dataset.sim_case_gmsh_file_path(case_num=17)
+gmsh_runner.set_input_file(gmsh_input)
+
+#%%
+# Now we can run gmsh to generate our mesh using the run method, the parse only
+# flag means we will run gmsh head less and not open the gmsh GUI but terminal
+# output will still be written to stdout.
+#
+# We also use our performance timer to time how long our mesh generation takes
+# and then we print this to the console. Note that parallelisation options for
+# gmsh can be controlled in the gmsh .geo script file.
+start_time = time.perf_counter()
+gmsh_runner.run(gmsh_input,parse_only=True)
+run_time = time.perf_counter() - start_time
+
+print()
+print("-"*80)
+print(f'Gmsh run time = {run_time :.3f} seconds')
+print("-"*80)
+print()
+
+#%%
+# The GmshRunner and the MooseRunner implement the SimRunner abstract base
+# class. Later on when we will see that we can use this to run a list of
+# different sim runners in order using MooseHerd workflow manager. This allows
+# us to first build our mesh with gmsh and then run a moose simulation using
+# that mesh. We can also implement our own SimRunner's to add additional pre or
+# post processing steps to our simulation chain.

pyvale/examples/mooseherder/ex2c_run_both_once.py

@@ -0,0 +1,114 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Run Gmsh then MOOSE once
+================================================================================
+
+In this example we use a gmsh runner followed by a moose runner to generate our
+mesh and then run a moose simulation using this mesh. The moose input file needs
+to know the name of the gmsh .msh file which is specified in the gmsh .geo
+script when the Save command is called. It is possible to use the input
+modifiers we have seen previously to update this file name as a variable in the
+moose input script but for this example we have set things manually inside the
+moose input script.
+
+**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
+import shutil
+from pathlib import Path
+
+#pyvale imports
+import pyvale.dataset as dataset
+from pyvale.mooseherder import (MooseConfig,
+                                GmshRunner,
+                                MooseRunner)
+
+#%%
+# We need to make sure the output .msh file from gmsh can be found by our moose
+# input script so we are going to put them in our standard pyvale-output
+# directory in our current working directory. First we grab the paths for the
+# .geo and .i and then we copy them to the pyvale-output directory where we will
+# run our simulation from. We then print the paths to we can see where the files
+# are - try opening them with your text editor of choice so you can see how the
+# name of the mesh is specified in the gmsh .geo as the .msh output and the then
+# how the name is matched in the moose .i to read the .msh to run the sim.
+
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+gmsh_file = dataset.sim_case_gmsh_file_path(case_num=17)
+gmsh_input = output_path / gmsh_file.name
+
+moose_file = dataset.sim_case_input_file_path(case_num=17)
+moose_input = output_path / moose_file.name
+
+shutil.copyfile(moose_file,moose_input)
+shutil.copyfile(gmsh_file,gmsh_input)
+
+print(f"\n{moose_input.resolve()=}")
+print(f"{gmsh_input.resolve()=}\n")
+
+#%%
+# We need to run gmsh first to generate our .msh file so we set it up and run it
+# in exactly the same way as we have done in the previous example. We pass the
+# path to the gmsh executable to our runner. We then set our input file and call
+# run to generate the mesh.
+gmsh_path = Path.home() / 'gmsh/bin/gmsh'
+gmsh_runner = GmshRunner(gmsh_path)
+
+gmsh_runner.set_input_file(gmsh_input)
+
+gmsh_start = time.perf_counter()
+gmsh_runner.run(parse_only=True)
+gmsh_run_time = time.perf_counter()-gmsh_start
+
+#%%
+# Now that we have our mesh we can run our moose simulation. We will setup and
+# run moose in exactly the same was as in a previous example. First, we setup
+# our moose configuration and pass this to our runner. We then set our run /
+# parallelisation options before calling run to extecute the simulation.
+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 = 4,
+                          redirect_out = True)
+
+moose_runner.set_input_file(moose_input)
+
+moose_start = time.perf_counter()
+moose_runner.run()
+moose_run_time = time.perf_counter() - moose_start
+
+#%%
+# Finally we print the execution times of both runners and print these to the
+# console.
+print("-"*80)
+print(f'Gmsh run time = {gmsh_run_time:.2f} seconds')
+print(f'MOOOSE run time = {moose_run_time:.2f} seconds')
+print("-"*80)
+print()
+
+

pyvale/examples/mooseherder/ex3_run_moose_seq_para.py

@@ -0,0 +1,157 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Running a parameter sweep of a MOOSE simulation
+================================================================================
+
+In this example we will perform a parameter sweep of a moose simulation showing
+the capability of the 'herder' workflow manager which can be passed a list of
+'input modifiers' and 'runners'. The 'herder' will then use the 'input
+modifiers' to update simulation parameters and then call the respective 'runner'
+using the modified input file. In this example we will also see that the
+'herder' can be used to execute a parameter sweep sequentially or in parallel.
+
+**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.
+"""
+
+from pathlib import Path
+import numpy as np
+
+#pyvale imports
+import pyvale.dataset as dataset
+from pyvale.mooseherder import (MooseHerd,
+                                MooseRunner,
+                                InputModifier,
+                                DirectoryManager,
+                                MooseConfig,
+                                sweep_param_grid)
+
+#%%
+# First we are going to setup an input modifier and a runner for our moose
+# simulation. Here we need to make sure that when we set our moose
+# parallelisation options we leave enough threads for all the simulations that
+# are running at once base on our CPU. It is also helpful to redirect stdout to
+# file so that our terminal does not become a mess when we start running our
+# simulations in parallel.
+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)
+
+#%%
+# Now we are going to create a directory manager which will be used to make sure
+# our simulations are run in separate directories. We then create our herd
+# workflow manager with our list of runners and corresponding input modifiers.
+# In our case we are only running moose so our lists have a single item. The
+# last thing we do is specify the number of simulations we want to run in
+# parallel, for this case we match the number of directories.
+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)
+
+#%%
+# We need somewhere to run our simulations and store the output so we create our
+# standard pyvale output directory and then we set this as the base directory
+# for our directory manager. We clear any old output directories and then create
+# new ones ready to write our simulation output to.
+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()
+
+#%%
+# We now need to generate the parameter combinations we want to run using our
+# 'herd'. This is given as a list of list of dictionaries where the outer list
+# corresponds to the unique simulation chain, the inner list corresponds to each
+# simulation runner in the chain, and the dicitionary contains key value pairs
+# where the keys are the variables names to edit in the input file. For this
+# case we only have moose in our simulation chain so our inner list will only
+# have a length of one but in the next example we will see how we can combine
+# a parameter sweep with gmsh->moose sweeping all possible combinations of
+# variables for both simulation tools.
+#
+# For now we are going to use a helper function from mooseherder which will
+# generate all possible combination for us in the correct data format. We just
+# provide a dictionary of lists of unique parameters we want to analyse. Finally
+# we print the unique combinations of parameters to the terminal as well as the
+# total number of simulations to check everything is working as expected.
+
+moose_params = {"nElemX": (2,3,4),
+                "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}")
+
+print()
+print(f"Total simulations = {len(sweep_params)}")
+print()
+
+#%%
+# The run once function of the herd allows us to run a particular single
+# simulation chain from anywhere in the sweep. This is useful for debugging when
+# you want to rerun a single case to see the output or what went wrong. The herd
+# also stores the solution time for each single iteration so we will store this
+# to estimate how long the whole sweep should take when solving sequentially.
+herd.run_once(0,sweep_params[0])
+time_run_once = herd.get_iter_time()
+
+
+#%%
+# We can run the whole parameter sweep sequentially (one by one) using the run
+# sequential function of the herd. We also store the total solution time
+# for all simulation chains so that we can compare to a parallel run later. Note
+# that it can be beneficial to run sequentially if you are using the herd within
+# another loop or if one of the steps in your simulation chain is expensive and
+# that step needs the computational resource.
+herd.run_sequential(sweep_params)
+time_run_seq = herd.get_sweep_time()
+
+#%%
+# Finally, we can run our parameter sweep in parallel. We need a main guard here
+# as we use the multi-processing package. We also store the sweep time for this
+# case to compare our sequential to parallel run time.
+if __name__ == "__main__":
+    herd.run_para(sweep_params)
+    time_run_para = herd.get_sweep_time()
+
+#%%
+# Now that we have run all cases we can compare run times for a single
+# simulation multiplied by the total number of simulations against runnning the
+# sweep in parallel
+print("-"*80)
+print(f'Run time (one iter)             = {time_run_once:.3f} seconds')
+print(f'Est. time (one iter x num sims) = {(time_run_once*len(sweep_params)):.3f} seconds')
+print()
+print(f'Run time (seq)      = {time_run_seq:.3f} seconds')
+print(f'Run time (para)     = {time_run_para:.3f} seconds')
+print("-"*80)
+print()
+
+