pyvale 2025.4.0__py3-none-any.whl

pyvale/examples/ex4_3_strain2d.py

@@ -0,0 +1,100 @@
+'''
+================================================================================
+Example: strain sensors on a 2d plate
+
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+'''
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.spatial.transform import Rotation as R
+import mooseherder as mh
+import pyvale as pyv
+
+def main() -> None:
+    """pyvale example: strain sensors on a 2D plate with a hole
+    ----------------------------------------------------------------------------
+    - Demonstrates rotation of tensor fields
+    """
+    data_path = pyv.DataSet.mechanical_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    # Scale to mm to make 3D visualisation scaling easier
+    sim_data.coords = sim_data.coords*1000.0 # type: ignore
+
+    descriptor = pyv.SensorDescriptorFactory.strain_descriptor()
+
+    spat_dims = 2
+    field_key = 'strain'
+    norm_components = ('strain_xx','strain_yy')
+    dev_components = ('strain_xy',)
+    strain_field = pyv.FieldTensor(sim_data,
+                                    field_key,
+                                    norm_components,
+                                    dev_components,
+                                    spat_dims)
+
+    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)
+
+    use_sim_time = False
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sens_data_norot = pyv.SensorData(positions=sensor_positions,
+                                        sample_times=sample_times)
+
+    sg_array_norot = pyv.SensorArrayPoint(sens_data_norot,
+                                             strain_field,
+                                             descriptor)
+
+    meas_norot = sg_array_norot.get_measurements()
+
+    sens_angles = sensor_positions.shape[0] * \
+        (R.from_euler("zyx", [45, 0, 0], degrees=True),)
+
+    sens_data_rot = pyv.SensorData(positions=sensor_positions,
+                                      sample_times=sample_times,
+                                      angles=sens_angles)
+
+    sg_array_rot = pyv.SensorArrayPoint(sens_data_rot,
+                                           strain_field,
+                                           descriptor)
+
+    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)
+
+    sys_err_rot = pyv.ErrSysField(strain_field,angle_error_data)
+    err_int = pyv.ErrIntegrator([sys_err_rot],
+                                     sens_data_rot,
+                                     sg_array_rot.get_measurement_shape())
+    sg_array_rot.set_error_integrator(err_int)
+
+
+    meas_rot = sg_array_rot.get_measurements()
+
+
+    print(80*'-')
+    sens_num = 4
+    print('The last 5 time steps (measurements) of sensor {sens_num}:')
+    pyv.print_measurements(sg_array_rot,
+                              (sens_num-1,sens_num),
+                              (1,2),
+                              (meas_rot.shape[2]-5,meas_rot.shape[2]))
+    print(80*'-')
+
+    plot_comp = 'strain_yy'
+    pyv.plot_time_traces(sg_array_norot,plot_comp)
+    pyv.plot_time_traces(sg_array_rot,plot_comp)
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/ex5_1_multiphysics2d.py

