pyvale 2025.7.2__cp311-cp311-musllinux_1_2_i686.whl → 2025.8.1__cp311-cp311-musllinux_1_2_i686.whl

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()
 

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()