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

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

pyvale/examples/basics/{ex4_1_expsim2d_thermmech2d.py → ex4a_expsim2d_thermmech2d.py}

@@ -23,8 +23,11 @@ Test case: thermo-mechanical analysis of a 2D plate with a temperature 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
 
 #%%
 # Here we get a list of paths to a set of 3 simulations in this case the
@@ -32,7 +35,7 @@ import pyvale as pyv
 # coefficient on the other. The mechanical deformation is a result of
 # thermal expansion. The 3 simulation cases cover a nominal thermal
 # and a perturbation of +/-10%.
-data_paths = pyv.DataSet.thermomechanical_2d_experiment_paths()
+data_paths = dataset.thermomechanical_2d_experiment_paths()
 elem_dims: int = 2
 
 #%%
@@ -43,7 +46,7 @@ disp_comps = ("disp_x","disp_y")
 sim_list = []
 for pp in data_paths:
     sim_data = mh.ExodusReader(pp).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_comps)
     sim_list.append(sim_data)
@@ -60,10 +63,10 @@ n_sens = (4,1,1)
 x_lims = (0.0,100.0)
 y_lims = (0.0,50.0)
 z_lims = (0.0,0.0)
-tc_sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+tc_sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
-tc_sens_data = pyv.SensorData(positions=tc_sens_pos,
-                                sample_times=sample_times)
+tc_sens_data = sens.SensorData(positions=tc_sens_pos,
+                              sample_times=sample_times)
 
 #%%
 # We use the sensor array factory to give us thermocouples with basic 2%