@@ -0,0 +1,78 @@
+'''
+================================================================================
+Example: thermo-mechanical multiphysics on 2D plate
+
+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 mooseherder as mh
+import pyvale as pyv
+
+
+def main() -> None:
+    """pyvale example: thermo-mechanical multi-physics sensors on a 2D plate
+    ----------------------------------------------------------------------------
+    """
+    #===========================================================================
+    # Load Simulations as mooseherder.SimData objects
+    data_path = pyv.DataSet.thermomechanical_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    # Scale to mm to make 3D visualisation scaling easier
+    sim_data.coords = sim_data.coords*1000.0 # type: ignore
+
+    #===========================================================================
+    # Specify sensor locations and sample times
+    n_sens = (4,1,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,50.0)
+    z_lims = (0.0,0.0)
+    sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    use_sim_time = True
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sens_data = pyv.SensorData(positions=sens_pos,
+                                  sample_times=sample_times)
+
+    #===========================================================================
+    # Create pyvale sensor arrays for thermal and mechanical data
+    tc_field = 'temperature'
+    tc_array = pyv.SensorArrayFactory \
+        .thermocouples_basic_errs(sim_data,
+                                  sens_data,
+                                  tc_field,
+                                  spat_dims=2)
+
+    sg_field = 'strain'
+    sg_array = pyv.SensorArrayFactory \
+        .strain_gauges_basic_errs(sim_data,
+                                  sens_data,
+                                  sg_field,
+                                  spat_dims=2)
+
+    #===========================================================================
+    # Visualise Traces
+    print(80*'-')
+    sens_num = 4
+    print('THERMAL: The last 5 time steps (measurements) of sensor {sens_num}:')
+    pyv.print_measurements(tc_array,
+                              (sens_num-1,sens_num),
+                              (0,1),
+                              (tc_array.get_measurement_shape()[2]-5,
+                               tc_array.get_measurement_shape()[2]))
+    print(80*'-')
+
+    pyv.plot_time_traces(tc_array,"temperature")
+    pyv.plot_time_traces(sg_array,"strain_xx")
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/ex6_1_multiphysics2d_expsim.py

@@ -0,0 +1,118 @@
+'''
+================================================================================
+Example: thermo-mechanical multiphysics on a 2D plate
+
+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 mooseherder as mh
+import pyvale as pyv
+
+def main() -> None:
+    """pyvale example: thermo-mechanical multi-physics sensors on a 2D plate
+    ----------------------------------------------------------------------------
+    - Demonstrates the experiment module for running many monte-carlo style
+      experiments and statistically analysing the results.
+    """
+    # Load Simulations as mooseherder.SimData objects
+    #base_path = Path("src/pyvale/data")
+    data_paths = pyv.DataSet.thermomechanical_2d_experiment_paths()
+
+    sim_list = []
+    for pp in data_paths:
+        sim_data = mh.ExodusReader(pp).read_all_sim_data()
+        # Scale to mm to make 3D visualisation scaling easier
+        sim_data.coords = sim_data.coords*1000.0 # type: ignore
+        sim_list.append(sim_data)
+
+    #===========================================================================
+    # Create pyvale sensor arrays for thermal and mechanical data
+    sim_data = sim_list[0]
+
+    n_sens = (4,1,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,50.0)
+    z_lims = (0.0,0.0)
+    sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    use_sim_time = True
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sens_data = pyv.SensorData(positions=sens_pos,
+                                  sample_times=sample_times)
+
+    tc_field = 'temperature'
+    tc_array = pyv.SensorArrayFactory \
+        .thermocouples_basic_errs(sim_data,
+                                  sens_data,
+                                  tc_field,
+                                  spat_dims=2,
+                                  errs_pc=1.0)
+
+    sg_field = 'strain'
+    sg_array = pyv.SensorArrayFactory \
+        .strain_gauges_basic_errs(sim_data,
+                                  sens_data,
+                                  sg_field,
+                                  spat_dims=2,
+                                  errs_pc=1.0)
+
+    sensor_arrays = [tc_array,sg_array]
+
+    #===========================================================================
+    # Create and run the simulated experiment
+    exp_sim = pyv.ExperimentSimulator(sim_list,
+                                         sensor_arrays,
+                                         num_exp_per_sim=1000)
+
+    exp_data = exp_sim.run_experiments()
+    exp_stats = exp_sim.calc_stats()
+
+    #===========================================================================
+    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*"=")
+
+    #===========================================================================
+    # VISUALISE RESULTS
+    (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/ex6_2_multiphysics3d_expsim.py

@@ -0,0 +1,158 @@
+'''
+================================================================================
+Example: thermo-mechanical multiphysics on a divertor armour heatsink
+
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+'''
+from pathlib import Path
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+def main() -> None:
+    """pyvale example: 3D thermo-mechanical with thermocouples & strain gauges
+    ----------------------------------------------------------------------------
+    """
+    # Load Simulations as mooseherder.SimData objects
+    sim_path = pyv.DataSet.thermomechanical_3d_path()
+    sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
+
+    # Scale to mm to make 3D visualisation scaling easier
+    sim_data.coords = sim_data.coords*1000.0
+    pyv.print_dimensions(sim_data)
+
+    sim_list = [sim_data]
+
+    use_sim_time = True
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    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)
+
+    #---------------------------------------------------------------------------
+    # Create the thermocouple array
+    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)
+
+    tc_field = "temperature"
+    tc_array = pyv.SensorArrayFactory \
+        .thermocouples_basic_errs(sim_data,
+                                  tc_sens_data,
+                                  tc_field,
+                                  spat_dims=3,
+                                  errs_pc=1.0)
+
+    # Visualise the thermocouple locations:
+    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)]
+    pv_plot.save_graphic(fig_save_path/(save_tag+"_tc_vis.svg"))
+    pv_plot.show()
+
+    #---------------------------------------------------------------------------
+    # Create the strain gauge array
+    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)
+
+
+    sg_field = "strain"
+    sg_array = pyv.SensorArrayFactory \
+        .strain_gauges_basic_errs(sim_data,
+                                  sg_sens_data,
+                                  sg_field,
+                                  spat_dims=3,
+                                  errs_pc=1.0)
+
+    # Visualise the strain gauge locations:
+    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)]
+    pv_plot.save_graphic(fig_save_path/(save_tag+"_sg_vis.svg"))
+    pv_plot.show()
+
+    #---------------------------------------------------------------------------
+    # Create and run the simulated experiment
+    sensor_arrays = [tc_array,sg_array]
+
+    exp_sim = pyv.ExperimentSimulator(sim_list,
+                                      sensor_arrays,
+                                      num_exp_per_sim=100)
+
+    exp_data = exp_sim.run_experiments()
+    exp_stats = exp_sim.calc_stats()
+
+    #---------------------------------------------------------------------------
+    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*"=")
+
+    #---------------------------------------------------------------------------
+    # Visualise all sensor traces over all experiments
+    trace_opts = pyv.TraceOptsExperiment(plot_all_exp_points=True)
+
+    (fig,ax) = pyv.plot_exp_traces(exp_sim,
+                                   component="temperature",
+                                   sens_array_num=0,
+                                   sim_num=0,
+                                   trace_opts=trace_opts)
+    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)
+    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/features/__init__.py

