pyvale 2025.4.1__py3-none-any.whl → 2025.5.1__py3-none-any.whl

pyvale/examples/basics/ex2_3_sensangle_disp2d.py

@@ -0,0 +1,139 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: Sensor angles for vector fields
+--------------------------------------------------------------------------------
+In this example we demonstrate how to setup vector field sensors at custom
+orientations with respect to the simulation coordinate system. We first build a
+sensor array aligned with the simulation coords in the same way as the previous
+example. We then build a sensor array with the sensors rotated and compare this
+to the case with no rotation.
+
+Note that this tutorial assumes you are familiar with the use of pyvale for
+scalar fields as described in the first set of examples.
+
+Test case: point displacement sensors on a 2D plate with hole loaded in tension
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.spatial.transform import Rotation
+import mooseherder as mh
+import pyvale as pyv
+
+def main() -> None:
+    # First we are going to setup the same displacement sensor array on the 2D
+    # solid mechanics test case we have used previously. This will serve as a
+    # baseline with no sensor rotation.
+
+    data_path = pyv.DataSet.mechanical_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+
+    field_name = "disp"
+    field_comps = ("disp_x","disp_y")
+    sim_data = pyv.scale_length_units(scale=1000.0,
+                                      sim_data=sim_data,
+                                      disp_comps=field_comps)
+
+    descriptor = pyv.SensorDescriptorFactory.displacement_descriptor()
+
+    disp_field = pyv.FieldVector(sim_data,field_name,field_comps,elem_dims=2)
+
+    n_sens = (2,3,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,150.0)
+    z_lims = (0.0,0.0)
+    sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+
+    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sens_data_norot = pyv.SensorData(positions=sens_pos,
+                                     sample_times=sample_times)
+
+    disp_sens_norot = pyv.SensorArrayPoint(sens_data_norot,
+                                           disp_field,
+                                           descriptor)
+
+    disp_sens_norot.calc_measurements()
+
+    # To create our sensor array with rotated sensors we need to add a tuple of
+    # scipy rotation objects to our sensor data class. This tuple must be the
+    # same length as the number of sensors in the sensor array. Note that it is
+    # also possible to specify a single rotation in the tuple in this case all
+    # sensors are assumed to have the same rotation and they are batch processed
+    # to increase speed. Here we will define our rotations to all be the same
+    # rotation in degrees about the z axis which is the out of plane axis for
+    # our current test case.
+    sens_angles = sens_pos.shape[0] * \
+        (Rotation.from_euler("zyx", [45, 0, 0], degrees=True),)
+
+    # We could have also use a single element tuple to have all sensors have the
+    # angle and batch process them:
+    sens_angles = (Rotation.from_euler("zyx", [45, 0, 0], degrees=True),)
+
+
+    sens_data_rot = pyv.SensorData(positions=sens_pos,
+                                   sample_times=sample_times,
+                                   angles=sens_angles)
+
+    disp_sens_rot = pyv.SensorArrayPoint(sens_data_rot,
+                                            disp_field,
+                                            descriptor)
+
+    # We can also use a field error to add uncertainty to the sensors angle.
+    # We can apply a specific offset to each sensor or provide a random
+    # generator to perturb the sensors orientation. Note that the offset and
+    # the random generator should provide the perturbation in degrees.
+    angle_offset = np.zeros_like(sens_pos)
+    angle_offset[:,0] = 2.0 # only rotate about z in 2D
+    angle_rand = (pyv.GenNormal(std=2.0),None,None)
+    angle_error_data = pyv.ErrFieldData(ang_offset_zyx=angle_offset,
+                                        ang_rand_zyx=angle_rand)
+
+
+    sys_err_rot = pyv.ErrSysField(disp_field,angle_error_data)
+    sys_err_int = pyv.ErrIntegrator([sys_err_rot],
+                                    sens_data_rot,
+                                    disp_sens_rot.get_measurement_shape())
+    disp_sens_rot.set_error_integrator(sys_err_int)
+
+    measurements = disp_sens_rot.calc_measurements()
+
+
+    # We print some of the results for one of the sensors so we can see the
+    # effect of the field errors.
+    print(80*"-")
+
+    sens_print: int = 0
+    time_print: int = 5
+    comp_print: int = 0
+
+    print("ROTATED SENSORS WITH ANGLE ERRORS:")
+    print(f"These are the last {time_print} virtual measurements of sensor "
+          + f"{sens_print} for {field_comps[comp_print]}:")
+
+    pyv.print_measurements(sens_array=disp_sens_rot,
+                           sensors=(sens_print,sens_print+1),
+                           components=(comp_print,comp_print+1),
+                           time_steps=(measurements.shape[2]-time_print,
+                                       measurements.shape[2]))
+    print(80*"-")
+
+    # We can now plot the traces for the non-rotated and rotated sensors to
+    # compare them:
+    for ff in field_comps:
+        (_,ax) = pyv.plot_time_traces(disp_sens_norot,ff)
+        ax.set_title("No Rotation")
+        (_,ax) = pyv.plot_time_traces(disp_sens_rot,ff)
+        ax.set_title("Rotated with Errors")
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/basics/ex2_4_chainfielderrs_disp2d.py

