pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/examples/dic/ex3_plate_with_hole_strain.py

@@ -0,0 +1,99 @@
+# ================================================================================
+# Example: DIC Challenge 2.0 Comparison
+#
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2024 The Computer Aided Validation Team
+# ================================================================================
+
+"""
+Strain and Deformation Gradient Calculations
+---------------------------------------------
+
+This example follows on from the previous one. It assumes that the DIC results
+have already been generated in the current working directory and are ready to
+be used for strain calculations.
+"""
+
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+# pyvale modules
+import pyvale.dic as dic
+import pyvale.strain as strain
+
+# %%
+# We'll start by importing the DIC data from the previous example.
+
+# create a directory for the the different outputs
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+# specify where our input data is
+input_data = output_path / "dic_results_*.csv"
+
+# %%
+# You can calculate strain directly from the DIC results.
+# It's not necessary to load the data beforehand — you can simply pass the
+# filename (or pattern) to the `data` argument. If you used a custom delimiter
+# or saved in binary format, make sure to specify those as well.
+
+# %%
+# At a minimum, you need to specify the strain window size and the element type
+# used within the window. The valid options for `window_element` are:
+#
+# - `4` for bilinear
+# - `9` for biquadratic
+#
+# 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.
+strain.calculate_2d(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
+# :func:`pyvale.strain.import_2d`.
+#
+# Be sure to specify the delimiter, format (binary or not), and layout.
+strain_output = output_path / "strain_dic_results_*.csv"
+straindata = strain.import_2d(data=strain_output,
+                              binary=False, delimiter=",",
+                              layout="matrix")
+
+# %%
+# Here's a simple example of how to visualize the deformation gradient components
+# for the first deformation step using matplotlib.
+fig, axes = plt.subplots(2, 2, figsize=(10, 10))
+axes = axes.flatten()
+fig.suptitle('Deformation Gradient for ' + straindata.filenames[0])
+
+im1 = axes[0].pcolor(straindata.window_x, straindata.window_y, straindata.def_xx[0])
+im2 = axes[1].pcolor(straindata.window_x, straindata.window_y, straindata.def_xy[0])
+im3 = axes[2].pcolor(straindata.window_x, straindata.window_y, straindata.def_yx[0])
+im4 = axes[3].pcolor(straindata.window_x, straindata.window_y, straindata.def_yy[0])
+
+# titles
+axes[0].set_title('deformation gradient xx')
+axes[1].set_title('deformation gradient xy')
+axes[2].set_title('deformation gradient yx')
+axes[3].set_title('deformation gradient yy')
+
+for aa in axes:
+    aa.set_aspect('equal')
+
+# Colorbars
+fig.colorbar(im1, ax=axes[0])
+fig.colorbar(im2, ax=axes[1])
+fig.colorbar(im3, ax=axes[2])
+fig.colorbar(im4, ax=axes[3])
+
+plt.tight_layout()
+plt.show()
+
+# %%
+# .. image:: ../../../../_static/plate_with_hole_def_grad.png
+#    :alt: Displacement and cost values
+#    :width: 800px
+#    :align: center

pyvale/examples/dic/ex4_dic_blender.py

@@ -0,0 +1,97 @@
+#================================================================================
+#Example: DIC with images generated by blender
+#
+#pyvale: the python validation engine
+#License: MIT
+#Copyright (C) 2024 The Computer Aided Validation Team
+#================================================================================
+
+"""
+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
+simulated data. For this to work, you'll need to complete the `2D image
+deformation example <https://computer-aided-validation-laboratory.github.io/pyvale/examples/renderblender/ex1_2_blenderdeformed.html>`_ using the blender module first. 
+
+**We'd recommend downloading both examples (links can be
+found at the bottom of each example) and placing them within the same folder on 
+your device. That way the relative file paths below will not need to be
+changed.**
+"""
+
+import matplotlib.pyplot as plt
+from pathlib import Path
+import numpy as np
+import os
+
+# pyvale imports
+import pyvale.dic as dic
+
+#subset size
+subset_size = 21
+
+# rename the reference image so that that we can distinguish between reference
+# and deformed images
+if os.path.exists("./blenderimages/blenderimage_0.tiff"):
+    os.rename("./blenderimages/blenderimage_0.tiff", 
+              "./blenderimages/reference.tiff")
+
+ref_img = "./blenderimages/reference.tiff"
+def_img = "./blenderimages/blenderimage_*.tiff"
+
+# Interactive ROI selection
+roi = dic.RegionOfInterest(ref_img)
+roi.interactive_selection(subset_size)
+
+#output_path
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+# DIC Calculation
+dic.calculate_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_")
+
+# Import the Results
+data_path = output_path / "blender_dic_*.csv"
+dicdata = dic.import_2d(data=data_path, delimiter=",",
+                                 layout='matrix', binary=False)
+
+# %%
+# As an example we can plot the v-component of displacement for each of the
+# eight deformation images
+
+# Setup plot
+fig, axes = plt.subplots(2, 4, figsize=(15, 5))
+axes = axes.flatten()
+
+# Compute global min and max for consistent color scaling
+vmin = np.nanmin(dicdata.v)
+vmax = np.nanmax(dicdata.v)
+print(vmin,vmax)
+
+# loop over images and add to subplots
+for i in range(len(dicdata.filenames)):
+    im = axes[i].pcolor(dicdata.ss_x, dicdata.ss_y, dicdata.v[i], vmin=vmin, vmax=vmax)
+    axes[i].set_title(dicdata.filenames[i])
+    fig.colorbar(im, ax=axes[i])
+
+plt.tight_layout()
+plt.show()
+
+# %%
+# .. image:: ../../../../_static/dic_blender_plot.png
+#    :alt: DIC Comparison with ground truth
+#    :width: 800px
+#    :align: center

pyvale/examples/dic/ex5_dic_challenge.py

@@ -0,0 +1,107 @@
+# ================================================================================
+# Example: DIC Challenge 2.0 Comparison
+# 
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2024 The Computer Aided Validation Team
+# ================================================================================
+
+"""
+Comparison to the 2.0 2D DIC Challenge
+---------------------------------------------
+
+The DIC challenge provides a framework for comparison and validation of existing
+DIC Codes. More information can be found at `https://idics.org/challenge/
+<https://idics.org/challenge/>`_. In this example we look at a comparison to a
+image generated with ±0.5 pixel sinusoidal vertical displacement amplitude “star” 
+pattern with varying spatial frequency. More information on the image creation
+can be found in the `original paper
+<https://link.springer.com/article/10.1007/s11340-021-00806-6>`_. In this
+example we'll look at the convergence to the peak vertical discplacement value
+of 0.5 pixels along a particular correlation direction. 
+
+As always, we'll start with importing the required libraries:
+"""
+
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+# 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 = dataset.dic_challenge_ref()
+def_pattern = dataset.dic_challenge_def()
+subset_size = 17
+
+
+# %%
+# we need to select our region of interest. For this example, we are only
+# interested in the subsets along the mid horizontal line.
+# 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 = 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()
+
+# create a directory for the the different outputs
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+# %%
+# .. image:: ../../../../_static/dic_challenge_roi.png
+#    :alt: Selected roi
+#    :width: 800px
+#    :align: center 
+
+
+# %% 
+# To perform the correlation we need to select a seed point. Ideally, this is
+# somewhere in the region where the displacements are small with low noise. 
+# Here we'll select it to be [3500,250], which is close to the right hand
+# boundary where the spatial frequency is lower. The results will be saved in
+# 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.
+dic.calculate_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)
+
+# %% 
+# We can import the results in the standard way
+data_path = output_path / "dic_results_DIC_Challenge*.csv"
+dicdata = dic.import_2d(data=data_path, layout='column', 
+                                 binary=False, delimiter=",")
+
+# &&
+# Finally a simple plot of the calculated displacements at y=2500. This could be
+# extended and compared to other DIC engines used in the 2.0 DIC challenge. A
+# link to the dataset can be found under '2D-DIC Challenge 2.0' can be found
+# at `https://idics.org/challenge/ <https://idics.org/challenge/>`_
+plt.figure()
+plt.xlabel("subset x location [px]")
+plt.ylabel("Displacement [px]")
+plt.grid(True)
+plt.axhline(y=0.5, color='red', linestyle='--', linewidth=4)
+plt.plot(dicdata.ss_x, dicdata.v[0,:])
+plt.tight_layout()
+plt.show()
+
+# %%
+# .. image:: ../../../../_static/dic_challenge_plot.png
+#    :alt: DIC Comparison with ground truth
+#    :width: 600px
+#    :align: center

