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_5_vectorfields3d_disp3d.py

@@ -5,14 +5,15 @@
 # ==============================================================================
 
 """
-Pyvale example: 3D vector field sensors
---------------------------------------------------------------------------------
+Basics: 3D vector field sensors
+================================================================================
+
 In all our previous examples we have looked at a 2D solid mechanics simulation
 and applied displacement sensors to the vector field. Here we will build a
 custom vector field sensor array on a 3D simulation of a small linear elastic
 cube loaded in tension with the addition of an applied thermal gradient.
 
-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: Simple 3D cube thermo-mechanical in tension with temp gradient.
@@ -24,86 +25,87 @@ import mooseherder as mh
 import pyvale as pyv
 
 
-def main() -> None:
-    # Frist 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)
-    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
-
-    # As we are creating a 3D vector field sensor we now have a third
-    # 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=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)
-
-    descriptor = pyv.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)
-
-    # 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),))
-
-    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)
-
-    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.show()
-
-    # 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(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 noting that we
-    # expect the bottom of the cube to be fixed, the top of the cube to have the
-    # 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)
-
-    plt.show()
-
-
-if __name__ == "__main__":
-    main()
+#%%
+# 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)
+sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+
+#%%
+# As we are creating a 3D vector field sensor we now have a third
+# 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=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)
+
+descriptor = pyv.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)
+
+#%%
+# 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),))
+
+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)
+
+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.show()
+
+#%%
+# 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(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 noting that we
+# expect the bottom of the cube to be fixed, the top of the cube to have the
+# 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)
+
+plt.show()

pyvale/examples/basics/ex3_1_basictensors_strain2d.py

@@ -5,14 +5,15 @@
 # ==============================================================================
 
 """
-Pyvale example: Basic tensor field sensors (strain gauges)
---------------------------------------------------------------------------------
+Basics: Tensor field sensors (strain gauges)
+================================================================================
+
 In this example we use the sensor array factory to build a set of strain
 sensors that can sample the strain tensor field from a solid mechanics
 simulation. In the next example we will examine how we can build custom tensor
 field sensors as we did for scalar field in the first set of examples.
 
-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 strain sensors on a 2D plate with hole loaded in tension
@@ -25,90 +26,89 @@ import mooseherder as mh
 from mooseherder import SimData
 import pyvale as pyv
 
-def main() -> None:
-    # First we load the same 2D solid mechanics simulation we used previously
-    # for vector displacement fields. Most of this setup code is similar to our
-    # 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"))
-
-    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)
-
-    sens_data = pyv.SensorData(positions=sens_pos,
-                               sample_times=sample_times)
-
-    # This is where we need to specify the string keys for the normal and
-    # deviatoric components of our strain field. In 2D we have two normal
-    # normal components and one deviatoric. In 3D we will have 3 of each as we
-    # will see in a later example. Otherwise this is very similar to what we
-    # have seen previously for scalar and vector fields.
-    norm_comps = ("strain_xx","strain_yy")
-    dev_comps = ("strain_xy",)
-    straingauge_array = pyv.SensorArrayFactory \
-                            .strain_gauges_basic_errs(sim_data,
-                                                      sens_data,
-                                                      elem_dims=2,
-                                                      field_name="strain",
-                                                      norm_comps=norm_comps,
-                                                      dev_comps=dev_comps,
-                                                      errs_pc=5.0)
-
-    # We run our virtual sensor simulation as normal. The only thing to note is
-    # that the second dimension of our measurement array will contain our tensor
-    # components in the order they are specified in the tuples with the normal
-    # components first followed by the deviatoric. In our case this will be
-    # (strain_xx,strain_yy,strain_xy).
-    measurements = straingauge_array.calc_measurements()
-
-    # Here we print the shape of the measurement array so we can see that the
-    # second dimension contains both our tensor components. We also print some
-    # of the sensor measurements for the first tensor component.
-    print("\n"+80*"-")
-    print("For a virtual sensor: measurement = truth + sysematic error + random error")
-    print(f"measurements.shape = {measurements.shape} = "+
-          "(n_sensors,n_field_components,n_timesteps)\n")
-    print("The truth, systematic error and random error arrays have the same "+
-          "shape.")
-
-    print(80*"-")
-
-    sens_print: int = 0
-    time_print: int = 5
-    comp_print: int = 0
-
-    print(f"These are the last {time_print} virtual measurements of sensor "
-          + f"{sens_print}:")
-
-    pyv.print_measurements(sens_array=straingauge_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*"-")
-
-    # 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.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)
-
-    plt.show()
-
-
-if __name__ == "__main__":
-    main()
+#%%
+# First we load the same 2D solid mechanics simulation we used previously
+# for vector displacement fields. Most of this setup code is similar to our
+# 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"))
+
+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)
+
+sens_data = pyv.SensorData(positions=sens_pos,
+                            sample_times=sample_times)
+
+#%%
+# This is where we need to specify the string keys for the normal and
+# deviatoric components of our strain field. In 2D we have two normal
+# normal components and one deviatoric. In 3D we will have 3 of each as we
+# will see in a later example. Otherwise this is very similar to what we
+# have seen previously for scalar and vector fields.
+norm_comps = ("strain_xx","strain_yy")
+dev_comps = ("strain_xy",)
+straingauge_array = pyv.SensorArrayFactory \
+                        .strain_gauges_basic_errs(sim_data,
+                                                    sens_data,
+                                                    elem_dims=2,
+                                                    field_name="strain",
+                                                    norm_comps=norm_comps,
+                                                    dev_comps=dev_comps,
+                                                    errs_pc=5.0)
+
+#%%
+# We run our virtual sensor simulation as normal. The only thing to note is
+# that the second dimension of our measurement array will contain our tensor
+# components in the order they are specified in the tuples with the normal
+# components first followed by the deviatoric. In our case this will be
+# (strain_xx,strain_yy,strain_xy).
+measurements = straingauge_array.calc_measurements()
+
+#%%
+# Here we print the shape of the measurement array so we can see that the
+# second dimension contains both our tensor components. We also print some
+# of the sensor measurements for the first tensor component.
+print("\n"+80*"-")
+print("For a virtual sensor: measurement = truth + sysematic error + random error")
+print(f"measurements.shape = {measurements.shape} = "+
+        "(n_sensors,n_field_components,n_timesteps)\n")
+print("The truth, systematic error and random error arrays have the same "+
+        "shape.")
+
+print(80*"-")
+
+sens_print = 0
+comp_print = 0
+time_last = 5
+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)
+
+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.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)
+
+plt.show()

