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

pyvale/examples/dic/ex4_dic_blender.py

@@ -8,7 +8,7 @@
 
 """
 DIC with images generated from a virtual blender experiment 
----------------------------------------------
+------------------------------------------------------------
 
 This example looks at taking the virtual experiments conducted using the blender
 module and taking it one step further and performing a DIC calculation on the
@@ -24,9 +24,11 @@ changed.**
 import matplotlib.pyplot as plt
 from pathlib import Path
 import numpy as np
-import pyvale
 import os
 
+# Pyvale imports
+import pyvale.dic as dic
+
 #subset size
 subset_size = 21
 
@@ -40,7 +42,7 @@ ref_img = "./blenderimages/reference.tiff"
 def_img = "./blenderimages/blenderimage_*.tiff"
 
 # Interactive ROI selection
-roi = pyvale.DICRegionOfInterest(ref_img)
+roi = dic.RegionOfInterest(ref_img)
 roi.interactive_selection(subset_size)
 
 #output_path
@@ -49,21 +51,21 @@ if not output_path.is_dir():
     output_path.mkdir(parents=True, exist_ok=True)
 
 # DIC Calculation
-pyvale.dic_2d(reference=ref_img,
-              deformed=def_img,
-              roi_mask=roi.mask,
-              seed=roi.seed,
-              subset_size=subset_size,
-              subset_step=10,
-              shape_function="AFFINE",
-              max_displacement=20,
-              correlation_criteria="ZNSSD",
-              output_basepath=output_path,
-              output_prefix="blender_dic_")
+dic.two_dimensional(reference=ref_img,
+                           deformed=def_img,
+                           roi_mask=roi.mask,
+                           seed=roi.seed,
+                           subset_size=subset_size,
+                           subset_step=10,
+                           shape_function="AFFINE",
+                           max_displacement=20,
+                           correlation_criteria="ZNSSD",
+                           output_basepath=output_path,
+                           output_prefix="blender_dic_")
 
 # Import the Results
 data_path = output_path / "blender_dic_*.csv"
-dicdata = pyvale.dic_data_import(data=data_path, delimiter=",",
+dicdata = dic.data_import(data=data_path, delimiter=",",
                                  layout='matrix', binary=False)
 
 # %%

pyvale/examples/dic/ex5_dic_challenge.py

@@ -25,13 +25,18 @@ As always, we'll start with importing the required libraries:
 
 import matplotlib.pyplot as plt
 from pathlib import Path
-import pyvale
+
+# Pyvale imports
+import pyvale.dataset as dataset
+import pyvale.dic as dic
+
 
 
 # %%
-# There's a pair of DIC challenge images that come as part of the Pyvale install. We can preload them with:
-ref_pattern = pyvale.DataSet.dic_challenge_ref()
-def_pattern = pyvale.DataSet.dic_challenge_def()
+# There's a pair of DIC challenge images that come as part of the Pyvale install. 
+# We can preload them with:
+ref_pattern = dataset.dic_challenge_ref()
+def_pattern = dataset.dic_challenge_def()
 subset_size = 17
 
 
@@ -41,7 +46,7 @@ subset_size = 17
 # We can use :func:`roi.rect_boundary` to exclude a large border region so we
 # only correlate along the horizontal at the midpoint for our selected subset
 # size
-roi = pyvale.DICRegionOfInterest(ref_image=ref_pattern)
+roi = dic.RegionOfInterest(ref_image=ref_pattern)
 subset_radius = subset_size // 2
 roi.rect_boundary(left=50,right=50,top=250-subset_radius,bottom=250-subset_radius)
 roi.show_image()
@@ -66,19 +71,19 @@ if not output_path.is_dir():
 # the current working directory with a filename prefix of subset_size_19_*.txt
 # If you are feeling adventorous you could investigate the effect of varying the
 # subset size by placing the above and below sections in a loop.
-pyvale.dic_2d(reference=ref_pattern,
-              deformed=def_pattern,
-              roi_mask=roi.mask,
-              subset_size=subset_size,
-              subset_step=1,
-              seed=[3500,250],
-              max_displacement=10,
-              output_basepath=output_path)
+dic.two_dimensional(reference=ref_pattern,
+                    deformed=def_pattern,
+                    roi_mask=roi.mask,
+                    subset_size=subset_size,
+                    subset_step=1,
+                    seed=[3500,250],
+                    max_displacement=10,
+                    output_basepath=output_path)
 
 # %% 
 # We can import the results in the standard way
 data_path = output_path / "dic_results_DIC_Challenge*.csv"
-dicdata = pyvale.dic_data_import(data=data_path, layout='column', 
+dicdata = dic.data_import(data=data_path, layout='column', 
                                  binary=False, delimiter=",")
 
 # &&

pyvale/examples/genanalyticdata/ex1_1_scalarvisualisation.py

@@ -3,32 +3,38 @@
 # License: MIT
 # Copyright (C) 2025 The Computer Aided Validation Team
 # ==============================================================================
-
+import numpy as np
 import matplotlib.pyplot as plt
-import pyvale
+import pyvale.verif as va
 
 def main() -> None:
 
-    (sim_data,data_gen) = pyvale.AnalyticCaseFactory.scalar_linear_2d()
+    (sim_data,data_gen) = va.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) = pyvale.AnalyticCaseFactory.scalar_quadratic_2d()
+    # (sim_data,data_gen) = va.AnalyticCaseFactory.scalar_quadratic_2d()
 
-    (grid_x,grid_y,grid_field) = data_gen.get_visualisation_grid()
+    # (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')
+    # fig, ax = plt.subplots()
+    # cs = ax.contourf(grid_x,grid_y,grid_field)
+    # cbar = fig.colorbar(cs)
+    # plt.axis('scaled')
+
+    # plt.show()
 
-    plt.show()
 
 
 if __name__ == '__main__':

pyvale/examples/genanalyticdata/ex1_2_scalarcasebuild.py

@@ -7,11 +7,11 @@
 import numpy as np
 import matplotlib.pyplot as plt
 import sympy
-import pyvale
+import pyvale.verif as va
 
 def main() -> None:
 
-    case_data = pyvale.AnalyticData2D()
+    case_data = va.AnalyticData2D()
     case_data.length_x = 10.0
     case_data.length_y = 7.5
     n_elem_mult = 10
@@ -27,7 +27,7 @@ def main() -> None:
     case_data.offsets_time = (0.0,)
 
 
-    data_gen = pyvale.AnalyticSimDataGen(case_data)
+    data_gen = va.AnalyticSimDataGen(case_data)
     sim_data = data_gen.generate_sim_data()
 
     (grid_x,grid_y,grid_field) = data_gen.get_visualisation_grid()

pyvale/examples/genanalyticdata/ex2_1_analyticsensors.py

@@ -6,23 +6,29 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
-import pyvale
+import pyvale as pyv
+import pyvale.verif as va
 
 def main() -> None:
-    (sim_data,_) = pyvale.AnalyticCaseFactory.scalar_linear_2d()
+    # 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,_) = va.AnalyticCaseFactory.scalar_linear_2d()
 
-    descriptor = pyvale.SensorDescriptorFactory.temperature_descriptor()
+    descriptor = pyv.SensorDescriptorFactory.temperature_descriptor()
 
     field_key = 'scalar'
-    t_field = pyvale.FieldScalar(sim_data,
-                                 field_key=field_key,
-                                 elem_dims=2)
+    t_field = pyv.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 = pyvale.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+    sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
     use_sim_time = False
     if use_sim_time:
@@ -30,10 +36,10 @@ def main() -> None:
     else:
         sample_times = np.linspace(0.0,np.max(sim_data.time),50)
 
-    sensor_data = pyvale.SensorData(positions=sens_pos,
+    sensor_data = pyv.SensorData(positions=sens_pos,
                                          sample_times=sample_times)
 
-    tc_array = pyvale.SensorArrayPoint(sensor_data,
+    tc_array = pyv.SensorArrayPoint(sensor_data,
                                        t_field,
                                        descriptor)
 
@@ -43,37 +49,37 @@ def main() -> None:
 
     error_chain = []
     if errors_on['indep_sys']:
-        error_chain.append(pyvale.ErrSysOffset(offset=-5.0))
-        error_chain.append(pyvale.ErrSysUnif(low=-5.0,
+        error_chain.append(pyv.ErrSysOffset(offset=-5.0))
+        error_chain.append(pyv.ErrSysUnif(low=-5.0,
                                             high=5.0))
-        gen_norm = pyvale.GenNormal(std=1.0)
+        gen_norm = pyv.GenNormal(std=1.0)
 
     if errors_on['rand']:
-        error_chain.append(pyvale.ErrRandNormPercent(std_percent=1.0))
-        error_chain.append(pyvale.ErrRandUnifPercent(low_percent=-1.0,
+        error_chain.append(pyv.ErrRandNormPercent(std_percent=1.0))
+        error_chain.append(pyv.ErrRandUnifPercent(low_percent=-1.0,
                                             high_percent=1.0))
 
     if errors_on['dep_sys']:
-        error_chain.append(pyvale.ErrSysDigitisation(bits_per_unit=2**8/100))
-        error_chain.append(pyvale.ErrSysSaturation(meas_min=0.0,meas_max=300.0))
+        error_chain.append(pyv.ErrSysDigitisation(bits_per_unit=2**8/100))
+        error_chain.append(pyv.ErrSysSaturation(meas_min=0.0,meas_max=300.0))
 
     if len(error_chain) > 0:
-        error_integrator = pyvale.ErrIntegrator(error_chain,
+        error_integrator = pyv.ErrIntegrator(error_chain,
                                                   sensor_data,
                                                   tc_array.get_measurement_shape())
         tc_array.set_error_integrator(error_integrator)
 
     measurements = tc_array.get_measurements()
 
-    pyvale.print_measurements(tc_array,
-                            (0,1), # Sensor 1
-                            (0,1), # Component 1: scalar field = 1 component
-                            (measurements.shape[2]-5,measurements.shape[2]))
+    pyv.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,_) = pyvale.plot_time_traces(tc_array,field_key)
+    (fig,_) = pyv.plot_time_traces(tc_array,field_key)
     plt.show()
 
-    pv_plot = pyvale.plot_point_sensors_on_sim(tc_array,field_key)
+    pv_plot = pyv.plot_point_sensors_on_sim(tc_array,field_key)
     pv_plot.show(cpos="xy")
 
 if __name__ == '__main__':

pyvale/examples/genanalyticdata/ex2_2_analyticsensors_nomesh.py

@@ -0,0 +1,67 @@
+# ==============================================================================
+# 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 va
+
+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,_) = va.AnalyticCaseFactory.scalar_linear_2d()
+    sim_data_nomesh = copy.deepcopy(sim_data)
+    sim_data_nomesh.connect = None
+
+    descriptor = sens.SensorDescriptorFactory.temperature_descriptor()
+
+    field_key = 'scalar'
+    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.create_sensor_pos_array(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.SensorArrayPoint(sensor_data,
+                                    scal_field,
+                                    descriptor)
+
+    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/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)
+