pyvale 2025.5.3__cp311-cp311-musllinux_1_2_aarch64.whl → 2025.7.0__cp311-cp311-musllinux_1_2_aarch64.whl

pyvale/examples/basics/ex1_7_spatavg_therm2d.py

@@ -5,9 +5,10 @@
 # ==============================================================================
 
 """
-Pyvale example: Sensor spatial averaging and averaging errors
---------------------------------------------------------------------------------
-In this example we show how pyvale can simulate sensor spatial averaging for
+Basics: 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
@@ -18,106 +19,109 @@ import matplotlib.pyplot as plt
 import mooseherder as mh
 import pyvale as pyv
 
+#%%
+# 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 = 0
+comp_print = 0
+time_last = 5
+time_print = slice(measurements.shape[2]-time_last,measurements.shape[2])
+
+
+print(f"These are the last {time_last} virtual measurements of sensor "
+        + f"{sens_print}:")
+
+pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+
+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.
+
+
 
-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

@@ -5,108 +5,109 @@
 # ==============================================================================
 
 """
-Pyvale example: Basic vector field (displacement) sensors
---------------------------------------------------------------------------------
+Basics: 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
+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()
+#%%
+# 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). We use `mooseherder` to
+# load the exodus file into a `SimData` object.
+data_path = pyv.DataSet.mechanical_2d_path()
+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 = 0
+comp_print = 0
+time_last = 5
+time_print = slice(measurements.shape[2]-time_last,measurements.shape[2])
+
+print(f"These are the last {time_last} virtual measurements of sensor "
+        + f"{sens_print}:")
+
+pyv.print_measurements(disp_sens_array,sens_print,comp_print,time_print)
+
+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()
+

pyvale/examples/basics/ex2_2_vectorsens_disp2d.py

@@ -5,8 +5,9 @@
 # ==============================================================================
 
 """
-Pyvale example: Custom vector field sensors
---------------------------------------------------------------------------------
+Basics: 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.
 
@@ -21,91 +22,96 @@ 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()
+
+#%%
+# 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()
+