pyvale 2025.5.3__cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

pyvale/examples/basics/ex1_5_fielderrs_therm3d.py

@@ -0,0 +1,168 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: Field-based systematic errors
+--------------------------------------------------------------------------------
+In this example we give an overview of field-based systematic errors. Field
+errors require additional interpolation of the underlying physical field such as
+uncertainty in a sensors position or sampling time. For this example we will
+focus on field error sources that perturb sensor locations and sampling times.
+In later examples we will analyse sensor orientation for vector and tensor
+fields.
+
+Note that field errors are more computationally intensive than basic errors as
+they require additional interpolations of the underlying physical field.
+
+Test case: Scalar field point sensors (thermocouples) on a 3D thermal simulation
+"""
+
+from pathlib import Path
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+
+def main() -> None:
+    # First we use everything we learned from the first three examples to build
+    # a thermocouple sensor array for the same 3D thermal simulation we have
+    # analysed in the previous examples. Then we will look at a new type of
+    # systematic error called a field error which requires additional
+    # interpolation of the underlying physical field to be measured.
+    data_path = pyv.DataSet.thermal_3d_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=None)
+
+    n_sens = (1,4,1)
+    x_lims = (12.5,12.5)
+    y_lims = (0.0,33.0)
+    z_lims = (0.0,12.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) # | None
+
+    sensor_data = pyv.SensorData(positions=sens_pos,
+                                 sample_times=sample_times)
+
+    field_key: str = "temperature"
+    tc_array = pyv.SensorArrayFactory \
+        .thermocouples_no_errs(sim_data,
+                               sensor_data,
+                               elem_dims=3,
+                               field_name=field_key)
+
+    # Now we will create a field error data class which we will use to build our
+    # field error. This controls which sensor parameters will be perturbed such
+    # as: position, time and orientation. Here we will perturb the sensor
+    # positions on the face of the block using a normal distribution and we will
+    # also perturb the measurement times.
+
+    # We can apply a constant offset to each sensors position in x,y,z by
+    # providing a shape=(num_sensors,coord[x,y,z]) array. Here we apply a
+    # constant offset in the y and z direction for all sensors.
+    pos_offset_xyz = np.array((0.0,1.0,1.0),dtype=np.float64)
+    pos_offset_xyz = np.tile(pos_offset_xyz,(sens_pos.shape[0],1))
+
+    # We can also apply a constant offset to the sampling times for all sensors
+    time_offset = np.full((sample_times.shape[0],),0.1)
+
+    # Using the `Gen*` random generators in pyvale we can randomly perturb the
+    # position or sampling times of our virtual sensors.
+    pos_rand = pyv.GenNormal(std=1.0) # units = mm
+    time_rand = pyv.GenNormal(std=0.1) # units = s
+
+    # Now we put everything into our field error data class ready to build our
+    # field error object. Have a look at the other parameters in this data class
+    # to geta feel for the other types of supported field errors. We will look
+    # at the orientation and area averaging errors when we look at vector and
+    # tensor fields in later examples.
+    field_err_data = pyv.ErrFieldData(
+        pos_offset_xyz=pos_offset_xyz,
+        time_offset=time_offset,
+        pos_rand_xyz=(None,pos_rand,pos_rand),
+        time_rand=time_rand
+    )
+
+    # Adding our field error to our error chain is exactly the same as the basic
+    # errors we have seen previously. We can also combine field errors with
+    # basic errors and place them anywhere in our error chain. We can even chain
+    # field errors together which we will look at in the next example. For now
+    # we will just have a single field error so we can easily visualise what
+    # this type of error does.
+    err_chain = []
+
+    # A field error needs to know which field it should interpolate for error
+    # calculations so we provide the field from the sensor array as well as the
+    # field error error data class.
+    err_chain.append(pyv.ErrSysField(tc_array.get_field(),
+                                     field_err_data))
+    err_int = pyv.ErrIntegrator(err_chain,
+                                sensor_data,
+                                tc_array.get_measurement_shape())
+    tc_array.set_error_integrator(err_int)
+
+
+    # Now we can run the sensor simulation and display the results to see what
+    # our field error has done.
+    measurements = tc_array.calc_measurements()
+
+    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=tc_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 are going to save some figures to disk as well as displaying them
+    # interactively so we create a directory for this:
+    output_path = Path.cwd() / "pyvale-output"
+    if not output_path.is_dir():
+        output_path.mkdir(parents=True, exist_ok=True)
+
+
+    # If we analyse the time traces we can see offsets in the sensor value and
+    # the sampling times which we expect from our field error setup.
+    (fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+
+    save_traces = output_path/"field_ex1_5_sensortraces.png"
+    fig.savefig(save_traces, dpi=300, bbox_inches="tight")
+    fig.savefig(save_traces.with_suffix(".svg"), dpi=300, bbox_inches="tight")
+
+    plt.show()
+
+    # It is also possible to view the perturbed sensor locations on the
+    # simulation mesh if we create a plot after running the sensor simulation.
+    pv_plot = pyv.plot_point_sensors_on_sim(tc_array,field_key)
+    pv_plot.camera_position = [(59.354, 43.428, 69.946),
+                               (-2.858, 13.189, 4.523),
+                               (-0.215, 0.948, -0.233)]
+
+    save_render = output_path / "fielderrs_ex1_5_sensorlocs.svg"
+    pv_plot.save_graphic(save_render) # only for .svg .eps .ps .pdf .tex
+    pv_plot.screenshot(save_render.with_suffix(".png"))
+
+    pv_plot.show()
+
+    # We have saved an image of the sensor traces and the perturbed locations of
+    # the sensors to the `pyvale-output` directory in your current working
+    # directory. Analyse these figures side by side to show that the location of
+    # the perturbed sensor locations matches the expected sensor traces.
+
+
+if __name__ == '__main__':
+    main()

pyvale/examples/basics/ex1_6_caliberrs_therm2d.py

@@ -0,0 +1,133 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: Sensor calibration systematic errors
+--------------------------------------------------------------------------------
+In this example we show how pyvale can simulate sensor calibration errors with
+user defined calibration functions.
+
+Test case: Scalar field point sensors (thermocouples) on a 2D thermal simulation
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+# First we need to define some calibration functions. These functions must take
+# a numpy array and return a numpy array of the same shape. We start by
+# defining what we think our calibration is called `assumed_calib()` and then
+# we also need to define the ground truth calibration `truth_calib()` so that
+# we can calculate the error between them. The calibration functions shown below
+# are simplified versions of the typical calibration curves for a K-type
+# thermocouple.
+def assumed_calib(signal: np.ndarray) -> np.ndarray:
+    return 24.3*signal + 0.616
+
+
+def truth_calib(signal: np.ndarray) -> np.ndarray:
+    return -0.01897 + 25.41881*signal - 0.42456*signal**2 + 0.04365*signal**3
+
+
+def main() -> None:
+
+    # We are first going to do a quick analytical calculation for the minimum
+    # and maximum systematic error we expect between our assumed and true
+    # calibration. For our true calibration we know this holds between 0 and 6mV
+    # so we perform the calculation over this range and print the min/max
+    # expected error over this range.
+    n_cal_divs = 10000
+    signal_calib_range = np.array((0.0,6.0),dtype=np.float64)
+    milli_volts = np.linspace(signal_calib_range[0],
+                              signal_calib_range[1],
+                              n_cal_divs)
+    temp_truth = truth_calib(milli_volts)
+    temp_assumed = assumed_calib(milli_volts)
+    calib_error = temp_assumed - temp_truth
+
+    print()
+    print(80*"-")
+    print(f"Max calibrated temperature: {np.min(temp_truth)} degC")
+    print(f"Min calibrated temperature: {np.max(temp_truth)} degC")
+    print()
+    print(f"Calibration error over signal:"
+          + f" {signal_calib_range[0]} to {signal_calib_range[1]} mV")
+    print(f"Max calib error: {np.max(calib_error)}")
+    print(f"Min calib error: {np.min(calib_error)}")
+    print(80*"-")
+    print()
+
+
+    # Now let's go back and build the 2D thermal plate with simulated
+    # thermocouples that we analysed in the first two examples. We use this
+    # simulation as the temperatures are within our calibrated range.
+    data_path = pyv.DataSet.thermal_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=None)
+
+    n_sens = (4,1,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,50.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) # | None
+
+    sensor_data = pyv.SensorData(positions=sens_pos,
+                                 sample_times=sample_times)
+
+    field_key: str = "temperature"
+    tc_array = pyv.SensorArrayFactory \
+        .thermocouples_no_errs(sim_data,
+                               sensor_data,
+                               elem_dims=2,
+                               field_name=field_key)
+
+
+    # With our assumed and true calibration functions we can build our
+    # calibration error object and add it to our error chain as normal. Note
+    # that the truth calibration function must be inverted numerically so to
+    # increase accuracy the number of divisions can be increased. However, 1e4
+    # divisions should be suitable for most applications.
+    cal_err = pyv.ErrSysCalibration(assumed_calib,
+                                    truth_calib,
+                                    signal_calib_range,
+                                    n_cal_divs=10000)
+    sys_err_int = pyv.ErrIntegrator([cal_err],
+                                     sensor_data,
+                                     tc_array.get_measurement_shape())
+    tc_array.set_error_integrator(sys_err_int)
+
+    # Now we run our sensor simulation to see what our calibration does.
+    measurements = tc_array.calc_measurements()
+
+    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=tc_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*"-")
+
+    pyv.plot_time_traces(tc_array,field_key)
+    plt.show()
+
+
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/basics/ex1_7_spatavg_therm2d.py

@@ -0,0 +1,123 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: Sensor spatial averaging and averaging errors
+--------------------------------------------------------------------------------
+In this example we show how pyvale can simulate sensor spatial averaging for
+ground truth calculations as well as for calculating systematic errors.
+
+Test case: Scalar field point sensors (thermocouples) on a 2D thermal simulation
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+
+def main() -> None:
+    # First we are going to build a custom sensor array so we can control how
+    # the ground truth is extracted for a sensor using area averaging. Note that
+    # the default is an ideal point sensor with no spatial averaging. Later we
+    # will add area averaging as a systematic error. Note that it is possible to
+    # have an ideal point sensor with no area averaging for the truth and then
+    # add an area averaging error. It is also possible to have a truth that is
+    # area averaged without and area averaging error. The first part of this is
+    # the same as the 3D thermal example we have used previously then we control
+    # the area averaging using the sensor data object.
+    data_path = pyv.DataSet.thermal_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=None)
+
+    descriptor = pyv.SensorDescriptorFactory.temperature_descriptor()
+
+    field_key = "temperature"
+    t_field = pyv.FieldScalar(sim_data,
+                                 field_key=field_key,
+                                 elem_dims=2)
+
+    n_sens = (4,1,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,50.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) # | None
+
+    # This is where we control the setup of the area averaging. We need to
+    # specify the sensor dimensions and the type of numerical spatial
+    # integration to use. Here we specify a square sensor in x and y with 4
+    # point Gaussian quadrature integration. It is worth noting that increasing
+    # the number of integration points will increase computational cost as each
+    # additional integration point requires an additional interpolation of the
+    # physical field.
+    sensor_dims = np.array([20.0,20.0,0]) # units = mm
+    sensor_data = pyv.SensorData(positions=sens_pos,
+                                 sample_times=sample_times,
+                                 spatial_averager=pyv.EIntSpatialType.QUAD4PT,
+                                 spatial_dims=sensor_dims)
+
+    # We have added spatial averaging to our sensor data so we can now create
+    # our sensor array as we have done in previous examples.
+    tc_array = pyv.SensorArrayPoint(sensor_data,
+                                    t_field,
+                                    descriptor)
+
+    # We are also going to create a field error that includes area averaging as
+    # an error. We do this by adding the option to our field error data class
+    # specifying rectangular integration with 1 point.
+    area_avg_err_data = pyv.ErrFieldData(
+        spatial_averager=pyv.EIntSpatialType.RECT1PT,
+        spatial_dims=np.array((5.0,5.0)),
+    )
+
+    # We add the field error to our error chain as normal. We could combine it
+    # with any of our other error models but we will isolate it for now so we
+    # can see what it does.
+    err_chain = []
+    err_chain.append(pyv.ErrSysField(t_field,
+                                     area_avg_err_data))
+    error_int = pyv.ErrIntegrator(err_chain,
+                                  sensor_data,
+                                  tc_array.get_measurement_shape())
+    tc_array.set_error_integrator(error_int)
+
+    # Now we run our sensor simulation to see how spatial averaging changes our
+    measurements = tc_array.calc_measurements()
+
+    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=tc_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*"-")
+
+    pyv.plot_time_traces(tc_array,field_key)
+    plt.show()
+
+    # From here you now have everything you need to build your own sensor
+    # simulations for scalar field sensors using pyvale. In the next examples
+    # we will look at sensors applied to vector (e.g. displacement) and tensor
+    # fields (e.g. strain). If you don't need to sample vector or tensor fields
+    # then skip ahead to the examples on experiment simulation where you will
+    # learn how to perform Monte-Carlo sensor uncertainty quantification
+    # simulations and to analyse the results with pyvale.
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/basics/ex2_1_basicvectors_disp2d.py

@@ -0,0 +1,112 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: Basic vector field (displacement) sensors
+--------------------------------------------------------------------------------
+In this example we use the sensor array factory to build a set of displacement
+sensors that can sample the displacement vector field from a solid mechanics
+simulation. In the next example we will examine how we can build custom vector
+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 displacement sensors on a 2D plate with hole loaded in tension
+"""
+
+
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+def main() -> None:
+    # Here we load a pre-packaged dataset from pyvale that is the output of a
+    # MOOSE simulation in exodus format. The simulation is a linear elastic
+    # rectangular plate with a central hole that is loaded in tension (we will
+    # see a visualisation of the mesh and results later).
+    data_path = pyv.DataSet.mechanical_2d_path()
+    # We use `mooseherder` to load the exodus file into a `SimData` object.
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+
+    # We scale our SI simulation to mm including the displacement fields which
+    # are also in length units. The string keys we have provided here must match
+    # the variable names you have in your SimData object.
+    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)
+
+    # Creating a displacement field point sensor array is similar to what we
+    # have already done for scalar fields we just need to specify the string
+    # keys for the displacement fields in the sim data object we have loaded.
+    # For 2D vector fields we expect to have 2 components which are typically:
+    # ("disp_x","disp_y"). For 3D vector fields we have 3 field components which
+    # are typically: ("disp_x","disp_y","disp_z").
+    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)
+
+    sens_data = pyv.SensorData(positions=sens_pos)
+
+    disp_sens_array = pyv.SensorArrayFactory \
+                        .disp_sensors_basic_errs(sim_data,
+                                                 sens_data,
+                                                 elem_dims=2,
+                                                 field_name=field_name,
+                                                 field_comps=field_comps,
+                                                 errs_pc=2.0)
+
+    # We run our sensor simulation as normal but we note that the second
+    # dimension of our measurement array will have the two vector components in
+    # the order we specified them in the field keys.
+    measurements = disp_sens_array.calc_measurements()
+
+    # Here we print the shape of the measurement array so we can see that the
+    # second dimension contains both our vector components. We also print some
+    # of the sensor measurements for the first vector 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=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*"-")
+
+    # Now that we have multiple field components we can plot each of them on the
+    # simulation mesh and visulise the sensor locations with respect to these
+    # fields.
+    for ff in field_comps:
+        pv_plot = pyv.plot_point_sensors_on_sim(disp_sens_array,ff)
+        pv_plot.show(cpos="xy")
+
+    # We can also plot the traces for each component of the displacement field.
+    for ff in field_comps:
+        pyv.plot_time_traces(disp_sens_array,ff)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/basics/ex2_2_vectorsens_disp2d.py