@@ -0,0 +1,7 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""

pyvale/examples/features/ex_animation_tools_3dmonoblock.py

@@ -0,0 +1,83 @@
+'''
+================================================================================
+Example: 3d thermocouples on a monoblock
+
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+'''
+from pathlib import Path
+import numpy as np
+import mooseherder as mh
+import pyvale
+
+
+def main() -> None:
+    """pyvale example: visualisation tools 3D
+    """
+    # Use mooseherder to read the exodus and get a SimData object
+    data_path = pyvale.DataSet.thermal_3d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    field_name = 'temperature'
+    # Scale to mm to make 3D visualisation scaling easier
+    sim_data.coords = sim_data.coords*1000.0 # type: ignore
+
+    pyvale.print_dimensions(sim_data)
+
+    n_sens = (1,4,1)
+    x_lims = (12.5,12.5)
+    y_lims = (0,33.0)
+    z_lims = (0.0,12.0)
+    sens_pos = pyvale.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    sens_data = pyvale.SensorData(positions=sens_pos)
+
+    tc_array = pyvale.SensorArrayFactory() \
+        .thermocouples_basic_errs(sim_data,
+                                  sens_data,
+                                  field_name,
+                                  spat_dims=3)
+
+    measurements = tc_array.get_measurements()
+    print(f'\nMeasurements for sensor at top of block:\n{measurements[-1,0,:]}\n')
+
+    vis_opts = pyvale.VisOptsSimSensors()
+    vis_opts.window_size_px = (1200,800)
+    vis_opts.camera_position = np.array([(59.354, 43.428, 69.946),
+                                         (-2.858, 13.189, 4.523),
+                                         (-0.215, 0.948, -0.233)])
+
+    vis_mode = "vector"
+    save_dir = Path.cwd() / "exampleoutput"
+    if not save_dir.is_dir():
+        save_dir.mkdir()
+
+    if vis_mode == "animate":
+        anim_opts = pyvale.VisOptsAnimation()
+
+        anim_opts.save_path = save_dir / "test_animation"
+        anim_opts.save_animation = pyvale.EAnimationType.MP4
+
+        pv_anim = pyvale.animate_sim_with_sensors(tc_array,
+                                                  field_name,
+                                                  time_steps=None,
+                                                  vis_opts=vis_opts,
+                                                  anim_opts=anim_opts)
+
+    else:
+        image_save_opts = pyvale.VisOptsImageSave()
+
+        image_save_opts.path = save_dir / "test_vector_graphics"
+        image_save_opts.image_type = pyvale.EImageType.SVG
+
+        pv_plot = pyvale.plot_point_sensors_on_sim(tc_array,
+                                                field_name,
+                                                time_step=-1,
+                                                vis_opts=vis_opts,
+                                                image_save_opts=image_save_opts)
+        pv_plot.show()
+
+
+if __name__ == '__main__':
+    main()