@@ -0,0 +1,196 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: Chaining field errors
+----------------------------------------------------------------------------
+In this example we show how field errors can be chained together and accumulated
+allowing for successive perturbations in postion, sampling time and orientation.
+It is more computationally efficient to provide a single field error object as
+this will perform all perturbations in a single step allowing for a single new
+interpolation of the underlying physical field. However, in some cases it can
+be useful to separate the sensor parameter perturbations to determine which is
+contributing most to the total error.
+
+Note that this tutorial assumes you are familiar with the use of pyvale for
+scalar fields as described in the first set of examples.
+
+Test case: point displacement sensors on a 2D plate with hole loaded in tension
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+def main() -> None:
+    # We start by building the same displacement sensor array applied to a 2D
+    # solid mechanics simulation that we have analysed previously.
+    data_path = pyv.DataSet.mechanical_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    field_name = "disp"
+    field_comps = ("disp_x","disp_y")
+    sim_data = pyv.scale_length_units(scale=1000.0,
+                                      sim_data=sim_data,
+                                      disp_comps=field_comps)
+
+    descriptor = pyv.SensorDescriptorFactory.displacement_descriptor()
+
+    disp_field = pyv.FieldVector(sim_data,field_name,field_comps,elem_dims=2)
+
+    n_sens = (2,3,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,150.0)
+    z_lims = (0.0,0.0)
+    sensor_positions = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sensor_data = pyv.SensorData(positions=sensor_positions,
+                                 sample_times=sample_times)
+
+    disp_sens_array = pyv.SensorArrayPoint(sensor_data,
+                                           disp_field,
+                                           descriptor)
+
+
+    # Now we will build a series of field errors that cause succesive offsets in
+    # sensor sampling time, sensor position and sensor orientation. That way
+    # we should be able to analyse the sensor data object at each point in the
+    # error chain to see how the sensor parameters have accumulated.
+
+    # We will apply a position offset of -1.0mm in the x and y axes.
+    pos_offset = -1.0*np.ones_like(sensor_positions)
+    pos_offset[:,2] = 0.0 # in 2d we only have offset in x and y so zero z
+    pos_error_data = pyv.ErrFieldData(pos_offset_xyz=pos_offset)
+
+    # We will apply a rotation offset about the z axis of 1 degree
+    angle_offset = np.zeros_like(sensor_positions)
+    angle_offset[:,0] = 1.0 # only rotate about z in 2D
+    angle_error_data = pyv.ErrFieldData(ang_offset_zyx=angle_offset)
+
+    time_offset = 2.0*np.ones_like(disp_sens_array.get_sample_times())
+    time_error_data = pyv.ErrFieldData(time_offset=time_offset)
+
+    # Now we add all our field errors to our error chain. We add each error
+    # twice to see how they accumulate with each other. We also need to set the
+    # error dependence to `DEPENDENT` so that the sensor state is accumulated
+    # over the error chain as field errors are `INDEPENDENT` by default.
+    err_chain = []
+    err_chain.append(pyv.ErrSysField(disp_field,
+                                     time_error_data,
+                                     pyv.EErrDep.DEPENDENT))
+    err_chain.append(pyv.ErrSysField(disp_field,
+                                     time_error_data,
+                                     pyv.EErrDep.DEPENDENT))
+
+    err_chain.append(pyv.ErrSysField(disp_field,
+                                     pos_error_data,
+                                     pyv.EErrDep.DEPENDENT))
+    err_chain.append(pyv.ErrSysField(disp_field,
+                                     pos_error_data,
+                                     pyv.EErrDep.DEPENDENT))
+
+    err_chain.append(pyv.ErrSysField(disp_field,
+                                     angle_error_data,
+                                     pyv.EErrDep.DEPENDENT))
+    err_chain.append(pyv.ErrSysField(disp_field,
+                                     angle_error_data,
+                                     pyv.EErrDep.DEPENDENT))
+
+    # Instead of setting the dependence for each individual error above we could
+    # also just use our error integration options to force all errors to be
+    # `DEPENDENT`. We also set the error integration options to store the errors
+    # for each step in the error chain so we can analyse the sensor data at each
+    # step of chain. This option also allows us to separate the contribution of
+    # each error in the chain to the total error rather than just being able to
+    # analyse the total systematic and total random error which is the default.
+    # Note that this option will use more memory.
+    err_int_opts = pyv.ErrIntOpts(force_dependence=pyv.EErrDep.DEPENDENT,
+                                  store_all_errs=True)
+
+    # Now we build our error integrator, add it to our sensor array and then run
+    # our sensor simulation to obtain some virtual measurements.
+    error_int = pyv.ErrIntegrator(err_chain,
+                                  sensor_data,
+                                  disp_sens_array.get_measurement_shape(),
+                                  err_int_opts)
+    disp_sens_array.set_error_integrator(error_int)
+
+    measurements = disp_sens_array.calc_measurements()
+
+
+    # Here we will print to the console the time, position and angle of from the
+    # sensor data objects at each point in the error chain. We should see each
+    # sensor parameter perturbed and accumulated throughout the chain:
+    sens_data_by_chain = error_int.get_sens_data_by_chain()
+    if sens_data_by_chain is not None:
+        for ii,ss in enumerate(sens_data_by_chain):
+            print(80*"-")
+            if ss is not None:
+                print(f"SensorData @ [{ii}]")
+                print("TIME")
+                print(ss.sample_times)
+                print()
+                print("POSITIONS")
+                print(ss.positions)
+                print()
+                print("ANGLES")
+                for aa in ss.angles:
+                    print(aa.as_euler("zyx",degrees=True))
+                print()
+            print(80*"-")
+
+    # Try setting all the field errors to be `INDEPENDENT` using the error
+    # integration options above. You should see that the sensor parameters are
+    # not accumulated throughout the error chain.
+
+    # Here we print the final sampling time, sensor positions and sensor angles
+    # at the end of error chain.
+    print()
+    print(80*"=")
+    sens_data_accumulated = error_int.get_sens_data_accumulated()
+    print("TIME")
+    print(sens_data_accumulated.sample_times)
+    print()
+    print("POSITIONS")
+    print(sens_data_accumulated.positions)
+    print()
+    print("ANGLES")
+    for aa in sens_data_accumulated.angles:
+        print(aa.as_euler("zyx",degrees=True))
+    print()
+    print(80*"=")
+
+    # We print the results for one of the sensors so we can see what the errors
+    # are for the last few sampling times.
+    print(80*"-")
+
+    sens_print: int = 0
+    time_print: int = 5
+    comp_print: int = 0
+
+    print("ROTATED SENSORS WITH ANGLE ERRORS:")
+    print(f"These are the last {time_print} virtual measurements of sensor "
+          + f"{sens_print} for {field_comps[comp_print]}:")
+
+    pyv.print_measurements(sens_array=disp_sens_array,
+                           sensors=(sens_print,sens_print+1),
+                           components=(comp_print,comp_print+1),
+                           time_steps=(measurements.shape[2]-time_print,
+                                       measurements.shape[2]))
+    print(80*"-")
+
+
+    # Finally, we plot the time traces for all field components.
+    for ff in field_comps:
+        pyv.plot_time_traces(disp_sens_array,ff)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/basics/ex2_5_vectorfields3d_disp3d.py

