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

pyvale/examples/basics/{ex1_4_basicerrors_therm3d.py → ex1d_basicerrors_therm3d.py}

@@ -28,32 +28,35 @@ to your error chain.
 
 import numpy as np
 import matplotlib.pyplot as plt
-import mooseherder as mh
-import pyvale as pyv
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
 
 
 #%%
 # 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 example.
-data_path = pyv.DataSet.thermal_3d_path()
+data_path = 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 = sens.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)
+sens_pos = sens.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,
+sensor_data = sens.SensorData(positions=sens_pos,
                             sample_times=sample_times)
 
 field_key: str = "temperature"
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_no_errs(sim_data,
                             sensor_data,
                             elem_dims=3,
@@ -73,61 +76,61 @@ err_chain = []
 #
 # These systematic errors provide a constant offset to all measurements in
 # simulation units or as a percentage.
-err_chain.append(pyv.ErrSysOffset(offset=-10.0))
-err_chain.append(pyv.ErrSysOffsetPercent(offset_percent=-1.0))
+err_chain.append(sens.ErrSysOffset(offset=-10.0))
+err_chain.append(sens.ErrSysOffsetPercent(offset_percent=-1.0))
 
 #%%
 # These systematic errors are sampled from a uniform or normal probability
 # distribution either in simulation units or as a percentage.
-err_chain.append(pyv.ErrSysUnif(low=-1.0,
+err_chain.append(sens.ErrSysUnif(low=-1.0,
                                 high=1.0))
-err_chain.append(pyv.ErrSysUnifPercent(low_percent=-1.0,
+err_chain.append(sens.ErrSysUnifPercent(low_percent=-1.0,
                                         high_percent=1.0))
-err_chain.append(pyv.ErrSysNorm(std=1.0))
-err_chain.append(pyv.ErrSysNormPercent(std_percent=1.0))
+err_chain.append(sens.ErrSysNorm(std=1.0))
+err_chain.append(sens.ErrSysNormPercent(std_percent=1.0))
 
 #%%
 # pyvale includes a series of random number generator objects that wrap the
 # random number generators from numpy. These are named `Gen*` and can be
 # used with an `ErrSysGen` or an `ErrSysGenPercent` object to create custom
 # probability distribution sampling errors:
-sys_gen = pyv.GenTriangular(left=-1.0,
+sys_gen = sens.GenTriangular(left=-1.0,
                             mode=0.0,
                             right=1.0)
-err_chain.append(pyv.ErrSysGen(sys_gen))
+err_chain.append(sens.ErrSysGen(sys_gen))
 
 #%%
 # We can also build the equivalent of `ErrSysUnifPercent` above using a
 # `Gen` object inserted into an `ErrSysGenPercent` object:
-unif_gen = pyv.GenUniform(low=-1.0,
+unif_gen = sens.GenUniform(low=-1.0,
                             high=1.0)
-err_chain.append(pyv.ErrSysGenPercent(unif_gen))
+err_chain.append(sens.ErrSysGenPercent(unif_gen))
 
 #%%
 # We can also add a series of random errors in a similar manner to the
 # systematic errors above noting that these will generate a new error for
 # each sensor and each time step whereas the systematic error sampling
 # provides a constant shift over all sampling times for each sensor.
-err_chain.append(pyv.ErrRandNorm(std = 2.0))
-err_chain.append(pyv.ErrRandNormPercent(std_percent=2.0))
-err_chain.append(pyv.ErrRandUnif(low=-2.0,high=2.0))
-err_chain.append(pyv.ErrRandUnifPercent(low_percent=-2.0,
+err_chain.append(sens.ErrRandNorm(std = 2.0))
+err_chain.append(sens.ErrRandNormPercent(std_percent=2.0))
+err_chain.append(sens.ErrRandUnif(low=-2.0,high=2.0))
+err_chain.append(sens.ErrRandUnifPercent(low_percent=-2.0,
                                         high_percent=2.0))
-rand_gen = pyv.GenTriangular(left=-5.0,
+rand_gen = sens.GenTriangular(left=-5.0,
                                 mode=0.0,
                                 right=5.0)
-err_chain.append(pyv.ErrRandGenerator(rand_gen))
+err_chain.append(sens.ErrRandGen(rand_gen))
 
 #%%
 # Finally we add some dependent systematic errors including rounding errors,
 # digitisation and saturation. Note that the saturation error must be placed
 # last in the error chain. Try changing some of these values to see how the
 # sensor traces change - particularly the saturation error.
-err_chain.append(pyv.ErrSysRoundOff(pyv.ERoundMethod.ROUND,0.1))
-err_chain.append(pyv.ErrSysDigitisation(bits_per_unit=2**16/100))
-err_chain.append(pyv.ErrSysSaturation(meas_min=0.0,meas_max=400.0))
+err_chain.append(sens.ErrSysRoundOff(sens.ERoundMethod.ROUND,0.1))
+err_chain.append(sens.ErrSysDigitisation(bits_per_unit=2**16/100))
+err_chain.append(sens.ErrSysSaturation(meas_min=0.0,meas_max=400.0))
 
-err_int = pyv.ErrIntegrator(err_chain,
+err_int = sens.ErrIntegrator(err_chain,
                             sensor_data,
                             tc_array.get_measurement_shape())
 tc_array.set_error_integrator(err_int)
@@ -148,10 +151,10 @@ 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)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
 print(80*"-")
 
-pyv.plot_time_traces(tc_array,field_key)
+sens.plot_time_traces(tc_array,field_key)
 plt.show()
 

pyvale/examples/basics/{ex1_5_fielderrs_therm3d.py → ex1e_fielderrs_therm3d.py}

@@ -24,8 +24,12 @@ 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
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
+
 
 #%%
 # First we use everything we learned from the first three examples to build
@@ -33,9 +37,9 @@ import pyvale as pyv
 # 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()
+data_path = 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 = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=None)
 
@@ -43,15 +47,15 @@ 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)
+sens_pos = sens.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,
+sensor_data = sens.SensorData(positions=sens_pos,
                                 sample_times=sample_times)
 
 field_key: str = "temperature"
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_no_errs(sim_data,
                             sensor_data,
                             elem_dims=3,
@@ -76,8 +80,8 @@ 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
+pos_rand = sens.GenNormal(std=1.0) # units = mm
+time_rand = sens.GenNormal(std=0.1) # units = s
 
 #%%
 # Now we put everything into our field error data class ready to build our
@@ -85,7 +89,7 @@ time_rand = pyv.GenNormal(std=0.1) # units = s
 # 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(
+field_err_data = sens.ErrFieldData(
     pos_offset_xyz=pos_offset_xyz,
     time_offset=time_offset,
     pos_rand_xyz=(None,pos_rand,pos_rand),
@@ -105,9 +109,9 @@ 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(),
+err_chain.append(sens.ErrSysField(tc_array.get_field(),
                                     field_err_data))
-err_int = pyv.ErrIntegrator(err_chain,
+err_int = sens.ErrIntegrator(err_chain,
                             sensor_data,
                             tc_array.get_measurement_shape())
 tc_array.set_error_integrator(err_int)
@@ -128,7 +132,7 @@ 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)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
 print(80*"-")
 
@@ -142,7 +146,7 @@ if not output_path.is_dir():
 #%%
 # 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)
+(fig,ax) = sens.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")
@@ -153,7 +157,7 @@ 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 = sens.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)]

pyvale/examples/basics/{ex1_6_caliberrs_therm2d.py → ex1f_caliberrs_therm2d.py}

@@ -16,8 +16,12 @@ 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
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
+
 
 #%%
 # First we need to define some calibration functions. These functions must take
@@ -27,11 +31,11 @@ import pyvale as pyv
 # 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:
+def calib_assumed(signal: np.ndarray) -> np.ndarray:
     return 24.3*signal + 0.616
 
 
-def truth_calib(signal: np.ndarray) -> np.ndarray:
+def calib_truth(signal: np.ndarray) -> np.ndarray:
     return -0.01897 + 25.41881*signal - 0.42456*signal**2 + 0.04365*signal**3
 
 
@@ -46,8 +50,8 @@ 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)
+temp_truth = calib_truth(milli_volts)
+temp_assumed = calib_assumed(milli_volts)
 calib_error = temp_assumed - temp_truth
 
 print()
@@ -66,9 +70,9 @@ 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()
+data_path = 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 = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=None)
 
@@ -76,15 +80,15 @@ 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)
+sens_pos = sens.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,
+sensor_data = sens.SensorData(positions=sens_pos,
                                 sample_times=sample_times)
 
 field_key: str = "temperature"
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_no_errs(sim_data,
                             sensor_data,
                             elem_dims=2,
@@ -96,11 +100,11 @@ tc_array = pyv.SensorArrayFactory \
 # 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,
+cal_err = sens.ErrSysCalibration(calib_assumed,
+                                calib_truth,
                                 signal_calib_range,
                                 n_cal_divs=10000)
-sys_err_int = pyv.ErrIntegrator([cal_err],
+sys_err_int = sens.ErrIntegrator([cal_err],
                                     sensor_data,
                                     tc_array.get_measurement_shape())
 tc_array.set_error_integrator(sys_err_int)
@@ -119,10 +123,10 @@ 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)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
 print(80*"-")
 
-pyv.plot_time_traces(tc_array,field_key)
+sens.plot_time_traces(tc_array,field_key)
 plt.show()
 

pyvale/examples/basics/{ex1_7_spatavg_therm2d.py → ex1g_spatavg_therm2d.py}

@@ -16,8 +16,11 @@ 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
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
 
 #%%
 # First we are going to build a custom sensor array so we can control how
@@ -29,16 +32,16 @@ import pyvale as pyv
 # 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()
+data_path = 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 = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=None)
 
-descriptor = pyv.SensorDescriptorFactory.temperature_descriptor()
+descriptor = sens.SensorDescriptorFactory.temperature_descriptor()
 
 field_key = "temperature"
-t_field = pyv.FieldScalar(sim_data,
+t_field = sens.FieldScalar(sim_data,
                                 field_key=field_key,
                                 elem_dims=2)
 
@@ -46,7 +49,7 @@ 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)
+sens_pos = sens.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
 
@@ -59,15 +62,15 @@ sample_times = np.linspace(0.0,np.max(sim_data.time),50) # | None
 # 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,
+sensor_data = sens.SensorData(positions=sens_pos,
                                 sample_times=sample_times,
-                                spatial_averager=pyv.EIntSpatialType.QUAD4PT,
+                                spatial_averager=sens.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,
+tc_array = sens.SensorArrayPoint(sensor_data,
                                 t_field,
                                 descriptor)
 
@@ -75,8 +78,8 @@ tc_array = pyv.SensorArrayPoint(sensor_data,
 # 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,
+area_avg_err_data = sens.ErrFieldData(
+    spatial_averager=sens.EIntSpatialType.RECT1PT,
     spatial_dims=np.array((5.0,5.0)),
 )
 
@@ -85,9 +88,9 @@ area_avg_err_data = pyv.ErrFieldData(
 # 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,
+err_chain.append(sens.ErrSysField(t_field,
                                     area_avg_err_data))
-error_int = pyv.ErrIntegrator(err_chain,
+error_int = sens.ErrIntegrator(err_chain,
                                 sensor_data,
                                 tc_array.get_measurement_shape())
 tc_array.set_error_integrator(error_int)
@@ -107,11 +110,11 @@ 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)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
 print(80*"-")
 
-pyv.plot_time_traces(tc_array,field_key)
+sens.plot_time_traces(tc_array,field_key)
 plt.show()
 
 #%%

pyvale/examples/basics/{ex2_1_basicvectors_disp2d.py → ex2a_basicvectors_disp2d.py}

@@ -20,8 +20,11 @@ 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
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
 
 #%%
 # Here we load a pre-packaged dataset from pyvale that is the output of a
@@ -29,7 +32,7 @@ import pyvale as pyv
 # 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()
+data_path = dataset.mechanical_2d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 #%%
@@ -38,7 +41,7 @@ sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 # 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 = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=field_comps)
 
@@ -53,11 +56,11 @@ 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_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
-sens_data = pyv.SensorData(positions=sens_pos)
+sens_data = sens.SensorData(positions=sens_pos)
 
-disp_sens_array = pyv.SensorArrayFactory \
+disp_sens_array = sens.SensorArrayFactory \
                     .disp_sensors_basic_errs(sim_data,
                                                 sens_data,
                                                 elem_dims=2,
@@ -92,7 +95,7 @@ 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)
+sens.print_measurements(disp_sens_array,sens_print,comp_print,time_print)
 
 print(80*"-")
 
@@ -101,13 +104,13 @@ print(80*"-")
 # 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 = sens.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)
+    sens.plot_time_traces(disp_sens_array,ff)
 
 plt.show()
 

pyvale/examples/basics/{ex2_2_vectorsens_disp2d.py → ex2b_vectorsens_disp2d.py}

@@ -19,18 +19,22 @@ 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
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
+
 
 
 #%%
 # 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()
+data_path = 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 = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=field_comps)
 
@@ -45,25 +49,25 @@ sim_data = pyv.scale_length_units(scale=1000.0,
 # 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)
+disp_field = sens.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)
+n_sens = (1,4,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_pos = sens.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,
+sens_data = sens.SensorData(positions=sens_pos,
                             sample_times=sample_times)
 
 #%%
@@ -71,7 +75,7 @@ sens_data = pyv.SensorData(positions=sens_pos,
 # 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.",
+descriptor = sens.SensorDescriptor(name="Disp.",
                                     symbol=r"u",
                                     units=r"mm",
                                     tag="DS",
@@ -81,7 +85,7 @@ descriptor = pyv.SensorDescriptor(name="Disp.",
 # 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_sens_array = sens.SensorArrayPoint(sens_data,
                                         disp_field,
                                         descriptor)
 
@@ -91,9 +95,9 @@ disp_sens_array = pyv.SensorArrayPoint(sens_data,
 # 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,
+error_chain.append(sens.ErrSysUnif(low=-0.01,high=0.01))  # units = mm
+error_chain.append(sens.ErrRandNorm(std=0.01))            # units = mm
+error_int = sens.ErrIntegrator(error_chain,
                                 sens_data,
                                 disp_sens_array.get_measurement_shape())
 disp_sens_array.set_error_integrator(error_int)
@@ -105,13 +109,13 @@ disp_sens_array.calc_measurements()
 # 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 = sens.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)
+    sens.plot_time_traces(disp_sens_array,ff)
 
 plt.show()