pyvale/examples/features/ex_area_avg.py

@@ -0,0 +1,89 @@
+"""
+================================================================================
+example: thermocouples on a 2d plate
+
+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 mooseherder as mh
+import pyvale
+
+
+def main() -> None:
+    """pyvale example: thermocouples on a 2d plate
+    ----------------------------------------------------------------------------
+    - Demonstrates area averaging for truth and for systematic errors
+    """
+    data_path = pyvale.DataSet.thermal_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    # Scale to mm to make 3D visualisation scaling easier
+    sim_data.coords = sim_data.coords*1000.0 # type: ignore
+
+    descriptor = pyvale.SensorDescriptorFactory.temperature_descriptor()
+
+    field_key = "temperature"
+    t_field = pyvale.FieldScalar(sim_data,
+                                 field_key=field_key,
+                                 spat_dims=2)
+
+    n_sens = (4,1,1)
+    x_lims = (0.0,100.0)
+    y_lims = (0.0,50.0)
+    z_lims = (0.0,0.0)
+    sens_pos = pyvale.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    use_sim_time = True
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sensor_dims = np.array([10.0,10.0,0])
+    sensor_data = pyvale.SensorData(positions=sens_pos,
+                                    sample_times=sample_times,
+                                    spatial_averager=pyvale.EIntSpatialType.QUAD4PT,
+                                    spatial_dims=sensor_dims)
+
+    tc_array = pyvale.SensorArrayPoint(sensor_data,
+                                       t_field,
+                                       descriptor)
+
+    area_avg_err_data = pyvale.ErrFieldData(
+        spatial_averager=pyvale.EIntSpatialType.RECT1PT,
+        spatial_dims=sensor_dims
+    )
+    err_chain = []
+    err_chain.append(pyvale.ErrSysField(t_field,
+                                        area_avg_err_data))
+    error_int = pyvale.ErrIntegrator(err_chain,
+                                     sensor_data,
+                                     tc_array.get_measurement_shape())
+    tc_array.set_error_integrator(error_int)
+
+    measurements = tc_array.get_measurements()
+
+    print("\n"+80*"-")
+    print("For a 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*"-")
+    print("Looking at the last 5 time steps (measurements) of sensor 0:")
+    pyvale.print_measurements(tc_array,
+                              (0,1),
+                              (0,1),
+                              (0,10))
+    print(80*"-")
+
+    pyvale.plot_time_traces(tc_array,field_key)
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()