pyvale/examples/extsensorsim/README.md

@@ -0,0 +1,2 @@
+Sensor Simulation: Extended Examples
+====================================

pyvale/examples/extsensorsim/ex1_byosimdata.py

@@ -0,0 +1,211 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""Bring your own simulation data 
+================================================================================
+
+In this example we demonstrate how you can load your own simulation data from
+either plain text or numpy binary array files into a `SimData` object for use
+with the pyvale sensor simulation engine. We do this by first converting and 
+saving an exodus simulation output file in plain text so we can see the format
+that is expected when we load the data.
+
+This example only demonstrates how to load simulation data into a `SimData`
+object 
+"""
+
+from pathlib import Path
+import numpy as np
+import matplotlib.pyplot as plt
+
+# pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
+
+
+#%%
+# 1. Save existing SimData to csv 
+# --------------------------------
+#
+# We are going to start by loading one the pre-packaged simulation datasets in
+# exodus format that comes with `pyvale`. We are then going to take the
+# `SimData` object and save it to the csv/txt format and numpy array formats
+# that can be loaded into `pyvale` so we can see what structure these files need
+# to be.
+data_path: Path = dataset.element_case_output_path(dataset.EElemTest.HEX20)
+sim_data: mh.SimData = mh.ExodusLoader(data_path).load_all_sim_data()
+
+#%%
+# Let's create our standard pyvale output directory in our current working
+# directory so we know where to find the csv and npy files we are going to
+# create from our `SimData` object.
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+#%%
+# All the simulation IO for `pyvale` can be found in the `mooseherder` module.
+# Here we will save our fields in both formats `BY_TIME` and `BY_FIELD`. For the
+# `BY_TIME` case each file will be a time step or frame  were the rows
+# correspond to the coordinate and the column corresponds to the individual
+# field. For the plain  text version the column headers will be the keys from
+# the `SimData.node_vars` dictionary. `BY_FIELD` means there will be one file
+# per field where the rows are the coordinate and the columns are the time
+# steps. In this case the field key will appear in the file name. We will see
+# later that we can load field in either of these formats.
+#
+# For saving the array files we can either use plain `TXT` or numpy binary
+# format `NPY`- here we save both.
+#
+# Finally, we use the simulation tag of "hex20" which will be a prefix on the
+# files we output so we can identify the simulation.
+save_opts = mh.SimDataSaveOpts(fields_save_by=mh.ESaveFieldOpt.BOTH,
+                               array_format = mh.ESaveArray.BOTH,
+                               sim_tag="hex20")
+
+mh.save_sim_data_to_arrays(output_path,sim_data,save_opts)
+
+#%%
+# Now if we have a look at the files in the pyvale-output directory we can see
+# what the expected format is going to be. There are two key files we need: 1) 
+# the list of nodal coordinates for the simulation; and 2) the list of time 
+# steps. These can be found in the files: "hex20_coords" and "hex20_time.csv".
+# We can also choose not to load these from disk and build the numpy arrays 
+# ourselves programmatically. 
+#
+# The connectivity table is optional as we will see in out example on mesh free 
+# virtual sensors but we will load it here to demonstrate mesh-based sensors. In 
+# this case each meshed object in the simulation has a connectivity table 
+# labelled "connectX" where X is an integer specifying the unique mesh in the 
+#  simulation. The "hex20_connect1.csv" has the shape 20 by number of elements 
+# in the mesh as we are using 20 node hexahedral elements.
+#
+# We can also see the field files which are labelled "hex20_node_field_*" with
+# a suffix of "frameX" for fields saved 'by time step' or a suffix of the field 
+# key for the case where we have saved 'by field'.
+
+#%%
+# Before we load the data we will specify a common file suffix and the paths to
+# the coordinate and time files.
+
+suffix: str = ".csv" # can be changed to ".npy"
+coords_file: str = "hex20_coords" + suffix
+time_step_file: str = "hex20_time" + suffix
+
+#%%
+# 2. Load SimData 'by time'
+# -------------------------
+#
+# First let's load the data 'by time'. This is a bit more complicated than 'by
+# field' as we need to specify how to slice into each frame to extract each
+# nodal field variable as well as specifying the wildcard pattern to search for
+# in the list of output time steps. 
+# 
+# We create the `field_slices` dictionary keyed by the same string we want the
+# field variable to have when it is loaded into `SimData.node_vars`. The value
+# for each key is then a slice specifying the column for the field variable in
+# the time step/frame file to read.
+#
+# We then create the wildcard pattern used to find the field files in the 
+# `field_pattern` variable below.  
+
+field_pattern = f"hex20_node_field_frame*{suffix}"
+
+field_slices = {"disp_x": slice(0,1),
+                "disp_y": slice(1,2),
+                "disp_z": slice(2,3),
+                "temperature": slice(9,10),}
+
+
+connect_pattern = f"hex20_connect*" 
+
+#%%
+# We create our load options specifying that we will load the data single 
+# threaded and not using the multi-processing library (the default). For loading
+# large datasets the number of workers can be changed to a positive integer 
+# based on the number of threads available on your machine. Parallelisation will
+# only be helpful if your files are large and you have many of them. Here we 
+# have a fairly small simulation with few files so single threaded will be 
+# faster.
+# 
+# We can now create our loader and use it to load all the simulation data into
+# our `SimData` object which we can now use with the rest of the `pyvale` tools.
+
+workers: int | None = None
+load_opts = mh.SimLoadOpts(workers=workers)
+
+sim_loader = mh.SimLoaderByTime(load_dir=output_path,
+                                coords_file=coords_file,
+                                time_step_file=time_step_file,
+                                node_files=field_pattern,
+                                node_slices=field_slices,
+                                connect_files=connect_pattern,
+                                glob_file=None,
+                                glob_slices=None,
+                                load_opts=load_opts)
+
+sim_data_load: mh.SimData = sim_loader.load_all_sim_data()
+
+#%%
+# Let's print some summary data to the terminal so we can see what our `SimData`
+# object contains:
+print(80*"-")
+print("SIM DATA: by time")
+print(80*"-")
+sens.print_sim_data(sim_data_load)
+print()
+
+#%%
+# 3. Load SimData 'by field'
+# --------------------------
+#
+# Now we will load the data 'by field' which is the simplest case as it is most
+# similar to how the `SimData` object stores our nodal fields. Specifically, 
+# each nodal variable is a numpy array where the first dimension corresponds to
+# the position in the coordinate array and the second dimension is the time 
+# step. Here we don't need to slice into field arrays so can just provide a 
+# dictionary where keys are the same as what we want in our `SimData.node_vars`
+# dictionary and the values are strings specifying the file names for that 
+# field.
+
+field_keys = {"disp_x","disp_y","disp_z","temperature"}
+
+prefix = "hex20_node_field"
+
+field_files = {}
+for ff in field_keys:
+    field_files[ff] = f"{prefix}_{ff}{suffix}"
+
+#%%
+# When we load data 'by field' the files generally do not have header rows so we
+# set this to None in the load options. Other than that loading the simulation 
+# data into our `SimData` object is exactly the same as we did previously. 
+
+load_opts = mh.SimLoadOpts(node_field_header=None,
+                           workers=workers)
+
+sim_loader = mh.SimLoaderByField(load_dir=output_path,
+                                 coords_file=coords_file,
+                                 time_step_file=time_step_file,
+                                 node_field_files=field_files,
+                                 connect_files=connect_pattern,
+                                 glob_file=None,
+                                 glob_slices=None,
+                                 load_opts=load_opts)
+
+sim_data_load: mh.SimData = sim_loader.load_all_sim_data()
+
+print(80*"-")
+print("SIM DATA: by field")
+print(80*"-")
+sens.print_sim_data(sim_data_load)
+
+#%%
+# That's it for this example! We will leave it as an exercise to load the strain
+# fields from the files in the output directory and to connect the `SimData` 
+# object you have just loaded to the rest of the `pyvale` sensor simulation 
+# engine.

pyvale/examples/extsensorsim/ex2_meshfreesensors.py

@@ -0,0 +1,174 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""Mesh-free virtual sensors
+================================================================================
+
+This example shows the ability of the pyvale sensor simulation module to apply
+virtual sensors for the case where the provided simulation data is a point
+cloud and does not contain a structured mesh with a connectivity table. For this
+case pyvale uses a Delaunay triangulation to perform linear interpolation of
+the simulation point cloud at the virtual sensor locations. The mesh free
+method is computationally more expensive than the mesh based method, especially
+in 3D, but it does give much more flexibility in input simulation data.
+
+The only difference between the mesh-based and mesh-free cases from a user
+interface perspective is that there is no connectivity table in the `SimData`
+object created by the user. Otherwise creating a sensor array is exactly the
+same as all previous examples - apart from the computational overhead of the
+mesh-free interpolation.
+"""
+
+import copy
+import time
+import numpy as np
+import pyvale as pyv
+
+# pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.verif as verif
+
+
+#%%
+# 1. Create analytic simulation data
+# ----------------------------------
+# For this example we are going to use a generated analytic dataset instead of
+# a finite element simulation as we want an analytic function for the measured
+# field that is linear so we can see that mesh-free interpolation matches the
+# mesh-based interpolation. For finite element simulations using non-tetrahedral
+# and/or high order elements the mesh-free method will not match the mesh-based.
+#
+# The analytic case is a rectangular plate that is 10x7.5 units in length with
+# a mesh of 40x30 elements. The physical field is scalar with a bi-linear
+# spatial gradient of 20/10 = 2 in the X direction and 10/7.5 = 1.33 in the Y
+# direction.
+#
+# Initially the generated `SimData` object is mesh-based so we create a copy and
+# then set the connectivity table dictionary to None to indicate that our data
+# is mesh-free.
+(sim_data,_) = verif.analyticsimdatafactory.scalar_linear_2d()
+
+sim_data_nomesh = copy.deepcopy(sim_data)
+sim_data_nomesh.connect = None
+
+#%%
+# We will use the same `SensorData` for the mesh-free and mesh-based sensor
+# arrays. First, we use a helper function to get the limiting dimensions of the
+# plate and use this to create our sensor position array. Then we specify our
+# sample times and use our sensor positions and sample times to create our
+# `SensorData` object.
+
+sim_dims = sens.simtools.get_sim_dims(sim_data)
+sens_pos = sens.gen_pos_grid_inside(num_sensors=(4,2,1),
+                                        x_lims=sim_dims["x"],
+                                        y_lims=sim_dims["y"],
+                                        z_lims=(0.0,0.0))
+
+sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+sens_data = sens.SensorData(positions=sens_pos,
+                            sample_times=sample_times)
+
+#%%
+# 2. Build virtual sensor arrays
+# --------------------------------
+# Now we create our virtual sensor arrays. There is no difference between the
+# mesh-based and mesh-free case in how these are created as `pyvale`
+# automatically detects that the connectivity table in the `SimData` object is
+# None and creates the Delaunay triangulation for later interpolation to virtual
+# sensor locations.
+#
+# The triangulation is computationally expensive, especially in 3D. For the 2D
+# case shown here with 1200 elements creating the sensor array is about 6
+# times slower than the mesh-based case.
+
+start_time = time.perf_counter()
+tc_array: sens.SensorsPoint = sens.SensorFactory.scalar_point(
+    sim_data,
+    sens_data,
+    comp_key="temperature",
+    spatial_dims=sens.EDim.TWOD,
+    descriptor=sens.DescriptorFactory.temperature(),
+)
+mesh_time = (time.perf_counter() - start_time)*1000.0
+
+
+start_time = time.perf_counter()
+tc_array_nomesh: sens.SensorsPoint = sens.SensorFactory.scalar_point(
+    sim_data_nomesh,
+    sens_data,
+    comp_key="temperature",
+    spatial_dims=sens.EDim.TWOD,
+    descriptor=sens.DescriptorFactory.temperature(),
+)
+
+nomesh_time = (time.perf_counter() - start_time)*1000.0
+
+print(80*"-")
+print("Sensor Array Creation Times:")
+print(f"Mesh based = {mesh_time:.3f} milliseconds")
+print(f"Mesh free  = {nomesh_time:.3f} milliseconds\n")
+
+#%%
+# 3. Run simulated experiment
+# ------------------------------------
+# Now we can simulate some measurements for the mesh-based and mesh-free cases
+# and compare the time taken for the calculation. Rough testing shows that the
+# mesh-free case takes about 5 times longer than the mesh-based case.
+
+start_time = time.perf_counter()
+meas = tc_array.get_measurements()
+mesh_time = (time.perf_counter() - start_time)*1000.0
+
+start_time = time.perf_counter()
+meas_nomesh = tc_array_nomesh.get_measurements()
+nomesh_time = (time.perf_counter() - start_time)*1000.0
+
+print(80*"-")
+print("Measurement Simulation Times")
+print(f"Mesh based = {mesh_time:.3f} milliseconds")
+print(f"Mesh free  = {nomesh_time:.3f} milliseconds\n")
+
+
+#%%
+# 4. Analyse the results
+# ----------------------------------
+# Finally, we can compare the measurements for both sensor arrays. As our
+# virtual sensors are measuring a linear field in 2D with linear elements the
+# mesh-based and mesh-free cases should agree exactly (especially because we
+# are not simulating any measurement errors).
+
+print(80*"-")
+print("MESH BASED INTERPOLATION")
+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("MESH FREE INTERPOLATION")
+sens.print_measurements(tc_array_nomesh,
+                        slice(0,1), # Sensor 1
+                        slice(0,1), # Component 1: scalar field = 1 component
+                        slice (meas_nomesh.shape[2]-5,meas_nomesh.shape[2]))
+
+print(f"\n{np.allclose(meas,meas_nomesh)=}")
+print(80*"-")
+
+# %%
+# Example terminal output with timings and numerical comparison between
+# mesh-based and mesh-free virtual sensors:
+#
+# .. image:: ../../../../_static/ext_ex2_term_out.png
+#    :alt: Terminal output comparing mesh-based and mesh-free sensors.
+#    :width: 700px
+#    :align: center
+
+#%%
+# That's it for this example! Mesh-free virtual sensors work in exactly the same
+# way as the mesh-based sensors, they are just a bit more computationally heavy
+# and slower.
+