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

pyvale/examples/basics/{ex1_1_basicscalars_therm2d.py → ex1a_basicscalars_therm2d.py}

@@ -18,8 +18,11 @@ Test case: Scalar field point sensors (thermocouples) on a 2D thermal simulation
 
 from pathlib import Path
 import matplotlib.pyplot as plt
-import mooseherder as mh
-import pyvale as pyv
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
+import pyvale.dataset as dataset
 
 #%%
 # Here we load a pre-generated MOOSE finite element simulation dataset that
@@ -28,13 +31,13 @@ import pyvale as pyv
 # to your own MOOSE simulation with exodus output (*.e). Note that the
 # field_key must match the name of your variable in your MOOSE simulation.
 # We use `mooseherder` to load the exodus file into a `SimData` object.
-data_path = pyv.DataSet.thermal_2d_path()
+data_path = dataset.thermal_2d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 #%%
 # Scale to mm to make 3D visualisation scaling easier as pyvista scales
 # everything to unity
-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)
 
@@ -46,14 +49,14 @@ n_sens = (3,2,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)
 
 #%%
 # This dataclass contains the parameters to build our sensor array. We can
 # also customise the output frequency, the sensor area and the sensor
 # orientation. For now we will use the defaults which assumes an ideal point
 # sensor sampling at the simulation time steps.
-sens_data = pyv.SensorData(positions=sens_pos)
+sens_data = sens.SensorData(positions=sens_pos)
 
 #%%
 # Now that we have our sensor locations we can use the sensor factory to
