pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/examples/genanalyticdata/ex1_1_scalarvisualisation.py

@@ -0,0 +1,41 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+import numpy as np
+import matplotlib.pyplot as plt
+import pyvale.verif as verif
+
+def main() -> None:
+
+    (sim_data,data_gen) = verif.AnalyticCaseFactory.scalar_linear_2d()
+
+    (grid_x,grid_y,grid_field) = data_gen.get_visualisation_grid()
+
+    print()
+    print(f"{np.min(grid_field.flatten())=}")
+    print(f"{np.max(grid_field.flatten())=}")
+    print()
+
+    fig, ax = plt.subplots()
+    cs = ax.contourf(grid_x,grid_y,grid_field)
+    cbar = fig.colorbar(cs)
+    plt.axis('scaled')
+
+
+    # (sim_data,data_gen) = va.AnalyticCaseFactory.scalar_quadratic_2d()
+
+    # (grid_x,grid_y,grid_field) = data_gen.get_visualisation_grid()
+
+    # fig, ax = plt.subplots()
+    # cs = ax.contourf(grid_x,grid_y,grid_field)
+    # cbar = fig.colorbar(cs)
+    # plt.axis('scaled')
+
+    # plt.show()
+
+
+
+if __name__ == '__main__':
+    main()

pyvale/examples/genanalyticdata/ex1_2_scalarcasebuild.py

@@ -0,0 +1,43 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import numpy as np
+import matplotlib.pyplot as plt
+import sympy
+import pyvale.verif as verif
+
+def main() -> None:
+
+    case_data = verif.AnalyticData2D()
+    case_data.length_x = 10.0
+    case_data.length_y = 7.5
+    n_elem_mult = 10
+    case_data.num_elem_x = 4*n_elem_mult
+    case_data.num_elem_y = 3*n_elem_mult
+    case_data.time_steps = np.linspace(0.0,1.0,11)
+
+    (sym_y,sym_x,sym_t) = sympy.symbols("y,x,t")
+    case_data.funcs_x = (25.0 * sympy.sin(2*sympy.pi*sym_x/case_data.length_x),)
+    case_data.funcs_y = (10.0/case_data.length_y * sym_y,)
+    case_data.funcs_t = (sym_t,)
+    case_data.offsets_space = (20.0,)
+    case_data.offset_time = (0.0,)
+
+
+    data_gen = verif.AnalyticSimDataGen(case_data)
+    sim_data = data_gen.generate_sim_data()
+
+    (grid_x,grid_y,grid_field) = data_gen.get_visualisation_grid()
+
+    fig, ax = plt.subplots()
+    cs = ax.contourf(grid_x,grid_y,grid_field)
+    cbar = fig.colorbar(cs)
+    plt.axis('scaled')
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()

pyvale/examples/genanalyticdata/ex2_1_analyticsensors.py

@@ -0,0 +1,86 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pyvale.sensorsim as sens
+import pyvale.verif.analyticsimdatafactory as asd
+
+def main() -> None:
+    # 10x7.5 plate with bi-directional field gradient
+    # 40x30 elements [x,y]
+    # Field slope of 20/lengX in X
+    # Field slope of 10/lengY in Y
+    # Field max in top corner of 220, field min in bottom corner 20
+    (sim_data,_) = asd.scalar_linear_2d()
+
+    descriptor = sens.SensorDescriptorFactory.temperature_descriptor()
+
+    field_key = 'scalar'
+    t_field = sens.FieldScalar(sim_data,
+                              field_key=field_key,
+                              elem_dims=2)
+
+    n_sens = (4,1,1)
+    x_lims = (0.0,10.0)
+    y_lims = (0.0,7.5)
+    z_lims = (0.0,0.0)
+    sens_pos = sens.gen_pos_grid_inside(n_sens,x_lims,y_lims,z_lims)
+
+    use_sim_time = False
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sensor_data = sens.SensorData(positions=sens_pos,
+                                         sample_times=sample_times)
+
+    tc_array = sens.SensorsPoint(sensor_data,
+                                       t_field,
+                                       descriptor)
+
+    errors_on = {'indep_sys': True,
+                 'rand': True,
+                 'dep_sys': True}
+
+    error_chain = []
+    if errors_on['indep_sys']:
+        error_chain.append(sens.ErrSysOffset(offset=-5.0))
+        error_chain.append(sens.ErrSysUnif(low=-5.0,
+                                            high=5.0))
+        gen_norm = sens.GenNormal(std=1.0)
+
+    if errors_on['rand']:
+        error_chain.append(sens.ErrRandNormPercent(std_percent=1.0))
+        error_chain.append(sens.ErrRandUnifPercent(low_percent=-1.0,
+                                            high_percent=1.0))
+
+    if errors_on['dep_sys']:
+        error_chain.append(sens.ErrSysDigitisation(bits_per_unit=2**8/100))
+        error_chain.append(sens.ErrSysSaturation(meas_min=0.0,meas_max=300.0))
+
+    if len(error_chain) > 0:
+        error_integrator = sens.ErrIntegrator(error_chain,
+                                                  sensor_data,
+                                                  tc_array.get_measurement_shape())
+        tc_array.set_error_integrator(error_integrator)
+
+    measurements = tc_array.get_measurements()
+
+    sens.print_measurements(tc_array,
+                            slice(0,1), # Sensor 1
+                            slice(0,1), # Component 1: scalar field = 1 component
+                            slice (measurements.shape[2]-5,measurements.shape[2]))
+
+    (fig,_) = sens.plot_time_traces(tc_array,field_key)
+    plt.show()
+
+    pv_plot = sens.plot_point_sensors_on_sim(tc_array,field_key)
+    pv_plot.show(cpos="xy")
+
+if __name__ == '__main__':
+    main()

