pyvale 2025.4.1__py3-none-any.whl → 2025.5.2__py3-none-any.whl

pyvale/examples/basics/ex3_3_tensorsens3d_strain3d.py

@@ -0,0 +1,182 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: Custom tensor field sensors (strain gauges) in 3D
+--------------------------------------------------------------------------------
+In this example we build a custom tensor field sensor array (i.e. a strain gauge
+array) in 3D. We will also demonstrate how to specify sensor angles and field
+errors based on sensor angles.
+
+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
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.spatial.transform import Rotation
+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 tensor field sensor we now have a third
+    # 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=sim_data,
+                                      disp_comps=disp_comps)
+
+    # 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 3D
+    # simulation here so we have 3 normal components and 3 deviatoric (shear).
+    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,
+                                   field_name=field_name,
+                                   norm_comps=norm_comps,
+                                   dev_comps=dev_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),     # bottom
+                                 (5.0,10.0,5.0),    # top
+                                 (5.0,5.0,0.0),     # xy face
+                                 (5.0,5.0,10.0),    # xy face
+                                 (0.0,5.0,5.0),     # yz face
+                                 (10.0,5.0,5.0),))  # yz face
+
+    # We set custom sensor sampling times here but we could also set this to
+    # None to have the sensors sample at the simulation time steps.
+    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    # We are going to manually specify the sensor angles for all our sensors.
+    sens_angles = (Rotation.from_euler("zyx", [0, 0, 0], degrees=True),
+                   Rotation.from_euler("zyx", [0, 0, 0], degrees=True),
+                   Rotation.from_euler("zyx", [45, 0, 0], degrees=True),
+                   Rotation.from_euler("zyx", [45, 0, 0], degrees=True),
+                   Rotation.from_euler("zyx", [0, 0, 45], degrees=True),
+                   Rotation.from_euler("zyx", [0, 0, 45], degrees=True),)
+
+
+    sens_data = pyv.SensorData(positions=sensor_positions,
+                               sample_times=sample_times,
+                               angles=sens_angles)
+
+    # 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','zz','xy','yz','xz'))
+
+
+    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.ErrSysUnif(low=-0.1e-3,high=0.1e-3))
+    error_chain.append(pyv.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))
+
+    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))
+
+    # We are going to lock position perturbation so that the sensors stay on the
+    # faces of the cube they are positioned on.
+    pos_lock = np.full(sensor_positions.shape,False,dtype=bool)
+    pos_lock[0:2,1] = True   # Block translation in y
+    pos_lock[2:4,2] = True   # Block translation in z
+    pos_lock[4:6,0] = True   # Block translation in x
+
+    # We are also going to lock angular perturbation so that each sensor is only
+    # allowed to rotate on the plane it is on.
+    angle_lock = np.full(sensor_positions.shape,True,dtype=bool)
+    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   # Alloq rotation about x
+
+    field_error_data = pyv.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)
+    error_chain.append(sys_err_field)
+
+
+    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.
+    measurements = straingauge_array.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*"-")
+
+    sens_print: int = 0
+    time_print: int = 5
+    comp_print: int = 1 # strain_yy based on order in tuple
+
+    print("ROTATED SENSORS WITH ANGLE ERRORS:")
+    print(f"These are the last {time_print} virtual measurements of sensor "
+          + f"{sens_print} for {norm_comps[comp_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()

pyvale/examples/basics/ex4_1_expsim2d_thermmech2d.py

@@ -0,0 +1,171 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""Pyvale example: Multi-physics experiment simulation in 2D
+--------------------------------------------------------------------------------
+In previous examples we have built our virtual sensor array and used this to
+run a single simulated experiment. However, we will generally want to run many
+simulated experiments and perform statistical analysis on the results. In this
+example we demonstrate how pyvale can be used to run a set of simulated
+experiments with a series of sensor arrays one measuring temperature and the
+other measuring strain. We also show how this analysis can be performed over a
+set of input physics simulations.
+
+Note that this tutorial assumes you are familiar with the use of pyvale for
+scalar and tensor fields as described in the previous examples.
+
+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
+
+
+def main() -> None:
+    # Here we get a list of paths to a set of 3 simulations in this case the
+    # simulation is a 2D plate with a heat flux on one edge and a heat transfer
+    # 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()
+    elem_dims: int = 2
+
+    # We now loop over the paths and load each into a `SimData` object. We then
+    # scale our length units to mm and append the simulation to a list which we
+    # will use to perform our simulated experiments.
+    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=sim_data,
+                                          disp_comps=disp_comps)
+        sim_list.append(sim_data)
+
+
+    # We will use the same sampling times for both the thermal and strain
+    # sensor arrays as well as the same positions.
+    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+
+    # We place 4 thermal sensors along the mid line of the plate in the
+    # direction of the temperature gradient.
+    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_data = pyv.SensorData(positions=tc_sens_pos,
+                                  sample_times=sample_times)
+
+    # We use the sensor array factory to give use thermocouples with basic 2%
+    # errors with uniform systematic error and normal random error. Note that
+    # we need to provide a `SimData` object to create our sensor array but when
+    # 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 \
+        .thermocouples_basic_errs(sim_list[0],
+                                  tc_sens_data,
+                                  elem_dims=elem_dims,
+                                  field_name=tc_field_name,
+                                  errs_pc=2.0)
+
+    # 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,
+                                  sample_times=sample_times)
+
+    # We use the factory to give us a basic strain gauge array as well.
+    sg_field_name = "strain"
+    sg_norm_comps = ("strain_xx","strain_yy")
+    sg_dev_comps = ("strain_xy",)
+    sg_array = pyv.SensorArrayFactory \
+        .strain_gauges_basic_errs(sim_list[0],
+                                  sg_sens_data,
+                                  elem_dims=elem_dims,
+                                  field_name=sg_field_name,
+                                  norm_comps=sg_norm_comps,
+                                  dev_comps=sg_dev_comps,
+                                  errs_pc=2.0)
+
+
+    # Now we have our list of simulation and the two sensor arrays we want to
+    # apply to the simulations. We create a list of our two sensor arrays and
+    # 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,
+                                      sensor_arrays,
+                                      num_exp_per_sim=1000)
+
+    # We can now run our experiments for all our sensor arrays. We are returned
+    # a list of numpy arrays. The index in the list corresponds to the position
+    # of the sensor array in the list. So if we want our thermocouple results we
+    # want exp_data[0] and for our strain gauges exp_data[1]. The numpy array
+    # has the following shape:
+    # (n_sims,n_exps,n_sensors,n_field_comps,n_time_steps)
+    exp_data = exp_sim.run_experiments()
+
+    # We can also calculate summary statistics for each sensor array which is
+    # returned as a list where the position corresponds to the sensor array as
+    # in our experimental data. The experiment stats object contains numpy
+    # arrays for each statistic that is collapsed over the number of
+    # experiments. The statistics we can acces include: mean, standard deviation
+    # minimum, maximum, median, median absolute deviation and the 25% and 75%
+    # quartiles. See the `ExperimentStats` data class for details.
+    exp_stats = exp_sim.calc_stats()
+
+    # We will index into and print the shape of our exp_data and exp_stats
+    # lists to demonstrate how this works in practice:
+    print(80*"=")
+    print("exp_data and exp_stats are lists where the index is the sensor array")
+    print("position in the list as field components are not consistent dims.\n")
+
+    print(80*"-")
+    print("Thermal sensor array @ exp_data[0]")
+    print(80*"-")
+    print("shape=(n_sims,n_exps,n_sensors,n_field_comps,n_time_steps)")
+    print(f"{exp_data[0].shape=}")
+    print()
+    print("Stats are calculated over all experiments (axis=1)")
+    print("shape=(n_sims,n_sensors,n_field_comps,n_time_steps)")
+    print(f"{exp_stats[0].max.shape=}")
+    print()
+    print(80*"-")
+    print("Mechanical sensor array @ exp_data[1]")
+    print(80*"-")
+    print("shape=(n_sims,n_exps,n_sensors,n_field_comps,n_time_steps)")
+    print(f"{exp_data[1].shape=}")
+    print()
+    print("shape=(n_sims,n_sensors,n_field_comps,n_time_steps)")
+    print(f"{exp_stats[1].max.shape=}")
+    print(80*"=")
+
+    # We also have specific plotting tools which allow us to visualise the
+    # uncertainty bounds for our sensor traces. The defaults plot options show
+    # the mean sensor trace and uncertainty bounds of 3 times the stanard
+    # 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,
+                                   component="temperature",
+                                   sens_array_num=0,
+                                   sim_num=0)
+
+    (fig,ax) = pyv.plot_exp_traces(exp_sim,
+                                   component="strain_yy",
+                                   sens_array_num=1,
+                                   sim_num=2)
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/basics/ex4_2_expsim3d_thermmech3d.py

