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

pyvale/examples/basics/{ex2_3_sensangle_disp2d.py → ex2c_sensangle_disp2d.py}

@@ -23,39 +23,42 @@ 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
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
 
 #%%
 # 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()
+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)
 
-descriptor = pyv.SensorDescriptorFactory.displacement_descriptor()
+descriptor = sens.SensorDescriptorFactory.displacement_descriptor()
 
-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)
 
 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)
 
 
 sample_times = np.linspace(0.0,np.max(sim_data.time),50)
 
-sens_data_norot = pyv.SensorData(positions=sens_pos,
+sens_data_norot = sens.SensorData(positions=sens_pos,
                                     sample_times=sample_times)
 
-disp_sens_norot = pyv.SensorArrayPoint(sens_data_norot,
+disp_sens_norot = sens.SensorArrayPoint(sens_data_norot,
                                         disp_field,
                                         descriptor)
 
@@ -78,11 +81,11 @@ sens_angles = sens_pos.shape[0] * \
 sens_angles = (Rotation.from_euler("zyx", [45, 0, 0], degrees=True),)
 
 
-sens_data_rot = pyv.SensorData(positions=sens_pos,
+sens_data_rot = sens.SensorData(positions=sens_pos,
                                 sample_times=sample_times,
                                 angles=sens_angles)
 
-disp_sens_rot = pyv.SensorArrayPoint(sens_data_rot,
+disp_sens_rot = sens.SensorArrayPoint(sens_data_rot,
                                         disp_field,
                                         descriptor)
 
@@ -93,13 +96,13 @@ disp_sens_rot = pyv.SensorArrayPoint(sens_data_rot,
 # 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,
+angle_rand = (sens.GenNormal(std=2.0),None,None)
+angle_error_data = sens.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],
+sys_err_rot = sens.ErrSysField(disp_field,angle_error_data)
+sys_err_int = sens.ErrIntegrator([sys_err_rot],
                                 sens_data_rot,
                                 disp_sens_rot.get_measurement_shape())
 disp_sens_rot.set_error_integrator(sys_err_int)
@@ -121,7 +124,7 @@ print("ROTATED SENSORS WITH ANGLE ERRORS:")
 print(f"These are the last {time_last} virtual measurements of sensor "
         + f"{sens_print} for {field_comps[comp_print]}:")
 
-pyv.print_measurements(disp_sens_rot,sens_print,comp_print,time_print)
+sens.print_measurements(disp_sens_rot,sens_print,comp_print,time_print)
 
 print(80*"-")
 
@@ -129,9 +132,9 @@ 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) = sens.plot_time_traces(disp_sens_norot,ff)
     ax.set_title("No Rotation")
-    (_,ax) = pyv.plot_time_traces(disp_sens_rot,ff)
+    (_,ax) = sens.plot_time_traces(disp_sens_rot,ff)
     ax.set_title("Rotated with Errors")
 
 plt.show()

pyvale/examples/basics/{ex2_4_chainfielderrs_disp2d.py → ex2d_chainfielderrs_disp2d.py}

@@ -24,36 +24,39 @@ 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
 
 #%%
 # 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()
+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)
 
-descriptor = pyv.SensorDescriptorFactory.displacement_descriptor()
+descriptor = sens.SensorDescriptorFactory.displacement_descriptor()
 
-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)
 
 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)
+sensor_positions = 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)
 
-sensor_data = pyv.SensorData(positions=sensor_positions,
+sensor_data = sens.SensorData(positions=sensor_positions,
                                 sample_times=sample_times)
 
-disp_sens_array = pyv.SensorArrayPoint(sensor_data,
+disp_sens_array = sens.SensorArrayPoint(sensor_data,
                                         disp_field,
                                         descriptor)
 
@@ -66,16 +69,16 @@ disp_sens_array = pyv.SensorArrayPoint(sensor_data,
 # 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)
+pos_error_data = sens.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)
+angle_error_data = sens.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)
+time_error_data = sens.ErrFieldData(time_offset=time_offset)
 
 #%%
 # Now we add all our field errors to our error chain. We add each error
@@ -83,26 +86,25 @@ time_error_data = pyv.ErrFieldData(time_offset=time_offset)
 # 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,
+err_chain.append(sens.ErrSysField(disp_field,
                                     time_error_data,
-                                    pyv.EErrDep.DEPENDENT))
-err_chain.append(pyv.ErrSysField(disp_field,
+                                    sens.EErrDep.DEPENDENT))
+err_chain.append(sens.ErrSysField(disp_field,
                                     time_error_data,
-                                    pyv.EErrDep.DEPENDENT))
+                                    sens.EErrDep.DEPENDENT))
 