pyvale/examples/genanalyticdata/ex2_2_analyticsensors_nomesh.py

@@ -0,0 +1,89 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+import copy
+import matplotlib.pyplot as plt
+import numpy as np
+import pyvale.sensorsim as sens
+import pyvale.verif as verif
+
+
+def main() -> None:
+    # 10x7.5 plate with bi-directional field gradient
+    # 40x30 elements [x,y]
+    # Field slope of 20/lengX in X
+    # Field slope of 10/lengY in Y
+    # Field max in top corner of 220, field min in bottom corner 20
+
+    (sim_data,_) = verif.analyticsimdatafactory.scalar_linear_2d()
+    sim_data_nomesh = copy.deepcopy(sim_data)
+
+    # When we have a point cloud and no mesh the connectivity table is None
+    sim_data_nomesh.connect = None
+
+    descriptor = sens.SensorDescriptorFactory.temperature_descriptor()
+
+    field_key = 'temperature'
+    scal_field = sens.FieldScalar(sim_data,
+                                  field_key=field_key,
+                                  elem_dims=2)
+
+    scal_field_nm = sens.FieldScalar(sim_data_nomesh,
+                                     field_key=field_key,
+                                     elem_dims=2)
+
+
+    n_sens = (4,1,1)
+    x_lims = (0.0,10.0)
+    y_lims = (0.0,7.5)
+    z_lims = (0.0,0.0)
+    sens_pos = sens.gen_pos_grid_inside(n_sens,x_lims,y_lims,z_lims)
+
+    use_sim_time = False
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sensor_data = sens.SensorData(positions=sens_pos,
+                                 sample_times=sample_times)
+
+    tc_array = sens.SensorsPoint(sensor_data,
+                                    scal_field,
+                                    descriptor)
+
+    tc_array_nm = sens.SensorsPoint(sensor_data,
+                                        scal_field_nm,
+                                        descriptor)
+
+
+    meas = tc_array.get_measurements()
+    meas_nm = tc_array_nm.get_measurements()
+
+    print(80*"-")
+    print("MESH INTERP")
+    sens.print_measurements(tc_array,
+                            slice(0,1), # Sensor 1
+                            slice(0,1), # Component 1: scalar field = 1 component
+                            slice (meas.shape[2]-5,meas.shape[2]))
+
+    print("POINT INTERP")
+    sens.print_measurements(tc_array_nm,
+                            slice(0,1), # Sensor 1
+                            slice(0,1), # Component 1: scalar field = 1 component
+                            slice (meas_nm.shape[2]-5,meas_nm.shape[2]))
+
+    print(f"{np.allclose(meas,meas_nm)=}")
+    print(80*"-")
+
+    # (fig,ax) = sens.plot_time_traces(tc_array,field_key)
+    # ax.set_title("Mesh Interp.")
+    # plt.show()
+
+    pv_plot = sens.plot_point_sensors_on_sim(tc_array_nm,field_key)
+    pv_plot.show(cpos="xy")
+
+if __name__ == '__main__':
+    main()

pyvale/examples/imagedef2d/ex_imagedef2d_todisk.py

@@ -0,0 +1,84 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+
+from pathlib import Path
+import numpy as np
+
+# Pyvale Imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
+import pyvale.dataset as dataset
+
+
+def main() -> None:
+    sim_path = dataset.mechanical_2d_path()
+    sim_data = mh.ExodusLoader(sim_path).load_all_sim_data()
+
+    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():
+        save_path.mkdir(parents=True, exist_ok=True)
+
+    coords = sim_data.coords
+    connectivity = (sim_data.connect["connect1"]-1).T # Beware 0 indexing here
+    disp_x = sim_data.node_vars["disp_x"][:,:]
+    disp_y = sim_data.node_vars["disp_y"][:,:]
+
+    print()
+    print(80*"-")
+    print(f"{coords.shape=}")
+    print(f"{connectivity.shape=}")
+    print(f"{disp_x.shape=}")
+    print(f"{disp_y.shape=}")
+    print(80*"-")
+
+
+    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 = sens.ImageDefOpts(save_path=save_path,
+                                  crop_on=True,
+                                  add_static_ref=True)
+
+
+
+    (upsampled_image,
+     image_mask,
+     image_input,
+     disp_x,
+     disp_y) = sens.ImageDef2D.preprocess(cam_data,
+                                            image_speckle,
+                                            coords,
+                                            connectivity,
+                                            disp_x,
+                                            disp_y,
+                                            id_opts,
+                                            print_on=True)
+
+    ff = -1
+    disp = np.array((disp_x[:,ff],disp_y[:,ff])).T
+    print(f"{disp.shape=}")
+
+
+    sens.ImageDef2D.deform_images_to_disk(cam_data,
+                                            upsampled_image,
+                                            coords,
+                                            connectivity,
+                                            disp_x,
+                                            disp_y,
+                                            image_mask,
+                                            id_opts,
+                                            print_on=True)
+
+
+if __name__ == "__main__":
+    main()
+

pyvale/examples/mooseherder/README.md

@@ -0,0 +1,2 @@
+Mooseherder Examples
+========================================

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()