@@ -63,7 +66,7 @@ sens_data = pyv.SensorData(positions=sens_pos)
 # If you want to remove the simulated errors and just interpolate at the
 # sensor locations then user `.thermocouples_no_errs()`.
 field_key: str = "temperature"
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_basic_errs(sim_data,
                                 sens_data,
                                 elem_dims=2,
@@ -93,7 +96,7 @@ if not output_path.is_dir():
 # This creates a pyvista visualisation of the sensor locations on the
 # simulation mesh. The plot will can be shown in interactive mode by calling
 # `pv_plot.show()`.
-pv_plot = pyv.plot_point_sensors_on_sim(tc_array,field_key)
+pv_plot = sens.plot_point_sensors_on_sim(tc_array,field_key)
 
 #%%
 # We determined manually by moving camera in interative mode and then
@@ -125,7 +128,7 @@ print(80*"-"+"\n")
 # markers shows the simulated sensor traces. In later examples we will see
 # how to configure this plot but for now we note we that we are returned a
 # matplotlib figure and axes object which allows for further customisation.
-(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+(fig,ax) = sens.plot_time_traces(tc_array,field_key)
 
 #%%
 # We can also save the sensor trace plot as a vector and raster graphic

pyvale/examples/basics/{ex1_2_sensormodel_therm2d.py → ex1b_sensormodel_therm2d.py}

@@ -29,8 +29,11 @@ Test case: Scalar field point sensors (thermocouples) on a 2D thermal simulation
 """
 
 import matplotlib.pyplot as plt
-import mooseherder as mh
-import pyvale as pyv
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
+import pyvale.dataset as dataset
 
 
 #%%
@@ -40,14 +43,14 @@ import pyvale as pyv
 # Here we load a pre-generated MOOSE finite element simulation dataset that
 # comes packaged with pyvale. The simulation is a 2D rectangular plate with
 # a bi-directional temperature gradient.
-data_path = pyv.DataSet.thermal_2d_path()
+data_path = dataset.thermal_2d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 field_key: str = "temperature"
 
 #%%
 # Scale to mm to make 3D visualisation scaling easier as pyvista scales
 # everything to unity
-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)
 
@@ -59,14 +62,14 @@ 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)
 
 #%%
 # This dataclass contains the parameters to build our sensor array. We can
 # also customise the output frequency, the sensor area and the sensor
 # orientation. For now we will use the defaults which assumes an ideal point
 # sensor sampling at the simulation time steps.
-sens_data = pyv.SensorData(positions=sens_pos)
+sens_data = sens.SensorData(positions=sens_pos)
 
 #%%
 # Now that we have our sensor locations we can use the sensor factory to
@@ -74,7 +77,7 @@ sens_data = pyv.SensorData(positions=sens_pos)
 # examples we will see how to customise sensor parameters and errors.
 # This basic thermocouple array includes a 5% systematic and random error -
 # We are specifically using exaggerated errors here for visualisation.
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_basic_errs(sim_data,
                                 sens_data,
                                 elem_dims=2,
@@ -111,16 +114,16 @@ print(80*"-")
 print(f"Looking at the last {time_last} virtual measurements for 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*"-")
 print("If we call the `calc_measurements()` method then the errors are "
         + "re-calculated.")
 measurements = tc_array.calc_measurements()
 
-pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
-(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+(fig,ax) = sens.plot_time_traces(tc_array,field_key)
 ax.set_title("Exp 1: called calc_measurements()")
 
 print(80*"-")
@@ -128,9 +131,9 @@ print("If we call the `get_measurements()` method then the errors are the "
         + "same:")
 measurements = tc_array.get_measurements()
 
-pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
-(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+(fig,ax) = sens.plot_time_traces(tc_array,field_key)
 ax.set_title("Exp 2: called get_measurements()")
 
 print(80*"-")
@@ -138,9 +141,9 @@ print("If we call the `calc_measurements()` method again we generate / "
         "sample new errors:")
 measurements = tc_array.calc_measurements()
 
-pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
-(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+(fig,ax) = sens.plot_time_traces(tc_array,field_key)
 ax.set_title("Exp 3: called calc_measurements()")
 
 print(80*"-")

pyvale/examples/basics/{ex1_3_customsens_therm3d.py → ex1c_customsens_therm3d.py}

@@ -18,8 +18,11 @@ 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
 
 #%%
 # To build our custom point sensor array we need to at minimum provide a
@@ -32,9 +35,9 @@ import pyvale as pyv
 # based on the same thermal example we have used in the last two examples so
 # we start by loading our simulation data:
 
-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,7 +46,7 @@ sim_data = pyv.scale_length_units(scale=1000.0,
 # field object to perform interpolation to the sensor locations at the
 # desired sampling times.
 field_key: str = "temperature"
-t_field = pyv.FieldScalar(sim_data,
+t_field = sens.FieldScalar(sim_data,
                             field_key=field_key,
                             elem_dims=3)
 
@@ -56,7 +59,7 @@ 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)
 
 #%%
 # We are also going to specify the times at which we would like to simulate
@@ -64,8 +67,8 @@ sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 # to match the simulation time steps.
 sample_times = np.linspace(0.0,np.max(sim_data.time),50)
 
-sensor_data = pyv.SensorData(positions=sens_pos,
-                                sample_times=sample_times)
+sensor_data = sens.SensorData(positions=sens_pos,
+                             sample_times=sample_times)
 
 #%%
 # Finally, we can create a `SensorDescriptor` which will be used to label
@@ -73,20 +76,20 @@ sensor_data = pyv.SensorData(positions=sens_pos,
 # examples.
 use_auto_descriptor: str = "blank"
 if use_auto_descriptor == "manual":
-    descriptor = pyv.SensorDescriptor(name="Temperature",
+    descriptor = sens.SensorDescriptor(name="Temperature",
                                         symbol="T",
                                         units = r"^{\circ}C",
                                         tag = "TC")
 elif use_auto_descriptor == "factory":
-    descriptor = pyv.SensorDescriptorFactory.temperature_descriptor()
+    descriptor = sens.SensorDescriptorFactory.temperature_descriptor()
 else:
-    descriptor = pyv.SensorDescriptor()
+    descriptor = sens.SensorDescriptor()
 
 #%%
 # We can now build our custom point sensor array. This sensor array has no
 # errors so if we call `get_measurements()` or `calc_measurements()` we will
 # be able to extract the simulation truth values at the sensor locations.
-tc_array = pyv.SensorArrayPoint(sensor_data,
+tc_array = sens.SensorArrayPoint(sensor_data,
                                 t_field,
                                 descriptor)
 
@@ -101,7 +104,7 @@ output_path = Path.cwd() / "pyvale-output"
 if not output_path.is_dir():
     output_path.mkdir(parents=True, exist_ok=True)
 
-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),
@@ -149,8 +152,8 @@ errors_on = {"sys": True,
 
 error_chain = []
 if errors_on["sys"]:
-    error_chain.append(pyv.ErrSysOffset(offset=-10.0))
-    error_chain.append(pyv.ErrSysUnif(low=-10.0,
+    error_chain.append(sens.ErrSysOffset(offset=-10.0))
+    error_chain.append(sens.ErrSysUnif(low=-10.0,
                                             high=10.0))
 #%%
 # This random error is generated by sampling from a normal distribution
@@ -159,8 +162,8 @@ if errors_on["sys"]:
 # probability distribution
 
 if errors_on["rand"]:
-    error_chain.append(pyv.ErrRandNorm(std=5.0))
-    error_chain.append(pyv.ErrRandUnifPercent(low_percent=-5.0,
+    error_chain.append(sens.ErrRandNorm(std=5.0))
+    error_chain.append(sens.ErrRandUnifPercent(low_percent=-5.0,
                                                 high_percent=5.0))
 
 #%%
@@ -171,11 +174,11 @@ if errors_on["rand"]:
 # INDEPENDENT.
 
 if len(error_chain) > 0:
-    err_int_opts = pyv.ErrIntOpts()
-    error_integrator = pyv.ErrIntegrator(error_chain,
-                                            sensor_data,
-                                            tc_array.get_measurement_shape(),
-                                            err_int_opts=err_int_opts)
+    err_int_opts = sens.ErrIntOpts()
+    error_integrator = sens.ErrIntegrator(error_chain,
+                                         sensor_data,
+                                         tc_array.get_measurement_shape(),
+                                         err_int_opts=err_int_opts)
     tc_array.set_error_integrator(error_integrator)
 
 #%%
@@ -204,11 +207,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*"-")
 
-(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+(fig,ax) = sens.plot_time_traces(tc_array,field_key)
 
 save_traces = output_path/"customsensors_ex1_3_sensortraces.png"
 fig.savefig(save_traces, dpi=300, bbox_inches="tight")

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