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

pyvale/examples/dic/ex1_2_blenderdeformed.py

@@ -0,0 +1,174 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Deforming a sample with 2D DIC
+===============================================
+
+This example follows a similar workflow to the previous Blender example.
+In this example, defomation is applied to sample, and images are rendered at
+each timestep.
+
+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
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
+import pyvale.blender as blender
+import pyvale.mooseherder as mh
+
+# %%
+# The simulation results are loaded in here in the same way as the previous
+# example. As mentioned this `data_path` can be replaced with your own MOOSE
+# simulation output in exodus format (*.e).
+
+data_path = dataset.render_mechanical_3d_path()
+sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+
+# %%
+# This is then scaled to mm, as all lengths in Blender are to be set in mm.
+# The `SimData` object is then converted into a `RenderMeshData` object, as
+# this skins the mesh ready to be imported into Blender.
+# 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 = sens.scale_length_units(scale=1000.0,
+                                     sim_data=sim_data,
+                                     disp_comps=disp_comps)
+
+render_mesh = sens.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+# %%
+# Firstly, a save path must be set.
+# In order to do this a base path must be set. Then all the generated files will
+# be saved to a subfolder within this specified base directory
+# (e.g. blenderimages).
+# If no base directory is specified, it will be set as your home directory.
+
+base_dir = Path.cwd()
+
+# %%
+# Creating the scene
+# ^^^^^^^^^^^^^^^^^^
+# In order to create a DIC setup in Blender, first a scene must be created.
+# A scene is initialised using the `BlenderScene` class. All the subsequent
+# objects and actions necessary are then methods of this class.
+
+scene = blender.Scene()
+
+# %%
+# The next thing that can be added to the scene is a sample.
+# This is done by passing in the `RenderMeshData` object.
+# It should be noted that the mesh will be centred on the origin to allow for
+# the cameras to be centred on the mesh.
+# Once the part is added to the Blender scene, it can be both moved and rotated.
+
+
+part = scene.add_part(render_mesh, sim_spat_dim=3)
+# Set the part location
+part_location = np.array([0, 0, 0])
+blender.Tools.move_blender_obj(part=part, pos_world=part_location)
+part_rotation = Rotation.from_euler("xyz", [0, 0, 0], degrees=True)
+blender.Tools.rotate_blender_obj(part=part, rot_world=part_rotation)
+
+# %%
+# A camera can then be added to the scene.
+# To initialise a camera, the camera parameters must be specified using the
+# `CameraData` dataclass. Note that all lengths / distances inputted are in mm.
+# This camera can then be added to the Blender scene.
+# The camera can also be moved and rotated.
+
+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]),
+                             roi_cent_world=(0, 0, 0),
+                             focal_length=15.0)
+camera = scene.add_camera(cam_data)
+camera.location = (0, 0, 410)
+camera.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
+
+# %%
+# A light can the be added to the scene.
+# Blender offers different light types: Point, Sun, Spot and Area.
+# The light can also be moved and rotated like the camera.
+
+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)
+light.rotation_euler = (0, 0, 0)
+
+# %%
+# A speckle pattern can then be applied to the sample.
+# Firstly, the material properties of the sample must be specified, but these
+# will all be defaulted if no inputs are provided.
+#The speckle pattern can then be specified by providing a path to an image file
+# with the pattern.
+# The mm/px resolution of the camera must also be specified in order to
+# correctly scale the speckle pattern.
+# It should be noted that for a bigger camera or sample you may need to generate
+# a larger speckle pattern.
+
+material_data = blender.MaterialData()
+speckle_path = dataset.dic_pattern_5mpx_path()
+mm_px_resolution = sens.CameraTools.calculate_mm_px_resolution(cam_data)
+scene.add_speckle(part=part,
+                    speckle_path=speckle_path,
+                    mat_data=material_data,
+                    mm_px_resolution=mm_px_resolution)
+
+# %%
+# Deforming the sample and rendering images
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+# Once all the objects have been added to the scene, the sample can be deformed,
+# and images can be rendered.
+# Firstly, all the rendering parameters must be set, including parameters such as
+# the number of threads to use.
+
+render_data = blender.RenderData(cam_data=cam_data,
+                                 base_dir=base_dir,
+                                 threads=8)
+
+# %%
+# A series of deformed images can then be rendered.
+# This is done by passing in rendering parameters, as well as the
+# `RenderMeshData` object, the part(sample) and the spatial dimension of the
+# simulation.
+# This will automatically deform the sample, and render subsequent images at
+# each deformation timestep.
+# If `stage_image` is set to True, the image will be saved to disk, converted to
+# an array, deleted and the image array will be returned. This is due to the
+# fact that an image cannot be saved directly as an array through Blender.
+
+scene.render_deformed_images(render_mesh,
+                             sim_spat_dim=3,
+                             render_data=render_data,
+                             part=part,
+                             stage_image=False)
+
+# %%
+# The rendered image will be saved to this filepath:
+
+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.
+
+blender.Tools.save_blender_file(base_dir)

pyvale/examples/dic/ex1_region_of_interest.py