@@ -0,0 +1,111 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: Custom vector field sensors
+--------------------------------------------------------------------------------
+In this example we build a custom vector field sensor array which mimics the
+sensor array we built with the factory in the previous example.
+
+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:
+
+    # First we load the same 2D solid mechanics simulation we had previously as
+    # a `SimData` object and then we scale everything to millimeters.
+    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)
+
+    # This is the key different between building a vector field sensor vs a
+    # scalar field sensor. Here we create a vector field object which we will
+    # pass to our sensor array. In later examples we will see that the process
+    # is the same for tensor fields (e.g. strain) where we create a tensor field
+    # object and pass this to our sensor array. One thing to note is that the
+    # number of field components will be different here for a 2D vs 3D
+    # simulation. Also, it is worth noting that the element dimensions
+    # parameter does not need to match the number of field components. For
+    # example: it is possible to have a surface mesh (elem_dims=2) where we
+    # have all 3 components of the displacement field.
+    disp_field = pyv.FieldVector(sim_data,field_name,field_comps,elem_dims=2)
+
+    # As we saw previously for scalar fields we define our sensor data object
+    # which determines how many point sensors we have and their sampling times.
+    # For vector field sensors we can also define the sensor orientation here
+    # which we will demonstrate in the next example.
+    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)
+
+    # We set custom sampling times here but we could also set this to None so
+    # that the sensors sample at the simulation time steps.
+    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sens_data = pyv.SensorData(positions=sens_pos,
+                               sample_times=sample_times)
+
+    # We can optionally define a custom sensor descriptor for our vector field
+    # sensor which will be used for labelling sensor placement visualisation or
+    # for time traces. It is also possible to use the sensor descriptor factory
+    # to get the same sensor descriptor object with these defaults.
+    descriptor = pyv.SensorDescriptor(name="Disp.",
+                                      symbol=r"u",
+                                      units=r"mm",
+                                      tag="DS",
+                                      components=("x","y","z"))
+
+    # The point sensor array class is generic and will take any field class
+    # that implements the field interface. So here we just pass in the vector
+    # field to create our vector field sensor array.
+    disp_sens_array = pyv.SensorArrayPoint(sens_data,
+                                           disp_field,
+                                           descriptor)
+
+    # We can add errors to our error simulation chain in exactly the same way as
+    # we did for scalar fields. We will add some simple errors for now but in
+    # the next example we will look at some field errors to do with sensor
+    # orientation that
+    error_chain = []
+    error_chain.append(pyv.ErrSysUnif(low=-0.01,high=0.01))  # units = mm
+    error_chain.append(pyv.ErrRandNorm(std=0.01))            # units = mm
+    error_int = pyv.ErrIntegrator(error_chain,
+                                  sens_data,
+                                  disp_sens_array.get_measurement_shape())
+    disp_sens_array.set_error_integrator(error_int)
+
+    disp_sens_array.calc_measurements()
+
+    # Now that we have multiple field components we can plot each of them on the
+    # simulation mesh and visulise the sensor locations with respect to these
+    # fields.
+    for ff in field_comps:
+        pv_plot = pyv.plot_point_sensors_on_sim(disp_sens_array,ff)
+        pv_plot.show(cpos="xy")
+
+    # We can also plot the traces for each component of the displacement field.
+    for ff in field_comps:
+        pyv.plot_time_traces(disp_sens_array,ff)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()