@@ -0,0 +1,252 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""Pyvale example: Multi-physics experiment simulation in 3D
+--------------------------------------------------------------------------------
+In the previous example we performed a series of simulated experiments on a set
+of 2D multi-physics simulations. Here we use a 3D thermo-mechanical analysis of
+a divertor armour heatsink to show how we can run simulated experiments in 3D.
+
+Note that this tutorial assumes you are familiar with the use of pyvale for
+scalar and tensor fields as described in the previous examples.
+
+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
+
+def main() -> None:
+    # 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_data = mh.ExodusReader(sim_path).read_all_sim_data()
+    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=sim_data,
+                                      disp_comps=disp_comps)
+
+    # If we are going to save figures showing where our sensors are and their
+    # simulated traces we need to create a directory. Set the flag below to
+    # save the figures when you run the script
+    save_figs = False
+    save_tag = "thermomech3d"
+    fig_save_path = Path.cwd()/"images"
+    if not fig_save_path.is_dir():
+        fig_save_path.mkdir(parents=True, exist_ok=True)
+
+    # We specify manual sensor sampling times but we could also set this to None
+    # for the sensors to sample at the simulation time steps.
+    sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+
+    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_data = pyv.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 \
+        .thermocouples_no_errs(sim_data,
+                                tc_sens_data,
+                                elem_dims=elem_dims,
+                                field_name=tc_field_name)
+
+    # 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))
+
+    # 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))
+
+    # 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,
+                                         pos_lock_xyz=tc_pos_lock)
+    tc_err_chain.append(pyv.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_sens_data,
+                                     tc_array.get_measurement_shape())
+    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.camera_position = [(59.354, 43.428, 69.946),
+                               (-2.858, 13.189, 4.523),
+                               (-0.215, 0.948, -0.233)]
+    if save_figs:
+        pv_plot.save_graphic(fig_save_path/(save_tag+"_tc_vis.svg"))
+        pv_plot.screenshot(fig_save_path/(save_tag+"_tc_vis.png"))
+
+    pv_plot.show()
+
+    # Now we have finished with our thermocouple array we can move on to our
+    # strain gauge array.
+
+    # We use the same sampling time but we are going to place the strain gauges
+    # down the side of the monoblock where the pipe passes through.
+    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_data = pyv.SensorData(positions=sg_sens_pos,
+                                  sample_times=sample_times)
+
+    # We use the sensor array factory to give us a strain gauge array with no
+    # errors.
+    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 \
+        .strain_gauges_no_errs(sim_data,
+                                sg_sens_data,
+                                elem_dims=elem_dims,
+                                field_name=sg_field_name,
+                                norm_comps=sg_norm_comps,
+                                dev_comps=sg_dev_comps)
+
+    # 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))
+
+    # 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))
+
+    # 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,
+                                         ang_lock_zyx=angle_lock)
+    sg_err_chain.append(pyv.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_sens_data,
+                                     sg_array.get_measurement_shape())
+    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.camera_position = [(59.354, 43.428, 69.946),
+                               (-2.858, 13.189, 4.523),
+                               (-0.215, 0.948, -0.233)]
+    if save_figs:
+        pv_plot.save_graphic(fig_save_path/(save_tag+"_sg_vis.svg"))
+        pv_plot.screenshot(fig_save_path/(save_tag+"_sg_vis.png"))
+
+    pv_plot.show()
+
+    # We have both our sensor arrays so we will create and run our experiment.
+    # Here we only have a single input simulation in our list and we only run
+    # 100 simulated experiments as we are going to plot all simulated data
+    # points on our traces. Note that if you are running more than 100
+    # experiments here you will need to set the trace plots below to not show
+    # all points on the graph.
+    sim_list = [sim_data,]
+    sensor_arrays = [tc_array,sg_array]
+    exp_sim = pyv.ExperimentSimulator(sim_list,
+                                      sensor_arrays,
+                                      num_exp_per_sim=100)
+
+    # We run our experiments and calculate summary statistics as in the previous
+    # example
+    exp_data = exp_sim.run_experiments()
+    exp_stats = exp_sim.calc_stats()
+
+    # We print the lengths of our exp_data and exp_stats lists along with the
+    # shape of the numpy arrays they contain so we can index into them easily.
+    print(80*"=")
+    print("exp_data and exp_stats are lists where the index is the sensor array")
+    print("position in the list as field components are not consistent dims:")
+    print(f"{len(exp_data)=}")
+    print(f"{len(exp_stats)=}")
+    print()
+    print(80*"-")
+    print("Thermal sensor array @ exp_data[0]")
+    print(80*"-")
+    print("shape=(n_sims,n_exps,n_sensors,n_field_comps,n_time_steps)")
+    print(f"{exp_data[0].shape=}")
+    print()
+    print("Stats are calculated over all experiments (axis=1)")
+    print("shape=(n_sims,n_sensors,n_field_comps,n_time_steps)")
+    print(f"{exp_stats[0].max.shape=}")
+    print()
+    print(80*"-")
+    print("Mechanical sensor array @ exp_data[1]")
+    print(80*"-")
+    print("shape=(n_sims,n_exps,n_sensors,n_field_comps,n_time_steps)")
+    print(f"{exp_data[1].shape=}")
+    print()
+    print("shape=(n_sims,n_sensors,n_field_comps,n_time_steps)")
+    print(f"{exp_stats[1].max.shape=}")
+    print(80*"=")
+
+    # Finally, we are going to plot the simulated sensor traces but we are going
+    # to control some of the plotting options using the options data class here.
+    # We set the plot to show all simulated experiment data points and to plot
+    # 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)
+
+    (fig,ax) = pyv.plot_exp_traces(exp_sim,
+                                   component="temperature",
+                                   sens_array_num=0,
+                                   sim_num=0,
+                                   trace_opts=trace_opts)
+    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,
+                                   component="strain_yy",
+                                   sens_array_num=1,
+                                   sim_num=0,
+                                   trace_opts=trace_opts)
+    if save_figs:
+        fig.savefig(fig_save_path/(save_tag+"_sg_traces.png"),
+                dpi=300, format='png', bbox_inches='tight')
+    plt.show()
+
+if __name__ == "__main__":
+    main()