@@ -15,14 +15,17 @@ This example looks at the current core functionality of the Region of Interest
 """
 
 from pathlib import Path
-import pyvale
+
+# pyvale modules
+import pyvale.dataset as dataset
+import pyvale.dic as dic
 
 # %% 
 # We'll begin by selecting our Region of Interest (ROI) using the interactive selection tool.
 # First, we create an instance of the ROI class. We pass a reference image to it, which is
 # displayed as the underlay during ROI selection.
-ref_img = pyvale.DataSet.dic_plate_with_hole_ref()
-roi = pyvale.DICRegionOfInterest(ref_image=ref_img)
+ref_img = dataset.dic_plate_with_hole_ref()
+roi = dic.RegionOfInterest(ref_image=ref_img)
 roi.interactive_selection(subset_size=31)
 
 # create a directory for the the different outputs

pyvale/examples/dic/ex2_plate_with_hole.py

@@ -16,7 +16,10 @@ allowing for comparison to analytically known values.
 
 import matplotlib.pyplot as plt
 from pathlib import Path
-import pyvale
+
+# pyvale modules
+import pyvale.dataset as dataset
+import pyvale.dic as dic
 
 # %%
 # We'll start by defining some variables that will be reused throughout the example:
@@ -29,8 +32,8 @@ import pyvale
 # The images used here are included in the `data <https://github.com/Computer-Aided-Validation-Laboratory/pyvale/tree/main/src/pyvale/data>`_ folder.
 # We've provided helper functions to load them regardless of your installation path.
 subset_size = 31
-ref_img = pyvale.DataSet.dic_plate_with_hole_ref()
-def_img = pyvale.DataSet.dic_plate_with_hole_def()
+ref_img = dataset.dic_plate_with_hole_ref()
+def_img = dataset.dic_plate_with_hole_def()
 
 # create a directory for the the different outputs
 output_path = Path.cwd() / "pyvale-output"
@@ -42,7 +45,7 @@ if not output_path.is_dir():
 # Create an instance of the ROI class and pass the reference image
 # as input. This image will be shown as the underlay during any ROI selection or
 # visualization.
-roi = pyvale.DICRegionOfInterest(ref_img)
+roi = dic.RegionOfInterest(ref_img)
 roi.interactive_selection(subset_size)
 
 # %%
@@ -77,22 +80,22 @@ roi.read_array(filename=roi_file, binary=False)
 # At present, the DIC engine doesn't return any results to the user, instead the results are saved to disk.
 # You can customize the filename, location, format, and delimiter using 
 # the options options `output_basepath`, `output_prefix`, `output_delimiter`, and `output_binary`.
-# More info on these options can be found in the documentation for :func:`pyvale.dic_2d`.
+# More info on these options can be found in the documentation for :func:`dic.two_dimensional`.
 # By default, the results will be saved with the prefix `dic_results_` followed
 # by the original filename. The file extension will be replaced will either ".csv" or "dic2d"
 # depending on whether the results are being saved in human-readable or binary format.
-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=10,
-              correlation_criteria="ZNSSD",
-              output_basepath=output_path,
-              output_delimiter=",",
-              output_prefix="dic_results_")
+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=10,
+                    correlation_criteria="ZNSSD",
+                    output_basepath=output_path,
+                    output_delimiter=",",
+                    output_prefix="dic_results_")
 
 # %%
 # If you saved the results in a human-readable format, you can use any tool
@@ -104,7 +107,7 @@ pyvale.dic_2d(reference=ref_img,
 # The returned object is an instance of :class:`pyvale.DICResults`. If the results
 # were saved in binary format or with a custom delimiter, be sure to specify those parameters.
 dic_files = output_path / "dic_results_*.csv"
-dicdata = pyvale.dic_data_import(data=dic_files, delimiter=",", binary=False)
+dicdata = dic.data_import(data=dic_files, delimiter=",", binary=False)
 
 # %%
 # As an example, here's a simple visualization of the displacement (u, v) and

pyvale/examples/dic/ex3_plate_with_hole_strain.py

@@ -17,7 +17,9 @@ be used for strain calculations.
 
 import matplotlib.pyplot as plt
 from pathlib import Path
-import pyvale
+
+# pyvale modules
+import pyvale.dic as dic
 
 # %%
 # We'll start by importing the DIC data from the previous example.
@@ -46,8 +48,8 @@ input_data = output_path / "dic_results_*.csv"
 # The output will always include the window coordinates and the full deformation
 # gradient tensor. If you also specify a `strain_formulation`, the corresponding
 # 2D strain tensor will be included in the output.
-pyvale.strain_2d(data=input_data, window_size=5, window_element=4,
-                 output_basepath=output_path)
+dic.strain_two_dimensional(data=input_data, window_size=5, window_element=4,
+                           output_basepath=output_path)
 
 # %%
 # Once the strain calculation is complete, you can import the results using
@@ -55,9 +57,9 @@ pyvale.strain_2d(data=input_data, window_size=5, window_element=4,
 #
 # Be sure to specify the delimiter, format (binary or not), and layout.
 strain_output = output_path / "strain_dic_results_*.csv"
-straindata = pyvale.strain_data_import(data=strain_output,
-                                       binary=False, delimiter=",",
-                                       layout="matrix")
+straindata = dic.strain_data_import(data=strain_output,
+                                    binary=False, delimiter=",",
+                                    layout="matrix")
 
 # %%
 # Here's a simple example of how to visualize the deformation gradient components

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