pyvale/examples/basics/ex3_2_tensorsens2d_strain2d.py

@@ -5,12 +5,13 @@
 # ==============================================================================
 
 """
-Pyvale example: Custom tensor field sensors (strain gauges) in 2D
---------------------------------------------------------------------------------
+Basics: Custom tensor field sensors (strain gauges) in 2D
+================================================================================
+
 In this example we build a custom tensor field sensor array (i.e. a strain gauge
 array) in 2D.
 
-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 strain sensors on a 2D plate with hole loaded in tension
@@ -21,91 +22,92 @@ import matplotlib.pyplot as plt
 import mooseherder as mh
 import pyvale as pyv
 
-def main() -> None:
-    # 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()
-    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
-    sim_data = pyv.scale_length_units(scale=1000.0,
-                                      sim_data=sim_data,
-                                      disp_comps=("disp_x","disp_y"))
-
-
-    # Here is the main difference when creating a tensor field sensor array. We
-    # create a tensor field where we need to specify the normal and deviatoric
-    # component string keys as they appear in our `SimData` object. We have a 2d
-    # simulation here so we have 2 normal components and 1 deviatoric (shear).
-    field_name = "strain"
-    norm_comps = ("strain_xx","strain_yy")
-    dev_comps = ("strain_xy",)
-    strain_field = pyv.FieldTensor(sim_data,
-                                   field_name=field_name,
-                                   norm_comps=norm_comps,
-                                   dev_comps=dev_comps,
-                                   elem_dims=2)
-
-    # The setup of our sensor data object is exactly the same as for any other
-    # point sensor array. We could optionally specify the sample time to be None
-    # in which case the sensor will sample at the simulation time steps.
-    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)
-
-    sens_data = pyv.SensorData(positions=sens_pos,
-                               sample_times=sample_times)
-
-    # Here we create a descriptor that will be used to label visualisations of
-    # 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",
-                                      symbol=r"\varepsilon",
-                                      units=r"-",
-                                      tag="SG",
-                                      components=("xx","yy","xy"))
-
-    # We build our point sensor array as normal.
-    straingauge_array = pyv.SensorArrayPoint(sens_data,
-                                             strain_field,
-                                             descriptor)
-
-
-    # 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,
-                                  sens_data,
-                                  straingauge_array.get_measurement_shape())
-    straingauge_array.set_error_integrator(error_int)
-
-    # We run our virtual sensor simulation as normal. The only thing to note is
-    # that the second dimension of our measurement array will contain our tensor
-    # components in the order they are specified in the tuples with the normal
-    # components first followed by the deviatoric. In our case this will be
-    # (strain_xx,strain_yy,strain_xy).
-    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.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)
-
-    plt.show()
-
-
-
-if __name__ == "__main__":
-    main()
+#%%
+# 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()
+sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+sim_data = pyv.scale_length_units(scale=1000.0,
+                                    sim_data=sim_data,
+                                    disp_comps=("disp_x","disp_y"))
+
+#%%
+# Here is the main difference when creating a tensor field sensor array. We
+# create a tensor field where we need to specify the normal and deviatoric
+# component string keys as they appear in our `SimData` object. We have a 2d
+# simulation here so we have 2 normal components and 1 deviatoric (shear).
+field_name = "strain"
+norm_comps = ("strain_xx","strain_yy")
+dev_comps = ("strain_xy",)
+strain_field = pyv.FieldTensor(sim_data,
+                                field_name=field_name,
+                                norm_comps=norm_comps,
+                                dev_comps=dev_comps,
+                                elem_dims=2)
+
+#%%
+# The setup of our sensor data object is exactly the same as for any other
+# point sensor array. We could optionally specify the sample time to be None
+# in which case the sensor will sample at the simulation time steps.
+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)
+
+sens_data = pyv.SensorData(positions=sens_pos,
+                            sample_times=sample_times)
+
+#%%
+# Here we create a descriptor that will be used to label visualisations of
+# 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",
+                                    symbol=r"\varepsilon",
+                                    units=r"-",
+                                    tag="SG",
+                                    components=("xx","yy","xy"))
+
+#%%
+# We build our point sensor array as normal.
+straingauge_array = pyv.SensorArrayPoint(sens_data,
+                                            strain_field,
+                                            descriptor)
+
+#%%
+# 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,
+                                sens_data,
+                                straingauge_array.get_measurement_shape())
+straingauge_array.set_error_integrator(error_int)
+
+#%%
+# We run our virtual sensor simulation as normal. The only thing to note is
+# that the second dimension of our measurement array will contain our tensor
+# components in the order they are specified in the tuples with the normal
+# components first followed by the deviatoric. In our case this will be
+# (strain_xx,strain_yy,strain_xy).
+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.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)
+
+plt.show()