pyvale/examples/{analyticdatagen → genanalyticdata}/ex1_1_scalarvisualisation.py

@@ -1,12 +1,9 @@
-'''
-================================================================================
-Analytic test case data - linear
-
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-'''
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
 import matplotlib.pyplot as plt
 import pyvale
 

pyvale/examples/{analyticdatagen → genanalyticdata}/ex1_2_scalarcasebuild.py

@@ -1,12 +1,9 @@
-'''
-================================================================================
-Analytic test case data - linear
-
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-'''
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
 import numpy as np
 import matplotlib.pyplot as plt
 import sympy
@@ -14,7 +11,7 @@ import pyvale
 
 def main() -> None:
 
-    case_data = pyvale.AnalyticCaseData2D()
+    case_data = pyvale.AnalyticData2D()
     case_data.length_x = 10.0
     case_data.length_y = 7.5
     n_elem_mult = 10
@@ -30,7 +27,7 @@ def main() -> None:
     case_data.offsets_time = (0.0,)
 
 
-    data_gen = pyvale.AnalyticSimDataGenerator(case_data)
+    data_gen = pyvale.AnalyticSimDataGen(case_data)
     sim_data = data_gen.generate_sim_data()
 
     (grid_x,grid_y,grid_field) = data_gen.get_visualisation_grid()