-err_chain.append(pyv.ErrSysField(disp_field,
+err_chain.append(sens.ErrSysField(disp_field,
                                     pos_error_data,
-                                    pyv.EErrDep.DEPENDENT))
-err_chain.append(pyv.ErrSysField(disp_field,
+                                    sens.EErrDep.DEPENDENT))
+err_chain.append(sens.ErrSysField(disp_field,
                                     pos_error_data,
-                                    pyv.EErrDep.DEPENDENT))
-
-err_chain.append(pyv.ErrSysField(disp_field,
+                                    sens.EErrDep.DEPENDENT))
+err_chain.append(sens.ErrSysField(disp_field,
                                     angle_error_data,
-                                    pyv.EErrDep.DEPENDENT))
-err_chain.append(pyv.ErrSysField(disp_field,
+                                    sens.EErrDep.DEPENDENT))
+err_chain.append(sens.ErrSysField(disp_field,
                                     angle_error_data,
-                                    pyv.EErrDep.DEPENDENT))
+                                    sens.EErrDep.DEPENDENT))
 
 #%%
 # Instead of setting the dependence for each individual error above we could
@@ -113,13 +115,13 @@ err_chain.append(pyv.ErrSysField(disp_field,
 # 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,
+err_int_opts = sens.ErrIntOpts(force_dependence=sens.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,
+error_int = sens.ErrIntegrator(err_chain,
                                 sensor_data,
                                 disp_sens_array.get_measurement_shape(),
                                 err_int_opts)
@@ -185,13 +187,13 @@ print("ROTATED SENSORS WITH ANGLE ERRORS:")
 print(f"These are the last {time_last} virtual measurements of sensor "
         + f"{sens_print} for {field_comps[comp_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*"-")
 
 #%%
 # Finally, we plot the time traces for all field components.
 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_5_vectorfields3d_disp3d.py → ex2e_vectorfields3d_disp3d.py}

@@ -21,15 +21,18 @@ 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
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
 
 
 #%%
 # First 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)
+data_path = dataset.element_case_output_path(dataset.EElemTest.HEX20)
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 #%%
@@ -37,40 +40,40 @@ sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 # 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 = sens.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)
+# `SimTools` object to help us locate our sensors on the cube.
+sens.SimTools.print_dimensions(sim_data)
 
-descriptor = pyv.SensorDescriptorFactory.displacement_descriptor()
+descriptor = sens.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)
+disp_field = sens.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),))
+                             (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,
+sensor_data = sens.SensorData(positions=sensor_positions,
                                 sample_times=sample_times)
 
-disp_sens_array = pyv.SensorArrayPoint(sensor_data,
+disp_sens_array = sens.SensorArrayPoint(sensor_data,
                                         disp_field,
                                         descriptor)
 
@@ -79,7 +82,7 @@ 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 = sens.plot_point_sensors_on_sim(disp_sens_array,"disp_y")
 pv_plot.show()
 
 #%%
@@ -96,7 +99,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} for {field_comps[comp_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*"-")
 
@@ -106,6 +109,6 @@ print(80*"-")
 # 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)
+    sens.plot_time_traces(disp_sens_array,ff)
 
 plt.show()

pyvale/examples/basics/{ex3_1_basictensors_strain2d.py → ex3a_basictensors_strain2d.py}

@@ -22,9 +22,11 @@ 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
+
+# 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 used previously
@@ -32,21 +34,21 @@ import pyvale as pyv
 # 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"))
+data_path: Path = dataset.mechanical_2d_path()
+sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+sim_data = sens.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)
+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)
 
