pyvale 2025.5.3__cp311-cp311-musllinux_1_2_aarch64.whl → 2025.7.0__cp311-cp311-musllinux_1_2_aarch64.whl

pyvale/examples/basics/ex2_3_sensangle_disp2d.py

@@ -5,15 +5,16 @@
 # ==============================================================================
 
 """
-Pyvale example: Sensor angles for vector fields
---------------------------------------------------------------------------------
+Basics: Sensor angles for vector fields
+================================================================================
+
 In this example we demonstrate how to setup vector field sensors at custom
 orientations with respect to the simulation coordinate system. We first build a
 sensor array aligned with the simulation coords in the same way as the previous
 example. We then build a sensor array with the sensors rotated and compare this
 to the case with no rotation.
 
-Note that this tutorial assumes you are familiar with the use of pyvale for
+Note that this tutorial assumes you are familiar with the use of `pyvale` for
 scalar fields as described in the first set of examples.
 
 Test case: point displacement sensors on a 2D plate with hole loaded in tension
@@ -25,115 +26,113 @@ from scipy.spatial.transform import Rotation
 import mooseherder as mh
 import pyvale as pyv
 
-def main() -> None:
-    # 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()
-    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=sim_data,
-                                      disp_comps=field_comps)
+#%%
+# 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()
+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=sim_data,
+                                    disp_comps=field_comps)
 
-    descriptor = pyv.SensorDescriptorFactory.displacement_descriptor()
+descriptor = pyv.SensorDescriptorFactory.displacement_descriptor()
 
-    disp_field = pyv.FieldVector(sim_data,field_name,field_comps,elem_dims=2)
+disp_field = pyv.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)
+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)
 
 
-    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+sample_times = np.linspace(0.0,np.max(sim_data.time),50)
 
-    sens_data_norot = pyv.SensorData(positions=sens_pos,
-                                     sample_times=sample_times)
+sens_data_norot = pyv.SensorData(positions=sens_pos,
+                                    sample_times=sample_times)
 
-    disp_sens_norot = pyv.SensorArrayPoint(sens_data_norot,
-                                           disp_field,
-                                           descriptor)
+disp_sens_norot = pyv.SensorArrayPoint(sens_data_norot,
+                                        disp_field,
+                                        descriptor)
 
-    disp_sens_norot.calc_measurements()
+disp_sens_norot.calc_measurements()
 
-    # To create our sensor array with rotated sensors we need to add a tuple of
-    # scipy rotation objects to our sensor data class. This tuple must be the
-    # same length as the number of sensors in the sensor array. Note that it is
-    # also possible to specify a single rotation in the tuple in this case all
-    # sensors are assumed to have the same rotation and they are batch processed
-    # to increase speed. Here we will define our rotations to all be the same
-    # rotation in degrees about the z axis which is the out of plane axis for
-    # our current test case.
-    sens_angles = sens_pos.shape[0] * \
-        (Rotation.from_euler("zyx", [45, 0, 0], degrees=True),)
+#%%
+# To create our sensor array with rotated sensors we need to add a tuple of
+# scipy rotation objects to our sensor data class. This tuple must be the
+# same length as the number of sensors in the sensor array. Note that it is
+# also possible to specify a single rotation in the tuple in this case all
+# sensors are assumed to have the same rotation and they are batch processed
+# to increase speed. Here we will define our rotations to all be the same
+# rotation in degrees about the z axis which is the out of plane axis for
+# our current test case.
+sens_angles = sens_pos.shape[0] * \
+    (Rotation.from_euler("zyx", [45, 0, 0], degrees=True),)
 
-    # We could have also use a single element tuple to have all sensors have the
-    # angle and batch process them:
-    sens_angles = (Rotation.from_euler("zyx", [45, 0, 0], degrees=True),)
+# We could have also use a single element tuple to have all sensors have the
+# angle and batch process them:
+sens_angles = (Rotation.from_euler("zyx", [45, 0, 0], degrees=True),)
 
 
-    sens_data_rot = pyv.SensorData(positions=sens_pos,
-                                   sample_times=sample_times,
-                                   angles=sens_angles)
+sens_data_rot = pyv.SensorData(positions=sens_pos,
+                                sample_times=sample_times,
+                                angles=sens_angles)
 
-    disp_sens_rot = pyv.SensorArrayPoint(sens_data_rot,
-                                            disp_field,
-                                            descriptor)
+disp_sens_rot = pyv.SensorArrayPoint(sens_data_rot,
+                                        disp_field,
+                                        descriptor)
 
-    # We can also use a field error to add uncertainty to the sensors angle.
-    # We can apply a specific offset to each sensor or provide a random
-    # generator to perturb the sensors orientation. Note that the offset and
-    # 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,
-                                        ang_rand_zyx=angle_rand)
+#%%
+# We can also use a field error to add uncertainty to the sensors angle.
+# We can apply a specific offset to each sensor or provide a random
+# generator to perturb the sensors orientation. Note that the offset and
+# 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,
+                                    ang_rand_zyx=angle_rand)
 
 
-    sys_err_rot = pyv.ErrSysField(disp_field,angle_error_data)
-    sys_err_int = pyv.ErrIntegrator([sys_err_rot],
-                                    sens_data_rot,
-                                    disp_sens_rot.get_measurement_shape())
-    disp_sens_rot.set_error_integrator(sys_err_int)
+sys_err_rot = pyv.ErrSysField(disp_field,angle_error_data)
+sys_err_int = pyv.ErrIntegrator([sys_err_rot],
+                                sens_data_rot,
+                                disp_sens_rot.get_measurement_shape())
+disp_sens_rot.set_error_integrator(sys_err_int)
 
-    measurements = disp_sens_rot.calc_measurements()
+measurements = disp_sens_rot.calc_measurements()
 
 
-    # We print some of the results for one of the sensors so we can see the
-    # effect of the field errors.
-    print(80*"-")
+#%%
+# We print some of the results for one of the sensors so we can see the
+# effect of the field errors.
+print(80*"-")
 
-    sens_print: int = 0
-    time_print: int = 5
-    comp_print: int = 0
+sens_print = 0
+comp_print = 0
+time_last = 5
+time_print = slice(measurements.shape[2]-time_last,measurements.shape[2])
 
-    print("ROTATED SENSORS WITH ANGLE ERRORS:")
-    print(f"These are the last {time_print} virtual measurements of sensor "
-          + f"{sens_print} for {field_comps[comp_print]}:")
+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(sens_array=disp_sens_rot,
-                           sensors=(sens_print,sens_print+1),
-                           components=(comp_print,comp_print+1),
-                           time_steps=(measurements.shape[2]-time_print,
-                                       measurements.shape[2]))
-    print(80*"-")
+pyv.print_measurements(disp_sens_rot,sens_print,comp_print,time_print)
 
-    # 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.set_title("No Rotation")
-        (_,ax) = pyv.plot_time_traces(disp_sens_rot,ff)
-        ax.set_title("Rotated with Errors")
+print(80*"-")
 
-    plt.show()
+#%%
+# 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.set_title("No Rotation")
+    (_,ax) = pyv.plot_time_traces(disp_sens_rot,ff)
+    ax.set_title("Rotated with Errors")
 
+plt.show()
 
-if __name__ == "__main__":
-    main()

pyvale/examples/basics/ex2_4_chainfielderrs_disp2d.py

@@ -5,8 +5,9 @@
 # ==============================================================================
 
 """
