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

pyvale/examples/ex6_2_multiphysics3d_expsim.py

@@ -1,160 +0,0 @@
-# ================================================================================
-# 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_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)
-
-    #---------------------------------------------------------------------------
-    # 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)]
-    if save_figs:
-        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)]
-    if save_figs:
-        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)
-    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/features/__init__.py

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

pyvale/examples/features/ex_area_avg.py

@@ -1,89 +0,0 @@
-"""
-================================================================================
-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()

pyvale/examples/features/ex_calibration_error.py

@@ -1,108 +0,0 @@
-'''
-================================================================================
-DEV: calibration check
-
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-'''
-import matplotlib.pyplot as plt
-import numpy as np
-import mooseherder as mh
-import pyvale
-
-
-def assumed_calib(signal: np.ndarray) -> np.ndarray:
-    return 24.3*signal + 0.616
-
-
-def truth_calib(signal: np.ndarray) -> np.ndarray:
-    return -0.01897 + 25.41881*signal - 0.42456*signal**2 + 0.04365*signal**3
-
-
-def main() -> None:
-    """pyvale example: sensor calibration error
-    Based on K-type thermocouple calibration
-    """
-    n_divs = 10000
-    signal_calib_range = np.array((0,6))
-    v = np.linspace(signal_calib_range[0],signal_calib_range[1],n_divs)
-
-    temp_truth = -0.01897 + 25.41881*v - 0.42456*v**2 + 0.04365*v**3
-    temp_assumed = 24.3*v + 0.616
-    calib_error = temp_assumed - temp_truth
-    print()
-    print(80*"-")
-    print(f"Calibration error over signal:"+\
-          f" {signal_calib_range[0]} to {signal_calib_range[1]} mV")
-    print(calib_error)
-    print(f"Max calib error: {np.max(calib_error)}")
-    print(f"Min calib error: {np.min(calib_error)}")
-    print()
-
-    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
-
-    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 = False
-    if use_sim_time:
-        sample_times = None
-    else:
-        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
-
-    sens_data = pyvale.SensorData(positions=sens_pos,
-                                  sample_times=sample_times)
-
-    tc_array = pyvale.SensorArrayPoint(sens_data,
-                                       t_field,
-                                       descriptor)
-
-    cal_err = pyvale.ErrSysCalibration(assumed_calib,
-                                        truth_calib,
-                                        signal_calib_range,
-                                        n_cal_divs=10000)
-    sys_err_int = pyvale.ErrIntegrator([cal_err],
-                                       sens_data,
-                                       tc_array.get_measurement_shape())
-    tc_array.set_error_integrator(sys_err_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),
-                              (measurements.shape[2]-5,measurements.shape[2]))
-    print(80*'-')
-
-    pyvale.plot_time_traces(tc_array,field_key)
-    plt.show()
-
-
-
-
-if __name__ == "__main__":
-    main()

pyvale/examples/features/ex_chain_field_errs.py

@@ -1,141 +0,0 @@
-"""
-================================================================================
-example: displacement 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
-import mooseherder as mh
-import pyvale
-
-def main() -> None:
-    data_path = pyvale.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 = pyvale.SensorDescriptorFactory.displacement_descriptor()
-
-    spat_dims = 2
-    field_key = "disp"
-    components = ("disp_x","disp_y")
-    disp_field = pyvale.FieldVector(sim_data,field_key,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 = 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_data = pyvale.SensorData(positions=sensor_positions,
-                                    sample_times=sample_times)
-
-    disp_sens_array = pyvale.SensorArrayPoint(sensor_data,
-                                              disp_field,
-                                              descriptor)
-
-    pos_offset = -1.0*np.ones_like(sensor_positions)
-    pos_offset[:,2] = 0 # in 2d we only have offset in x and y so zero z
-    pos_error_data = pyvale.ErrFieldData(pos_offset_xyz=pos_offset)
-
-    angle_offset = np.zeros_like(sensor_positions)
-    angle_offset[:,0] = 1.0 # only rotate about z in 2D
-    angle_error_data = pyvale.ErrFieldData(ang_offset_zyx=angle_offset)
-
-    time_offset = 2.0*np.ones_like(disp_sens_array.get_sample_times())
-    time_error_data = pyvale.ErrFieldData(time_offset=time_offset)
-
-    field_errs = []
-    field_errs.append(pyvale.ErrSysField(disp_field,
-                                         time_error_data))
-    field_errs.append(pyvale.ErrSysField(disp_field,
-                                        time_error_data))
-
-    field_errs.append(pyvale.ErrSysField(disp_field,
-                                        pos_error_data))
-    field_errs.append(pyvale.ErrSysField(disp_field,
-                                        pos_error_data))
-
-    field_errs.append(pyvale.ErrSysField(disp_field,
-                                        angle_error_data))
-    field_errs.append(pyvale.ErrSysField(disp_field,
-                                        angle_error_data))
-
-    err_int_opts = pyvale.ErrIntOpts(force_dependence=True,
-                                     store_all_errs=True)
-    error_int = pyvale.ErrIntegrator(field_errs,
-                                     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()
-
-    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*"-")
-
-    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*"=")
-
-    print(80*"-")
-    sens_num = 4
-    print("The last 5 time steps (measurements) of sensor {sens_num}:")
-    pyvale.print_measurements(disp_sens_array,
-                              (sens_num-1,sens_num),
-                              (0,1),
-                              (measurements.shape[2]-5,measurements.shape[2]))
-    print(80*"-")
-
-    plot_field = "disp_x"
-
-    if plot_field == "disp_x":
-        pv_plot = pyvale.plot_point_sensors_on_sim(disp_sens_array,"disp_x")
-        pv_plot.show()
-    elif plot_field == "disp_y":
-        pv_plot = pyvale.plot_point_sensors_on_sim(disp_sens_array,"disp_y")
-        pv_plot.show()
-
-    pyvale.plot_time_traces(disp_sens_array,"disp_x")
-    pyvale.plot_time_traces(disp_sens_array,"disp_y")
-    plt.show()
-
-
-if __name__ == "__main__":
-    main()