@@ -0,0 +1,109 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: 3D vector field sensors
+--------------------------------------------------------------------------------
+In all our previous examples we have looked at a 2D solid mechanics simulation
+and applied displacement sensors to the vector field. Here we will build a
+custom vector field sensor array on a 3D simulation of a small linear elastic
+cube loaded in tension with the addition of an applied thermal gradient.
+
+Note that this tutorial assumes you are familiar with the use of pyvale for
+scalar fields as described in the first set of examples.
+
+Test case: Simple 3D cube thermo-mechanical in tension with temp gradient.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+
+def main() -> None:
+    # Frist we load our simulation as a `SimData` object. In this case we are
+    # loading a 10mm cube loaded in tension in the y direction with the addition
+    # of a thermal gradient in the y direction.
+    data_path = pyv.DataSet.element_case_path(pyv.EElemTest.HEX20)
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+
+    # As we are creating a 3D vector field sensor we now have a third
+    # displacement field component here.
+    field_name = "disp"
+    field_comps = ("disp_x","disp_y","disp_z")
+    sim_data = pyv.scale_length_units(scale=1000.0,
+                                      sim_data=sim_data,
+                                      disp_comps=field_comps)
+
+    # We use a helper function to print the extent of the dimensions in our
+    # `SimData` object to help us locate our sensors on the cube.
+    pyv.print_dimensions(sim_data)
+
+    descriptor = pyv.SensorDescriptorFactory.displacement_descriptor()
+
+    # We pass in the string keys for the three vector field components as they
+    # appear in our `SimData` object as well as specifying that our elements are
+    # 3 dimensional.
+    disp_field = pyv.FieldVector(sim_data,field_name,field_comps,elem_dims=3)
+
+    # Here we manually define our sensor positions to place a sensor on the
+    # centre of each face of our 10mm cube. From here everything is the same as
+    # for our 2D vector field sensor arrays.
+    sensor_positions = np.array(((5.0,0.0,5.0),
+                                 (5.0,10.0,5.0),
+                                 (5.0,5.0,0.0),
+                                 (5.0,5.0,10.0),
+                                 (0.0,5.0,5.0),
+                                 (10.0,5.0,5.0),))
+
+    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sensor_data = pyv.SensorData(positions=sensor_positions,
+                                 sample_times=sample_times)
+
+    disp_sens_array = pyv.SensorArrayPoint(sensor_data,
+                                           disp_field,
+                                           descriptor)
+
+    measurements = disp_sens_array.calc_measurements()
+
+    # Let's have a look at the y displacement field in relation to the location
+    # of our displacement sensors.
+    pv_plot = pyv.plot_point_sensors_on_sim(disp_sens_array,"disp_y")
+    pv_plot.show()
+
+    # We print the results for one of the sensors so we can see what the errors
+    # are for the last few sampling times.
+    print(80*"-")
+
+    sens_print: int = 0
+    time_print: int = 5
+    comp_print: int = 0
+
+    print(f"These are the last {time_print} virtual measurements of sensor "
+          + f"{sens_print} for {field_comps[comp_print]}:")
+
+    pyv.print_measurements(sens_array=disp_sens_array,
+                           sensors=(sens_print,sens_print+1),
+                           components=(comp_print,comp_print+1),
+                           time_steps=(measurements.shape[2]-time_print,
+                                       measurements.shape[2]))
+    print(80*"-")
+
+
+    # Finally, we plot the time traces for all field components noting that we
+    # expect the bottom of the cube to be fixed, the top of the cube to have the
+    # maximum y displacement, and that all sensors on the sides of the cube
+    # should give the same results.
+    for ff in field_comps:
+        pyv.plot_time_traces(disp_sens_array,ff)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/basics/ex3_1_basictensors_strain2d.py