-sens_data = pyv.SensorData(positions=sens_pos,
+sens_data = sens.SensorData(positions=sens_pos,
                             sample_times=sample_times)
 
 #%%
@@ -57,7 +59,7 @@ sens_data = pyv.SensorData(positions=sens_pos,
 # have seen previously for scalar and vector fields.
 norm_comps = ("strain_xx","strain_yy")
 dev_comps = ("strain_xy",)
-straingauge_array = pyv.SensorArrayFactory \
+straingauge_array = sens.SensorArrayFactory \
                         .strain_gauges_basic_errs(sim_data,
                                                     sens_data,
                                                     elem_dims=2,
@@ -95,7 +97,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(straingauge_array,sens_print,comp_print,time_print)
+sens.print_measurements(straingauge_array,sens_print,comp_print,time_print)
 
 print(80*"-")
 
@@ -103,12 +105,12 @@ 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 = sens.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)
+    sens.plot_time_traces(straingauge_array,cc)
 
 plt.show()

pyvale/examples/basics/{ex3_2_tensorsens2d_strain2d.py → ex3b_tensorsens2d_strain2d.py}

@@ -19,17 +19,20 @@ 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
+
+# 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 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()
+data_path = 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 = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=("disp_x","disp_y"))
 
@@ -41,7 +44,7 @@ sim_data = pyv.scale_length_units(scale=1000.0,
 field_name = "strain"
 norm_comps = ("strain_xx","strain_yy")
 dev_comps = ("strain_xy",)
-strain_field = pyv.FieldTensor(sim_data,
+strain_field = sens.FieldTensor(sim_data,
                                 field_name=field_name,
                                 norm_comps=norm_comps,
                                 dev_comps=dev_comps,
@@ -55,11 +58,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)
 
 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)
 
 #%%
@@ -67,7 +70,7 @@ sens_data = pyv.SensorData(positions=sens_pos,
 # 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",
+descriptor = sens.SensorDescriptor(name="Strain",
                                     symbol=r"\varepsilon",
                                     units=r"-",
                                     tag="SG",
@@ -75,7 +78,7 @@ descriptor = pyv.SensorDescriptor(name="Strain",
 
 #%%
 # We build our point sensor array as normal.
-straingauge_array = pyv.SensorArrayPoint(sens_data,
+straingauge_array = sens.SensorArrayPoint(sens_data,
                                             strain_field,
                                             descriptor)
 
@@ -83,9 +86,9 @@ straingauge_array = pyv.SensorArrayPoint(sens_data,
 # 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,
+error_chain.append(sens.ErrSysUnifPercent(low_percent=-2.0,high_percent=2.0))
+error_chain.append(sens.ErrRandNormPercent(std_percent=2.0))
+error_int = sens.ErrIntegrator(error_chain,
                                 sens_data,
                                 straingauge_array.get_measurement_shape())
 straingauge_array.set_error_integrator(error_int)
@@ -102,12 +105,12 @@ 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 = sens.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)
+    sens.plot_time_traces(straingauge_array,cc)
 
 plt.show()

pyvale/examples/basics/{ex3_3_tensorsens3d_strain3d.py → ex3c_tensorsens3d_strain3d.py}

@@ -21,14 +21,17 @@ Test case: point strain 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
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
 
 #%%
 # First we load our simulation asa `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)
+data_path = dataset.element_case_output_path(dataset.EElemTest.HEX20)
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 #%%
@@ -36,7 +39,7 @@ sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 # displacement field component here for scaling. Note that you don't need to
 # scale the displacements here if you only want to analyse strains.
 disp_comps = ("disp_x","disp_y","disp_z")
-sim_data = pyv.scale_length_units(scale=1000.0,
+sim_data = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=disp_comps)
 
@@ -48,7 +51,7 @@ sim_data = pyv.scale_length_units(scale=1000.0,
 field_name = "strain"
 norm_comps = ("strain_xx","strain_yy","strain_zz")
 dev_comps = ("strain_xy","strain_yz","strain_xz")
-strain_field = pyv.FieldTensor(sim_data,
+strain_field = sens.FieldTensor(sim_data,
                                 field_name=field_name,
                                 norm_comps=norm_comps,
                                 dev_comps=dev_comps,
@@ -80,7 +83,7 @@ sens_angles = (Rotation.from_euler("zyx", [0, 0, 0], degrees=True),
                 Rotation.from_euler("zyx", [0, 0, 45], degrees=True),)
 
 
-sens_data = pyv.SensorData(positions=sensor_positions,
+sens_data = sens.SensorData(positions=sensor_positions,
                             sample_times=sample_times,
                             angles=sens_angles)
 
@@ -89,14 +92,14 @@ sens_data = pyv.SensorData(positions=sensor_positions,
 # 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",
+descriptor = sens.SensorDescriptor(name="Strain",
                                     symbol=r"\varepsilon",
                                     units=r"-",
                                     tag="SG",
                                     components=('xx','yy','zz','xy','yz','xz'))
 
 
-straingauge_array = pyv.SensorArrayPoint(sens_data,
+straingauge_array = sens.SensorArrayPoint(sens_data,
                                             strain_field,
                                             descriptor)
 
@@ -104,22 +107,22 @@ straingauge_array = pyv.SensorArrayPoint(sens_data,
 # We can add any errors we like to our error chain. Here we add some basic
 # percentage errors.
 error_chain = []
-error_chain.append(pyv.ErrSysUnif(low=-0.1e-3,high=0.1e-3))
-error_chain.append(pyv.ErrRandNormPercent(std_percent=1.0))
+error_chain.append(sens.ErrSysUnif(low=-0.1e-3,high=0.1e-3))
+error_chain.append(sens.ErrRandNormPercent(std_percent=1.0))
 
 #%%
 # Now we add a field error to perturb the positions of each sensor on its
 # relevant face and then add a +/- 2deg angle error.
 
 pos_uncert = 0.1 # units = mm
-pos_rand_xyz = (pyv.GenNormal(std=pos_uncert),
-                pyv.GenNormal(std=pos_uncert),
-                pyv.GenNormal(std=pos_uncert))
+pos_rand_xyz = (sens.GenNormal(std=pos_uncert),
+                sens.GenNormal(std=pos_uncert),
+                sens.GenNormal(std=pos_uncert))
 
 angle_uncert = 2.0
-angle_rand_zyx = (pyv.GenUniform(low=-angle_uncert,high=angle_uncert), # units = deg
-                    pyv.GenUniform(low=-angle_uncert,high=angle_uncert),
-                    pyv.GenUniform(low=-angle_uncert,high=angle_uncert))
+angle_rand_zyx = (sens.GenUniform(low=-angle_uncert,high=angle_uncert), # units = deg
+                    sens.GenUniform(low=-angle_uncert,high=angle_uncert),
+                    sens.GenUniform(low=-angle_uncert,high=angle_uncert))
 
 #%%
 # We are going to lock position perturbation so that the sensors stay on the
@@ -137,15 +140,15 @@ angle_lock[0:2,1] = False   # Allow rotation about y
 angle_lock[2:4,0] = False   # Allow rotation about z
 angle_lock[4:6,2] = False   # Allow rotation about x
 
-field_error_data = pyv.ErrFieldData(pos_rand_xyz=pos_rand_xyz,
+field_error_data = sens.ErrFieldData(pos_rand_xyz=pos_rand_xyz,
                                     pos_lock_xyz=pos_lock,
                                     ang_rand_zyx=angle_rand_zyx,
                                     ang_lock_zyx=angle_lock)
-sys_err_field = pyv.ErrSysField(strain_field,field_error_data)
+sys_err_field = sens.ErrSysField(strain_field,field_error_data)
 error_chain.append(sys_err_field)
 
 
-error_int = pyv.ErrIntegrator(error_chain,
+error_int = sens.ErrIntegrator(error_chain,
                                 sens_data,
                                 straingauge_array.get_measurement_shape())
 straingauge_array.set_error_integrator(error_int)
@@ -175,7 +178,7 @@ print("ROTATED SENSORS WITH ANGLE ERRORS:")
 print(f"These are the last {time_last} virtual measurements of sensor "
         + f"{sens_print} for {norm_comps[comp_print]}:")
 
-pyv.print_measurements(straingauge_array,sens_print,comp_print,time_print)
+sens.print_measurements(straingauge_array,sens_print,comp_print,time_print)
 
 print(80*"-")
 
@@ -183,12 +186,12 @@ 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 = sens.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)
+    sens.plot_time_traces(straingauge_array,cc)
 
 plt.show()