pyvale/examples/features/ex_field_errs.py

@@ -1,78 +0,0 @@
-'''
-================================================================================
-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: point sensors on a 2D thermal simulation
-    ----------------------------------------------------------------------------
-    """
-    data_path = pyvale.DataSet.thermal_2d_path()
-    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
-    field_key = list(sim_data.node_vars.keys())[0] # type: ignore
-    # Scale to mm to make 3D visualisation scaling easier
-    sim_data.coords = sim_data.coords*1000.0 # type: ignore
-
-    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)
-
-    sample_times = np.linspace(0.0,np.max(sim_data.time),50) # | None
-
-    sensor_data = pyvale.SensorData(positions=sens_pos,
-                                    sample_times=sample_times)
-
-    tc_array = pyvale.SensorArrayFactory \
-        .thermocouples_no_errs(sim_data,
-                               sensor_data,
-                               field_key,
-                               spat_dims=2)
-
-    #---------------------------------------------------------------------------
-    # Standard independent systematic errors
-    pos_rand = pyvale.GeneratorNormal(std=1.0) # mm
-    pos_lock = np.full_like(sensor_data.positions,False,dtype=bool)
-    pos_lock[:,2] = True
-    field_err_data = pyvale.ErrFieldData(
-        pos_rand_xyz=(pos_rand,pos_rand,pos_rand),
-        pos_lock_xyz=pos_lock
-    )
-
-    err_chain = []
-    err_chain.append(pyvale.ErrSysField(tc_array.get_field(),
-                                        field_err_data))
-    err_int = pyvale.ErrIntegrator(err_chain,
-                                   sensor_data,
-                                   tc_array.get_measurement_shape())
-    tc_array.set_error_integrator(err_int)
-
-
-    #---------------------------------------------------------------------------
-    measurements = tc_array.calc_measurements()
-    print(80*'-')
-    sens_num = 4
-    print('The last 5 time steps (measurements) of sensor {sens_num}:')
-    pyvale.print_measurements(tc_array,
-                              (sens_num-1,sens_num),
-                              (0,1),
-                              (measurements.shape[2]-5,measurements.shape[2]))
-    print(80*'-')
-
-    pyvale.plot_time_traces(tc_array,field_key)
-    plt.show()
-
-
-if __name__ == '__main__':
-    main()

pyvale/examples/features/ex_sensor_single_angle_batch.py

@@ -1,110 +0,0 @@
-"""
-================================================================================
-Example: displacement 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
-import mooseherder as mh
-import pyvale
-
-def main() -> None:
-    """pyvale example: single rotation batch processing
-    ----------------------------------------------------------------------------
-    - Tests that when only one sensor rotation is provided that
-      all sensors are assumed to have the same rotation and batch processed.
-    """
-    data_path = pyvale.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 = pyvale.SensorDescriptorFactory.displacement_descriptor()
-
-    spat_dims = 2
-    field_key = "disp"
-    components = ("disp_x","disp_y")
-    disp_field = pyvale.FieldVector(sim_data,field_key,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 = pyvale.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)
-
-    # Provide only a single rotation for the 6 sensors
-    sensor_angles = (Rotation.from_euler("zyx", [180, 0, 0], degrees=True),)
-
-    sensor_data_norot = pyvale.SensorData(positions=sensor_positions,
-                                          sample_times=sample_times)
-
-
-    sensor_data_rot = pyvale.SensorData(positions=sensor_positions,
-                                  sample_times=sample_times,
-                                  angles=sensor_angles)
-
-    #---------------------------------------------------------------------------
-    disp_sensors_norot = pyvale.SensorArrayPoint(sensor_data_norot,
-                                                disp_field,
-                                                descriptor)
-
-
-    disp_sensors_rot = pyvale.SensorArrayPoint(sensor_data_rot,
-                                               disp_field,
-                                               descriptor)
-
-
-
-    measurements_norot = disp_sensors_norot.calc_measurements()
-    measurements_rot = disp_sensors_rot.calc_measurements()
-
-    #---------------------------------------------------------------------------
-    sens_to_print = 1
-    print(80*"-")
-    print(f"The last 5 time steps (measurements) of non-rotated sensor {sens_to_print}:")
-    pyvale.print_measurements(disp_sensors_norot,
-                              (sens_to_print-1,sens_to_print),
-                              (0,1),
-                              (measurements_norot.shape[2]-5,measurements_norot.shape[2]))
-    print(80*"-")
-    print(f"The last 5 time steps (measurements) of rotated sensor {sens_to_print}:")
-    pyvale.print_measurements(disp_sensors_rot,
-                              (sens_to_print-1,sens_to_print),
-                              (0,1),
-                              (measurements_rot.shape[2]-5,measurements_rot.shape[2]))
-    print(80*"-")
-
-    #---------------------------------------------------------------------------
-    plot_field = "disp_x"
-
-    if plot_field == "disp_x":
-        pv_plot = pyvale.plot_point_sensors_on_sim(disp_sensors_rot,"disp_x")
-        pv_plot.show(cpos="xy")
-    elif plot_field == "disp_y":
-        pv_plot = pyvale.plot_point_sensors_on_sim(disp_sensors_rot,"disp_y")
-        pv_plot.show(cpos="xy")
-
-    (fig,ax) = pyvale.plot_time_traces(disp_sensors_norot,plot_field)
-    ax.set_title("No rotation")
-    (fig,ax) = pyvale.plot_time_traces(disp_sensors_rot,plot_field)
-    ax.set_title("Rotated")
-    plt.show()
-
-
-if __name__ == "__main__":
-    main()