@@ -0,0 +1,114 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: Basic tensor field sensors (strain gauges)
+--------------------------------------------------------------------------------
+In this example we use the sensor array factory to build a set of strain
+sensors that can sample the strain tensor field from a solid mechanics
+simulation. In the next example we will examine how we can build custom tensor
+field sensors as we did for scalar field in the first set of examples.
+
+Note that this tutorial assumes you are familiar with the use of pyvale for
+scalar fields as described in the first set of examples.
+
+Test case: point strain sensors on a 2D plate with hole loaded in tension
+"""
+
+from pathlib import Path
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+from mooseherder import SimData
+import pyvale as pyv
+
+def main() -> None:
+    # First we load the same 2D solid mechanics simulation we used previously
+    # for vector displacement fields. Most of this setup code is similar to our
+    # vector field examples except we will need to specify the string keys for
+    # the normal a deviatoric components of our tensor field (as they appear in
+    # our `SimData` object).
+    data_path: Path = pyv.DataSet.mechanical_2d_path()
+    sim_data: SimData = mh.ExodusReader(data_path).read_all_sim_data()
+    sim_data: SimData = pyv.scale_length_units(scale=1000.0,
+                                                sim_data=sim_data,
+                                                disp_comps=("disp_x","disp_y"))
+
+    n_sens = (2,3,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,150.0)
+    z_lims = (0.0,0.0)
+    sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sens_data = pyv.SensorData(positions=sens_pos,
+                               sample_times=sample_times)
+
+    # This is where we need to specify the string keys for the normal and
+    # deviatoric components of our strain field. In 2D we have two normal
+    # normal components and one deviatoric. In 3D we will have 3 of each as we
+    # will see in a later example. Otherwise this is very similar to what we
+    # have seen previously for scalar and vector fields.
+    norm_comps = ("strain_xx","strain_yy")
+    dev_comps = ("strain_xy",)
+    straingauge_array = pyv.SensorArrayFactory \
+                            .strain_gauges_basic_errs(sim_data,
+                                                      sens_data,
+                                                      elem_dims=2,
+                                                      field_name="strain",
+                                                      norm_comps=norm_comps,
+                                                      dev_comps=dev_comps,
+                                                      errs_pc=5.0)
+
+    # We run our virtual sensor simulation as normal. The only thing to note is
+    # that the second dimension of our measurement array will contain our tensor
+    # components in the order they are specified in the tuples with the normal
+    # components first followed by the deviatoric. In our case this will be
+    # (strain_xx,strain_yy,strain_xy).
+    measurements = straingauge_array.calc_measurements()
+
+    # Here we print the shape of the measurement array so we can see that the
+    # second dimension contains both our tensor components. We also print some
+    # of the sensor measurements for the first tensor component.
+    print("\n"+80*"-")
+    print("For a virtual sensor: measurement = truth + sysematic error + random error")
+    print(f"measurements.shape = {measurements.shape} = "+
+          "(n_sensors,n_field_components,n_timesteps)\n")
+    print("The truth, systematic error and random error arrays have the same "+
+          "shape.")
+
+    print(80*"-")
+
+    sens_print: int = 0
+    time_print: int = 5
+    comp_print: int = 0
+
+    print(f"These are the last {time_print} virtual measurements of sensor "
+          + f"{sens_print}:")
+
+    pyv.print_measurements(sens_array=straingauge_array,
+                           sensors=(sens_print,sens_print+1),
+                           components=(comp_print,comp_print+1),
+                           time_steps=(measurements.shape[2]-time_print,
+                                       measurements.shape[2]))
+    print(80*"-")
+
+    # We can plot a given component of our tensor field and display our sensor
+    # locations with respect to the field.
+    plot_field = "strain_yy"
+    pv_plot = pyv.plot_point_sensors_on_sim(straingauge_array,plot_field)
+    pv_plot.show(cpos="xy")
+
+    # We can also plot time traces for all components of the tensor field.
+    for cc in (norm_comps+dev_comps):
+        pyv.plot_time_traces(straingauge_array,cc)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/basics/ex3_2_tensorsens2d_strain2d.py

@@ -0,0 +1,111 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: Custom tensor field sensors (strain gauges) in 2D
+--------------------------------------------------------------------------------
+In this example we build a custom tensor field sensor array (i.e. a strain gauge
+array) in 2D.
+
+Note that this tutorial assumes you are familiar with the use of pyvale for
+scalar fields as described in the first set of examples.
+
+Test case: point strain sensors on a 2D plate with hole loaded in tension
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+def main() -> None:
+    # First we load the same 2D solid mechanics simulation of a plate with a
+    # hole loaded in tension as a `SimData` object. We scale the units to mm
+    # from SI including the coordinates and displacement. Strain is unitless so
+    # we leave it alone.
+    data_path = pyv.DataSet.mechanical_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    sim_data = pyv.scale_length_units(scale=1000.0,
+                                      sim_data=sim_data,
+                                      disp_comps=("disp_x","disp_y"))
+
+
+    # Here is the main difference when creating a tensor field sensor array. We
+    # create a tensor field where we need to specify the normal and deviatoric
+    # component string keys as they appear in our `SimData` object. We have a 2d
+    # simulation here so we have 2 normal components and 1 deviatoric (shear).
+    field_name = "strain"
+    norm_comps = ("strain_xx","strain_yy")
+    dev_comps = ("strain_xy",)
+    strain_field = pyv.FieldTensor(sim_data,
+                                   field_name=field_name,
+                                   norm_comps=norm_comps,
+                                   dev_comps=dev_comps,
+                                   elem_dims=2)
+
+    # The setup of our sensor data object is exactly the same as for any other
+    # point sensor array. We could optionally specify the sample time to be None
+    # in which case the sensor will sample at the simulation time steps.
+    n_sens = (2,3,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,150.0)
+    z_lims = (0.0,0.0)
+    sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sens_data = pyv.SensorData(positions=sens_pos,
+                               sample_times=sample_times)
+
+    # Here we create a descriptor that will be used to label visualisations of
+    # the sensor locations and time traces for our sensors. For the strain
+    # gauges we are modelling here we could also use the descriptor factory to
+    # get these defaults.
+    descriptor = pyv.SensorDescriptor(name="Strain",
+                                      symbol=r"\varepsilon",
+                                      units=r"-",
+                                      tag="SG",
+                                      components=("xx","yy","xy"))
+
+    # We build our point sensor array as normal.
+    straingauge_array = pyv.SensorArrayPoint(sens_data,
+                                             strain_field,
+                                             descriptor)
+
+
+    # We can add any errors we like to our error chain. Here we add some basic
+    # percentage errors.
+    error_chain = []
+    error_chain.append(pyv.ErrSysUnifPercent(low_percent=-2.0,high_percent=2.0))
+    error_chain.append(pyv.ErrRandNormPercent(std_percent=2.0))
+    error_int = pyv.ErrIntegrator(error_chain,
+                                  sens_data,
+                                  straingauge_array.get_measurement_shape())
+    straingauge_array.set_error_integrator(error_int)
+
+    # We run our virtual sensor simulation as normal. The only thing to note is
+    # that the second dimension of our measurement array will contain our tensor
+    # components in the order they are specified in the tuples with the normal
+    # components first followed by the deviatoric. In our case this will be
+    # (strain_xx,strain_yy,strain_xy).
+    measurements = straingauge_array.calc_measurements()
+
+    # We can plot a given component of our tensor field and display our sensor
+    # locations with respect to the field.
+    plot_field = "strain_yy"
+    pv_plot = pyv.plot_point_sensors_on_sim(straingauge_array,plot_field)
+    pv_plot.show(cpos="xy")
+
+    # We can also plot time traces for all components of the tensor field.
+    for cc in (norm_comps+dev_comps):
+        pyv.plot_time_traces(straingauge_array,cc)
+
+    plt.show()
+
+
+
+if __name__ == "__main__":
+    main()