-Pyvale example: Chaining field errors
-----------------------------------------------------------------------------
+Basics: Chaining field errors
+================================================================================
+
 In this example we show how field errors can be chained together and accumulated
 allowing for successive perturbations in postion, sampling time and orientation.
 It is more computationally efficient to provide a single field error object as
@@ -15,7 +16,7 @@ interpolation of the underlying physical field. However, in some cases it can
 be useful to separate the sensor parameter perturbations to determine which is
 contributing most to the total error.
 
-Note that this tutorial assumes you are familiar with the use of pyvale for
+Note that this tutorial assumes you are familiar with the use of `pyvale` for
 scalar fields as described in the first set of examples.
 
 Test case: point displacement sensors on a 2D plate with hole loaded in tension
@@ -26,171 +27,171 @@ import matplotlib.pyplot as plt
 import mooseherder as mh
 import pyvale as pyv
 
-def main() -> None:
-    # 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()
-    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=sim_data,
-                                      disp_comps=field_comps)
-
-    descriptor = pyv.SensorDescriptorFactory.displacement_descriptor()
-
-    disp_field = pyv.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)
-
-    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
-
-    sensor_data = pyv.SensorData(positions=sensor_positions,
-                                 sample_times=sample_times)
-
-    disp_sens_array = pyv.SensorArrayPoint(sensor_data,
-                                           disp_field,
-                                           descriptor)
-
-
-    # Now we will build a series of field errors that cause succesive offsets in
-    # sensor sampling time, sensor position and sensor orientation. That way
-    # we should be able to analyse the sensor data object at each point in the
-    # error chain to see how the sensor parameters have accumulated.
-
-    # 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)
-
-    # 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)
-
-    time_offset = 2.0*np.ones_like(disp_sens_array.get_sample_times())
-    time_error_data = pyv.ErrFieldData(time_offset=time_offset)
-
-    # Now we add all our field errors to our error chain. We add each error
-    # twice to see how they accumulate with each other. We also need to set the
-    # 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,
-                                     time_error_data,
-                                     pyv.EErrDep.DEPENDENT))
-    err_chain.append(pyv.ErrSysField(disp_field,
-                                     time_error_data,
-                                     pyv.EErrDep.DEPENDENT))
-
-    err_chain.append(pyv.ErrSysField(disp_field,
-                                     pos_error_data,
-                                     pyv.EErrDep.DEPENDENT))
-    err_chain.append(pyv.ErrSysField(disp_field,
-                                     pos_error_data,
-                                     pyv.EErrDep.DEPENDENT))
-
-    err_chain.append(pyv.ErrSysField(disp_field,
-                                     angle_error_data,
-                                     pyv.EErrDep.DEPENDENT))
-    err_chain.append(pyv.ErrSysField(disp_field,
-                                     angle_error_data,
-                                     pyv.EErrDep.DEPENDENT))
-
-    # Instead of setting the dependence for each individual error above we could
-    # also just use our error integration options to force all errors to be
-    # `DEPENDENT`. We also set the error integration options to store the errors
-    # for each step in the error chain so we can analyse the sensor data at each
-    # step of chain. This option also allows us to separate the contribution of
-    # 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,
-                                  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,
-                                  sensor_data,
-                                  disp_sens_array.get_measurement_shape(),
-                                  err_int_opts)
-    disp_sens_array.set_error_integrator(error_int)
-
-    measurements = disp_sens_array.calc_measurements()
-
-
-    # Here we will print to the console the time, position and angle of from the
-    # sensor data objects at each point in the error chain. We should see each
-    # sensor parameter perturbed and accumulated throughout the chain:
-    sens_data_by_chain = error_int.get_sens_data_by_chain()
-    if sens_data_by_chain is not None:
-        for ii,ss in enumerate(sens_data_by_chain):
-            print(80*"-")
-            if ss is not None:
-                print(f"SensorData @ [{ii}]")
-                print("TIME")
-                print(ss.sample_times)
-                print()
-                print("POSITIONS")
-                print(ss.positions)
-                print()
-                print("ANGLES")
-                for aa in ss.angles:
-                    print(aa.as_euler("zyx",degrees=True))
-                print()
-            print(80*"-")
-
-    # Try setting all the field errors to be `INDEPENDENT` using the error
-    # integration options above. You should see that the sensor parameters are
-    # not accumulated throughout the error chain.
-
-    # Here we print the final sampling time, sensor positions and sensor angles
-    # at the end of error chain.
-    print()
-    print(80*"=")
-    sens_data_accumulated = error_int.get_sens_data_accumulated()
-    print("TIME")
-    print(sens_data_accumulated.sample_times)
-    print()
-    print("POSITIONS")
-    print(sens_data_accumulated.positions)
-    print()
-    print("ANGLES")
-    for aa in sens_data_accumulated.angles:
-        print(aa.as_euler("zyx",degrees=True))
-    print()
-    print(80*"=")
-
-    # We print the results for one of the sensors so we can see what the errors
-    # are for the last few sampling times.
-    print(80*"-")
-
-    sens_print: int = 0
-    time_print: int = 5
-    comp_print: int = 0
-
-    print("ROTATED SENSORS WITH ANGLE ERRORS:")
-    print(f"These are the last {time_print} virtual measurements of sensor "
-          + f"{sens_print} for {field_comps[comp_print]}:")
-
-    pyv.print_measurements(sens_array=disp_sens_array,
-                           sensors=(sens_print,sens_print+1),
-                           components=(comp_print,comp_print+1),
-                           time_steps=(measurements.shape[2]-time_print,
-                                       measurements.shape[2]))
-    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)
-
-    plt.show()
-
-
-if __name__ == "__main__":
-    main()
+#%%
+# 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()
+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=sim_data,
+                                    disp_comps=field_comps)
+
+descriptor = pyv.SensorDescriptorFactory.displacement_descriptor()
+
+disp_field = pyv.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)
+
+sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+sensor_data = pyv.SensorData(positions=sensor_positions,
+                                sample_times=sample_times)
+
+disp_sens_array = pyv.SensorArrayPoint(sensor_data,
+                                        disp_field,
+                                        descriptor)
+
+#%%
+# Now we will build a series of field errors that cause succesive offsets in
+# sensor sampling time, sensor position and sensor orientation. That way
+# we should be able to analyse the sensor data object at each point in the
+# error chain to see how the sensor parameters have accumulated.
+#
+# 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)
+
+#%%
+# 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)
+
+time_offset = 2.0*np.ones_like(disp_sens_array.get_sample_times())
+time_error_data = pyv.ErrFieldData(time_offset=time_offset)
+
+#%%
+# Now we add all our field errors to our error chain. We add each error
+# twice to see how they accumulate with each other. We also need to set the
+# 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,
+                                    time_error_data,
+                                    pyv.EErrDep.DEPENDENT))
+err_chain.append(pyv.ErrSysField(disp_field,
+                                    time_error_data,
+                                    pyv.EErrDep.DEPENDENT))
+
+err_chain.append(pyv.ErrSysField(disp_field,
+                                    pos_error_data,
+                                    pyv.EErrDep.DEPENDENT))
+err_chain.append(pyv.ErrSysField(disp_field,
+                                    pos_error_data,
+                                    pyv.EErrDep.DEPENDENT))
+
+err_chain.append(pyv.ErrSysField(disp_field,
+                                    angle_error_data,
+                                    pyv.EErrDep.DEPENDENT))
+err_chain.append(pyv.ErrSysField(disp_field,
+                                    angle_error_data,
+                                    pyv.EErrDep.DEPENDENT))
+
+#%%
+# Instead of setting the dependence for each individual error above we could
+# also just use our error integration options to force all errors to be
+# `DEPENDENT`. We also set the error integration options to store the errors
+# for each step in the error chain so we can analyse the sensor data at each
+# step of chain. This option also allows us to separate the contribution of
+# 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,
+                                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,
+                                sensor_data,
+                                disp_sens_array.get_measurement_shape(),
+                                err_int_opts)
+disp_sens_array.set_error_integrator(error_int)
+
+measurements = disp_sens_array.calc_measurements()
+
+#%%
+# Here we will print to the console the time, position and angle of from the
+# sensor data objects at each point in the error chain. We should see each
+# sensor parameter perturbed and accumulated throughout the chain:
+sens_data_by_chain = error_int.get_sens_data_by_chain()
+if sens_data_by_chain is not None:
+    for ii,ss in enumerate(sens_data_by_chain):
+        print(80*"-")
+        if ss is not None:
+            print(f"SensorData @ [{ii}]")
+            print("TIME")
+            print(ss.sample_times)
+            print()
+            print("POSITIONS")
+            print(ss.positions)
+            print()
+            print("ANGLES")
+            for aa in ss.angles:
+                print(aa.as_euler("zyx",degrees=True))
+            print()
+        print(80*"-")
+
+#%%
+# Try setting all the field errors to be `INDEPENDENT` using the error
+# integration options above. You should see that the sensor parameters are
+# not accumulated throughout the error chain.
+#
+# Here we print the final sampling time, sensor positions and sensor angles
+# at the end of error chain.
+print()
+print(80*"=")
+sens_data_accumulated = error_int.get_sens_data_accumulated()
+print("TIME")
+print(sens_data_accumulated.sample_times)
+print()
+print("POSITIONS")
+print(sens_data_accumulated.positions)
+print()
+print("ANGLES")
+for aa in sens_data_accumulated.angles:
+    print(aa.as_euler("zyx",degrees=True))
+print()
+print(80*"=")
+
+#%%
+# We print the results for one of the sensors so we can see what the errors
+# are for the last few sampling times.
+print(80*"-")
+
+sens_print = 0
+comp_print = 0
+time_last = 5
+time_print = slice(measurements.shape[2]-time_last,measurements.shape[2])
+
+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)
+
+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)
+
+plt.show()