@@ -72,7 +75,7 @@ tc_sens_data = pyv.SensorData(positions=tc_sens_pos,
 # we run our experiment the field object that relies on this will switch the
 # sim data for the required simulation in our list.
 tc_field_name = "temperature"
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_basic_errs(sim_list[0],
                                 tc_sens_data,
                                 elem_dims=elem_dims,
@@ -82,8 +85,8 @@ tc_array = pyv.SensorArrayFactory \
 #%%
 # We place 3 strain gauges along the direction of the temperature gradient.
 n_sens = (3,1,1)
-sg_sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
-sg_sens_data = pyv.SensorData(positions=sg_sens_pos,
+sg_sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+sg_sens_data = sens.SensorData(positions=sg_sens_pos,
                                 sample_times=sample_times)
 
 #%%
@@ -91,7 +94,7 @@ sg_sens_data = pyv.SensorData(positions=sg_sens_pos,
 sg_field_name = "strain"
 sg_norm_comps = ("strain_xx","strain_yy")
 sg_dev_comps = ("strain_xy",)
-sg_array = pyv.SensorArrayFactory \
+sg_array = sens.SensorArrayFactory \
     .strain_gauges_basic_errs(sim_list[0],
                                 sg_sens_data,
                                 elem_dims=elem_dims,
@@ -106,7 +109,7 @@ sg_array = pyv.SensorArrayFactory \
 # use this to create an experiment simulator while specifying how many
 # simulate experiments we want to run per simulation and sensor array.
 sensor_arrays = [tc_array,sg_array]
-exp_sim = pyv.ExperimentSimulator(sim_list,
+exp_sim = sens.ExperimentSimulator(sim_list,
                                     sensor_arrays,
                                     num_exp_per_sim=1000)
 
@@ -163,12 +166,12 @@ print(80*"=")
 # deviation. In the next example we will see how to control these plots.
 # For now we will plot the temperature traces for the first simulation and
 # the strain traces for the third simulation in our list of SimData objects.
-(fig,ax) = pyv.plot_exp_traces(exp_sim,
+(fig,ax) = sens.plot_exp_traces(exp_sim,
                                 component="temperature",
                                 sens_array_num=0,
                                 sim_num=0)
 
-(fig,ax) = pyv.plot_exp_traces(exp_sim,
+(fig,ax) = sens.plot_exp_traces(exp_sim,
                                 component="strain_yy",
                                 sens_array_num=1,
                                 sim_num=2)

pyvale/examples/basics/{ex4_2_expsim3d_thermmech3d.py → ex4b_expsim3d_thermmech3d.py}

@@ -20,14 +20,17 @@ Test case: thermo-mechanical analysis of a divertor heatsink in 3D
 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 get the path to simulation output file and then read the
 # simulation into a `SimData`  object. In this case our simulation is a
 # thermomechanical model of a divertor heatsink.
-sim_path = pyv.DataSet.thermomechanical_3d_path()
+sim_path = dataset.thermomechanical_3d_path()
 sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
 elem_dims: int = 3
 
@@ -35,7 +38,7 @@ elem_dims: int = 3
 # We scale our length and displacement units to mm to help with
 # visualisation.
 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)
 
@@ -59,15 +62,15 @@ x_lims = (12.5,12.5)
 y_lims = (0.0,33.0)
 z_lims = (0.0,12.0)
 n_sens = (1,4,1)
-tc_sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+tc_sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
-tc_sens_data = pyv.SensorData(positions=tc_sens_pos,
+tc_sens_data = sens.SensorData(positions=tc_sens_pos,
                                 sample_times=sample_times)
 #%%
 # We use the sensor array factory to create our thermocouple array with no
 # errors.
 tc_field_name = "temperature"
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_no_errs(sim_data,
                             tc_sens_data,
                             elem_dims=elem_dims,
@@ -76,30 +79,30 @@ tc_array = pyv.SensorArrayFactory \
 # Now we build our error chain starting with some basic errors on the order
 # of 1 degree.
 tc_err_chain = []
-tc_err_chain.append(pyv.ErrSysUnif(low=1.0,high=1.0))
-tc_err_chain.append(pyv.ErrRandNorm(std=1.0))
+tc_err_chain.append(sens.ErrSysUnif(low=1.0,high=1.0))
+tc_err_chain.append(sens.ErrRandNorm(std=1.0))
 
 #%%
 # Now we add positioning error for our thermocouples.
 tc_pos_uncert = 0.1 # units = mm
-tc_pos_rand = (pyv.GenNormal(std=tc_pos_uncert),
-                pyv.GenNormal(std=tc_pos_uncert),
-                pyv.GenNormal(std=tc_pos_uncert))
+tc_pos_rand = (sens.GenNormal(std=tc_pos_uncert),
+                sens.GenNormal(std=tc_pos_uncert),
+                sens.GenNormal(std=tc_pos_uncert))
 
 #%%
 # We block translation in x so the thermocouples stay attached.
 tc_pos_lock = np.full(tc_sens_pos.shape,False,dtype=bool)
 tc_pos_lock[:,0] = True
 
-tc_field_err_data = pyv.ErrFieldData(pos_rand_xyz=tc_pos_rand,
+tc_field_err_data = sens.ErrFieldData(pos_rand_xyz=tc_pos_rand,
                                         pos_lock_xyz=tc_pos_lock)
-tc_err_chain.append(pyv.ErrSysField(tc_array.get_field(),
+tc_err_chain.append(sens.ErrSysField(tc_array.get_field(),
 
                                     tc_field_err_data))
 #%%
 # We have finished our error chain so we can build our error integrator and
 # attach it to our thermocouple array.
-tc_error_int = pyv.ErrIntegrator(tc_err_chain,
+tc_error_int = sens.ErrIntegrator(tc_err_chain,
                                     tc_sens_data,
                                     tc_array.get_measurement_shape())
 tc_array.set_error_integrator(tc_error_int)
@@ -107,7 +110,7 @@ tc_array.set_error_integrator(tc_error_int)
 #%%
 # We visualise our thermcouple locations on our mesh to make sure they are
 # in the correct positions.
-pv_plot = pyv.plot_point_sensors_on_sim(tc_array,"temperature")
+pv_plot = sens.plot_point_sensors_on_sim(tc_array,"temperature")
 pv_plot.camera_position = [(59.354, 43.428, 69.946),
                             (-2.858, 13.189, 4.523),
                             (-0.215, 0.948, -0.233)]
@@ -127,9 +130,9 @@ x_lims = (9.4,9.4)
 y_lims = (0.0,33.0)
 z_lims = (12.0,12.0)
 n_sens = (1,4,1)
-sg_sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+sg_sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
-sg_sens_data = pyv.SensorData(positions=sg_sens_pos,
+sg_sens_data = sens.SensorData(positions=sg_sens_pos,
                                 sample_times=sample_times)
 
 #%%
@@ -138,7 +141,7 @@ sg_sens_data = pyv.SensorData(positions=sg_sens_pos,
 sg_field_name = "strain"
 sg_norm_comps = ("strain_xx","strain_yy","strain_zz")
 sg_dev_comps = ("strain_xy","strain_yz","strain_xz")
-sg_array = pyv.SensorArrayFactory \
+sg_array = sens.SensorArrayFactory \
     .strain_gauges_no_errs(sim_data,
                             sg_sens_data,
                             elem_dims=elem_dims,
@@ -150,30 +153,30 @@ sg_array = pyv.SensorArrayFactory \
 # Now we build our error chain starting with some basic errors on the order
 # of 1 percent.
 sg_err_chain = []
-sg_err_chain.append(pyv.ErrSysUnifPercent(low_percent=1.0,high_percent=1.0))
-sg_err_chain.append(pyv.ErrRandNormPercent(std_percent=1.0))
+sg_err_chain.append(sens.ErrSysUnifPercent(low_percent=1.0,high_percent=1.0))
+sg_err_chain.append(sens.ErrRandNormPercent(std_percent=1.0))
 
 #%%
 # We are going to add +/-2 degree rotation uncertainty to our strain gauges.
 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 only allow rotation on the face the strain gauges are on
 angle_lock = np.full(sg_sens_pos.shape,True,dtype=bool)
 angle_lock[:,0] = False   # Allow rotation about z
 
-sg_field_err_data = pyv.ErrFieldData(ang_rand_zyx=angle_rand_zyx,
+sg_field_err_data = sens.ErrFieldData(ang_rand_zyx=angle_rand_zyx,
                                         ang_lock_zyx=angle_lock)
-sg_err_chain.append(pyv.ErrSysField(sg_array.get_field(),
+sg_err_chain.append(sens.ErrSysField(sg_array.get_field(),
                                     sg_field_err_data))
 
 #%%
 # We have finished our error chain so we can build our error integrator and
 # attach it to our thermocouple array.
-sg_error_int = pyv.ErrIntegrator(sg_err_chain,
+sg_error_int = sens.ErrIntegrator(sg_err_chain,
                                     sg_sens_data,
                                     sg_array.get_measurement_shape())
 sg_array.set_error_integrator(sg_error_int)
@@ -181,7 +184,7 @@ sg_array.set_error_integrator(sg_error_int)
 #%%
 # Now we visualise the strain gauge locations to make sure they are where
 # we expect them to be.
-pv_plot = pyv.plot_point_sensors_on_sim(sg_array,"strain_yy")
+pv_plot = sens.plot_point_sensors_on_sim(sg_array,"strain_yy")
 pv_plot.camera_position = [(59.354, 43.428, 69.946),
                             (-2.858, 13.189, 4.523),
                             (-0.215, 0.948, -0.233)]
@@ -200,7 +203,7 @@ pv_plot.show()
 # all points on the graph.
 sim_list = [sim_data,]
 sensor_arrays = [tc_array,sg_array]
-exp_sim = pyv.ExperimentSimulator(sim_list,
+exp_sim = sens.ExperimentSimulator(sim_list,
                                     sensor_arrays,
                                     num_exp_per_sim=100)
 
@@ -246,11 +249,11 @@ print(80*"=")
 # the median as the centre line and to fill between the min and max values.
 # Note that the default here is to plot the mean and fill between 3 times
 # the standard deviation.
-trace_opts = pyv.TraceOptsExperiment(plot_all_exp_points=True,
-                                        centre=pyv.EExpVisCentre.MEDIAN,
-                                        fill_between=pyv.EExpVisBounds.MINMAX)
+trace_opts = sens.TraceOptsExperiment(plot_all_exp_points=True,
+                                        centre=sens.EExpVisCentre.MEDIAN,
+                                        fill_between=sens.EExpVisBounds.MINMAX)
 
-(fig,ax) = pyv.plot_exp_traces(exp_sim,
+(fig,ax) = sens.plot_exp_traces(exp_sim,
                                 component="temperature",
                                 sens_array_num=0,
                                 sim_num=0,
@@ -259,7 +262,7 @@ if save_figs:
     fig.savefig(fig_save_path/(save_tag+"_tc_traces.png"),
             dpi=300, format='png', bbox_inches='tight')
 
-(fig,ax) = pyv.plot_exp_traces(exp_sim,
+(fig,ax) = sens.plot_exp_traces(exp_sim,
                                 component="strain_yy",
                                 sens_array_num=1,
                                 sim_num=0,

pyvale/examples/basics/ex5_nomesh.py

@@ -0,0 +1,24 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""Basics: No mesh
+================================================================================
+
+TODO
+"""
+
+import numpy as np
+import pyvale as pyv
+
+# Build an analytic mesh in 2D and create a bi-linear field on the mesh
+
+# Run normal pyvale to see output of a sensor array
+
+
+
+
+
+