pyvale 2025.4.0__py3-none-any.whl

pyvale/core/visualsimplotter.py

@@ -0,0 +1,182 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+# import vtk #NOTE: has to be here to fix latex bug in pyvista/vtk
+# See: https://github.com/pyvista/pyvista/discussions/2928
+#NOTE: causes output to console to be suppressed unfortunately
+import pyvista as pv
+
+import mooseherder as mh
+
+from pyvale.core.sensorarraypoint import SensorArrayPoint
+from pyvale.core.fieldconverter import simdata_to_pyvista
+from pyvale.core.visualopts import (VisOptsSimSensors,VisOptsImageSave)
+from pyvale.core.visualtools import (create_pv_plotter,
+                                     get_colour_lims,
+                                     save_image)
+
+
+#TODO: Docstrings
+
+def add_sim_field(pv_plot: pv.Plotter,
+                  sensor_array: SensorArrayPoint,
+                  component: str,
+                  time_step: int,
+                  vis_opts: VisOptsSimSensors,
+                  ) -> tuple[pv.Plotter,pv.UnstructuredGrid]:
+
+    sim_vis = sensor_array.field.get_visualiser()
+    sim_data = sensor_array.field.get_sim_data()
+    sim_vis[component] = sim_data.node_vars[component][:,time_step]
+    comp_ind = sensor_array.field.get_component_index(component)
+
+    scalar_bar_args = {"title":sensor_array.descriptor.create_label(comp_ind),
+                        "vertical":vis_opts.colour_bar_vertical,
+                        "title_font_size":vis_opts.colour_bar_font_size,
+                        "label_font_size":vis_opts.colour_bar_font_size}
+
+    pv_plot.add_mesh(sim_vis,
+                     scalars=component,
+                     label="sim-data",
+                     show_edges=vis_opts.show_edges,
+                     show_scalar_bar=vis_opts.colour_bar_show,
+                     scalar_bar_args=scalar_bar_args,
+                     lighting=False,
+                     clim=vis_opts.colour_bar_lims)
+
+    if vis_opts.time_label_show:
+        pv_plot.add_text(f"Time: {sim_data.time[time_step]} " + \
+                            f"{sensor_array.descriptor.time_units}",
+                            position=vis_opts.time_label_position,
+                            font_size=vis_opts.time_label_font_size,
+                            name='time-label')
+
+    return (pv_plot,sim_vis)
+
+
+def add_sensor_points_nom(pv_plot: pv.Plotter,
+                          sensor_array: SensorArrayPoint,
+                          vis_opts: VisOptsSimSensors,
+                          ) -> pv.Plotter:
+
+    vis_sens_nominal = pv.PolyData(sensor_array.sensor_data.positions)
+    vis_sens_nominal["labels"] = sensor_array.descriptor.create_sensor_tags(
+    sensor_array.get_measurement_shape()[0])
+
+    # Add points to show sensor locations
+    pv_plot.add_point_labels(vis_sens_nominal,"labels",
+                            font_size=vis_opts.sens_label_font_size,
+                            shape_color=vis_opts.sens_label_colour,
+                            point_color=vis_opts.sens_colour_nom,
+                            render_points_as_spheres=True,
+                            point_size=vis_opts.sens_point_size,
+                            always_visible=True)
+
+    return pv_plot
+
+
+def add_sensor_points_pert(pv_plot: pv.Plotter,
+                           sensor_array: SensorArrayPoint,
+                           vis_opts: VisOptsSimSensors,
+                           ) -> pv.Plotter:
+
+    sens_data_perturbed = sensor_array.get_sensor_data_perturbed()
+
+    if sens_data_perturbed is not None and vis_opts.show_perturbed_pos:
+        vis_sens_perturbed = pv.PolyData(sens_data_perturbed.positions)
+        vis_sens_perturbed["labels"] = ["",]*sensor_array.get_measurement_shape()[0]
+
+        pv_plot.add_point_labels(vis_sens_perturbed,"labels",
+                                font_size=vis_opts.sens_label_font_size,
+                                shape_color=vis_opts.sens_label_colour,
+                                point_color=vis_opts.sens_colour_pert,
+                                render_points_as_spheres=True,
+                                point_size=vis_opts.sens_point_size,
+                                always_visible=True)
+
+    return pv_plot
+
+
+def plot_sim_mesh(sim_data: mh.SimData,
+                  vis_opts: VisOptsSimSensors | None = None,
+                  ) -> pv.Plotter:
+
+    if vis_opts is None:
+        vis_opts = VisOptsSimSensors()
+
+    pv_simdata = simdata_to_pyvista(sim_data,
+                                         None,
+                                         sim_data.num_spat_dims)
+
+    pv_plot = create_pv_plotter(vis_opts)
+
+    pv_plot.add_mesh(pv_simdata,
+                     label='sim-data',
+                     show_edges=True,
+                     show_scalar_bar=False)
+
+    return pv_plot
+
+
+def plot_sim_data(sim_data: mh.SimData,
+                  component: str,
+                  time_step: int = -1,
+                  vis_opts: VisOptsSimSensors | None = None
+                  ) -> pv.Plotter:
+
+    if vis_opts is None:
+        vis_opts = VisOptsSimSensors()
+
+    pv_simdata = simdata_to_pyvista(sim_data,
+                                        (component,),
+                                         sim_data.num_spat_dims)
+
+    pv_plot = create_pv_plotter(vis_opts)
+
+    pv_plot.add_mesh(pv_simdata,
+                     scalars=pv_simdata[component][:,time_step],
+                     label="sim-data",
+                     show_edges=True,
+                     show_scalar_bar=True,
+                     scalar_bar_args={"title":component},)
+
+
+    return pv_plot
+
+
+def plot_point_sensors_on_sim(sensor_array: SensorArrayPoint,
+                              component: str,
+                              time_step: int = -1,
+                              vis_opts: VisOptsSimSensors | None = None,
+                              image_save_opts: VisOptsImageSave | None = None,
+                              ) -> pv.Plotter:
+
+    if vis_opts is None:
+        vis_opts = VisOptsSimSensors()
+
+    sim_data = sensor_array.field.get_sim_data()
+    vis_opts.colour_bar_lims = get_colour_lims(
+        sim_data.node_vars[component][:,time_step],
+        vis_opts.colour_bar_lims)
+
+    pv_plot = create_pv_plotter(vis_opts)
+
+    pv_plot = add_sensor_points_pert(pv_plot,sensor_array,vis_opts)
+    pv_plot = add_sensor_points_nom(pv_plot,sensor_array,vis_opts)
+    (pv_plot,_) = add_sim_field(pv_plot,
+                                sensor_array,
+                                component,
+                                time_step,
+                                vis_opts)
+
+    pv_plot.camera_position = vis_opts.camera_position
+
+    if image_save_opts is not None:
+        save_image(pv_plot,image_save_opts)
+
+    return pv_plot
+

pyvale/core/visualtools.py

@@ -0,0 +1,81 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from pathlib import Path
+import numpy as np
+#import vtk #NOTE: has to be here to fix latex bug in pyvista/vtk
+# See: https://github.com/pyvista/pyvista/discussions/2928
+#NOTE: causes output to console to be suppressed unfortunately
+import pyvista as pv
+from pyvale.core.visualopts import (VisOptsSimSensors,
+                                    VisOptsImageSave,
+                                    EImageType,
+                                    VisOptsAnimation,
+                                    EAnimationType)
+
+#TODO: Docstrings
+
+def create_pv_plotter(vis_opts: VisOptsSimSensors) -> pv.Plotter:
+    pv_plot = pv.Plotter(window_size=vis_opts.window_size_px)
+    pv_plot.set_background(vis_opts.background_colour)
+    pv.global_theme.font.color = vis_opts.font_colour
+    pv_plot.add_axes_at_origin(labels_off=True)
+    return pv_plot
+
+
+def get_colour_lims(component_data: np.ndarray,
+                     colour_bar_lims: tuple[float,float] | None
+                     ) -> tuple[float,float]:
+
+    if colour_bar_lims is None:
+        min_comp = np.min(component_data.flatten())
+        max_comp = np.max(component_data.flatten())
+        colour_bar_lims = (min_comp,max_comp)
+
+    return colour_bar_lims
+
+
+def save_image(pv_plot: pv.Plotter,
+               image_save_opts: VisOptsImageSave) -> None:
+    if image_save_opts.path is None:
+        image_save_opts.path = Path.cwd() / "pyvale-image"
+
+    if image_save_opts.image_type == EImageType.PNG:
+        image_save_opts.path = image_save_opts.path.with_suffix(".png")
+        pv_plot.screenshot(image_save_opts.path,
+                           image_save_opts.transparent_background)
+
+    elif image_save_opts.image_type == EImageType.SVG:
+        image_save_opts.path = image_save_opts.path.with_suffix(".svg")
+        pv_plot.save_graphic(image_save_opts.path)
+
+
+def set_animation_writer(pv_plot: pv.Plotter,
+                         anim_opts: VisOptsAnimation) -> pv.Plotter:
+    if anim_opts.save_animation is None:
+          return pv_plot
+
+    if anim_opts.save_path is None:
+        anim_opts.save_path = Path.cwd() / "pyvale-animation"
+
+    if anim_opts.save_animation == EAnimationType.GIF:
+        anim_opts.save_path = anim_opts.save_path.with_suffix(".gif")
+        pv_plot.open_gif(anim_opts.save_path,
+                         loop=0,
+                         fps=anim_opts.frames_per_second)
+
+    elif anim_opts.save_animation == EAnimationType.MP4:
+        anim_opts.save_path = anim_opts.save_path.with_suffix(".mp4")
+        print(80*"=")
+        print(f"{anim_opts.save_path=}")
+        print(80*"=")
+        pv_plot.open_movie(anim_opts.save_path,
+                           anim_opts.frames_per_second)
+
+    return pv_plot
+
+

pyvale/core/visualtraceplotter.py

@@ -0,0 +1,256 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from typing import Any
+
+import numpy as np
+import matplotlib.pyplot as plt
+from pyvale.core.sensorarraypoint import SensorArrayPoint
+from pyvale.core.visualopts import (PlotOptsGeneral,
+                                    TraceOptsSensor,
+                                    TraceOptsExperiment)
+from pyvale.core.experimentsimulator import ExperimentSimulator
+
+#TODO: Docstrings
+
+def plot_time_traces(sensor_array: SensorArrayPoint,
+                     component: str,
+                     trace_opts: TraceOptsSensor | None = None,
+                     plot_opts: PlotOptsGeneral | None = None
+                     ) -> tuple[Any,Any]:
+
+    #---------------------------------------------------------------------------
+    field = sensor_array.field
+    comp_ind = sensor_array.field.get_component_index(component)
+    samp_time = sensor_array.get_sample_times()
+    measurements = sensor_array.get_measurements()
+    n_sensors = sensor_array.sensor_data.positions.shape[0]
+    descriptor = sensor_array.descriptor
+    sensors_perturbed = sensor_array.get_sensor_data_perturbed()
+
+    #---------------------------------------------------------------------------
+    if plot_opts is None:
+        plot_opts = PlotOptsGeneral()
+
+    if trace_opts is None:
+        trace_opts = TraceOptsSensor()
+
+    if trace_opts.sensors_to_plot is None:
+        sensors_to_plot = range(n_sensors)
+    else:
+        sensors_to_plot = trace_opts.sensors_to_plot
+
+    #---------------------------------------------------------------------------
+    # Figure canvas setup
+    fig, ax = plt.subplots(figsize=plot_opts.single_fig_size_landscape,
+                           layout='constrained')
+    fig.set_dpi(plot_opts.resolution)
+
+    #---------------------------------------------------------------------------
+    # Plot simulation and truth lines
+    if trace_opts.sim_line is not None:
+        sim_time = field.get_time_steps()
+        sim_vals = field.sample_field(sensor_array.sensor_data.positions,
+                                      None,
+                                      sensor_array.sensor_data.angles)
+
+        for ii,ss in enumerate(sensors_to_plot):
+            ax.plot(sim_time,
+                    sim_vals[ss,comp_ind,:],
+                    trace_opts.sim_line,
+                    lw=plot_opts.lw,
+                    ms=plot_opts.ms,
+                    color=plot_opts.colors[ii % plot_opts.n_colors])
+
+    if trace_opts.truth_line is not None:
+        truth = sensor_array.get_truth()
+        for ii,ss in enumerate(sensors_to_plot):
+            ax.plot(samp_time,
+                    truth[ss,comp_ind,:],
+                    trace_opts.truth_line,
+                    lw=plot_opts.lw,
+                    ms=plot_opts.ms,
+                    color=plot_opts.colors[ii % plot_opts.n_colors])
+
+    sensor_tags = descriptor.create_sensor_tags(n_sensors)
+    for ii,ss in enumerate(sensors_to_plot):
+        sensor_time = samp_time
+        if sensors_perturbed is not None:
+            if sensors_perturbed.sample_times is not None:
+                sensor_time = sensors_perturbed.sample_times
+
+        ax.plot(sensor_time,
+                measurements[ss,comp_ind,:],
+                trace_opts.meas_line,
+                label=sensor_tags[ss],
+                lw=plot_opts.lw,
+                ms=plot_opts.ms,
+                color=plot_opts.colors[ii % plot_opts.n_colors])
+
+    #---------------------------------------------------------------------------
+    # Axis / legend labels and options
+    ax.set_xlabel(trace_opts.time_label,
+                fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+    ax.set_ylabel(descriptor.create_label(comp_ind),
+                fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+    if trace_opts.time_min_max is None:
+        min_time = np.min((np.min(samp_time),np.min(sensor_time)))
+        max_time = np.max((np.max(samp_time),np.max(sensor_time)))
+        ax.set_xlim((min_time,max_time)) # type: ignore
+    else:
+        ax.set_xlim(trace_opts.time_min_max)
+
+    if trace_opts.legend:
+        ax.legend(prop={"size":plot_opts.font_leg_size},loc='best')
+
+    plt.grid(True)
+    plt.draw()
+
+    return (fig,ax)
+
+
+def plot_exp_traces(exp_sim: ExperimentSimulator,
+                    component: str,
+                    sens_array_num: int,
+                    sim_num: int,
+                    trace_opts: TraceOptsExperiment | None = None,
+                    plot_opts: PlotOptsGeneral | None = None) -> tuple[Any,Any]:
+    #---------------------------------------------------------------------------
+    n_sensors = exp_sim.sensor_arrays[sens_array_num].sensor_data.positions.shape[0]
+    descriptor = exp_sim.sensor_arrays[sens_array_num].descriptor
+    comp_ind = exp_sim.sensor_arrays[sens_array_num].field.get_component_index(component)
+    samp_time = exp_sim.sensor_arrays[sens_array_num].get_sample_times()
+    num_sens = exp_sim.sensor_arrays[sens_array_num].get_measurement_shape()[0]
+
+    #---------------------------------------------------------------------------
+    if trace_opts is None:
+        trace_opts = TraceOptsExperiment()
+
+    if plot_opts is None:
+        plot_opts = PlotOptsGeneral()
+
+    #---------------------------------------------------------------------------
+    exp_data = exp_sim.get_data()
+    exp_stats = exp_sim.get_stats()
+
+    if trace_opts.sensors_to_plot is None:
+        sensors_to_plot = range(num_sens)
+    else:
+        sensors_to_plot = trace_opts.sensors_to_plot
+
+    #---------------------------------------------------------------------------
+    # Figure canvas setup
+    fig, ax = plt.subplots(figsize=plot_opts.single_fig_size_landscape,
+                           layout='constrained')
+    fig.set_dpi(plot_opts.resolution)
+
+    #---------------------------------------------------------------------------
+    # Plot all simulated experimental points
+    if trace_opts.plot_all_exp_points:
+        for ii,ss in enumerate(sensors_to_plot):
+            for ee in range(exp_sim.num_exp_per_sim):
+                ax.plot(samp_time,
+                        exp_data[sens_array_num][sim_num,ee,ss,comp_ind,:],
+                        "+",
+                        lw=plot_opts.lw,
+                        ms=plot_opts.ms,
+                        color=plot_opts.colors[ii % plot_opts.n_colors])
+
+    #---------------------------------------------------------------------------
+    sensor_tags = descriptor.create_sensor_tags(n_sensors)
+    for ii,ss in enumerate(sensors_to_plot):
+        if trace_opts.centre == "median":
+            ax.plot(samp_time,
+                    exp_stats[sens_array_num].median[sim_num,ss,comp_ind,:],
+                    trace_opts.exp_mean_line,
+                    label=sensor_tags[ss],
+                    lw=plot_opts.lw,
+                    ms=plot_opts.ms,
+                    color=plot_opts.colors[ii % plot_opts.n_colors])
+        else:
+            ax.plot(samp_time,
+                    exp_stats[sens_array_num].mean[sim_num,ss,comp_ind,:],
+                    trace_opts.exp_mean_line,
+                    label=sensor_tags[ss],
+                    lw=plot_opts.lw,
+                    ms=plot_opts.ms,
+                    color=plot_opts.colors[ii % plot_opts.n_colors])
+
+        if trace_opts is not None:
+            upper = np.zeros_like(exp_stats[sens_array_num].min)
+            lower = np.zeros_like(exp_stats[sens_array_num].min)
+
+            if trace_opts.fill_between == 'max':
+                upper = exp_stats[sens_array_num].min
+                lower = exp_stats[sens_array_num].max
+
+            elif trace_opts.fill_between == 'quartile':
+                upper = exp_stats[sens_array_num].q25
+                lower = exp_stats[sens_array_num].q75
+
+            elif trace_opts.fill_between == '2std':
+                upper = exp_stats[sens_array_num].mean + \
+                        2*exp_stats[sens_array_num].std
+                lower = exp_stats[sens_array_num].mean - \
+                        2*exp_stats[sens_array_num].std
+
+            elif trace_opts.fill_between == '3std':
+                upper = exp_stats[sens_array_num].mean + \
+                        3*exp_stats[sens_array_num].std
+                lower = exp_stats[sens_array_num].mean - \
+                        3*exp_stats[sens_array_num].std
+
+            ax.fill_between(samp_time,
+                upper[sim_num,ss,comp_ind,:],
+                lower[sim_num,ss,comp_ind,:],
+                color=plot_opts.colors[ii % plot_opts.n_colors],
+                alpha=0.2)
+
+    #---------------------------------------------------------------------------
+    # Plot simulation and truth line
+    if trace_opts.sim_line is not None:
+        sim_time = exp_sim.sensor_arrays[sens_array_num].field.get_time_steps()
+        sim_vals = exp_sim.sensor_arrays[sens_array_num].field.sample_field(
+                    exp_sim.sensor_arrays[sens_array_num].positions)
+
+        for ss in sensors_to_plot:
+            ax.plot(sim_time,
+                    sim_vals[ss,comp_ind,:],
+                    trace_opts.sim_line,
+                    lw=plot_opts.lw,
+                    ms=plot_opts.ms)
+
+    if trace_opts.truth_line is not None:
+        truth = exp_sim.sensor_arrays[sens_array_num].get_truth()
+        for ss in sensors_to_plot:
+            ax.plot(samp_time,
+                    truth[ss,comp_ind,:],
+                    trace_opts.truth_line,
+                    lw=plot_opts.lw,
+                    ms=plot_opts.ms,
+                    color=plot_opts.colors[ii % plot_opts.n_colors])
+
+    #---------------------------------------------------------------------------
+    # Axis / legend labels and options
+    ax.set_xlabel(trace_opts.time_label,
+                fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+    ax.set_ylabel(descriptor.create_label(comp_ind),
+                fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+    if trace_opts.time_min_max is None:
+        ax.set_xlim((np.min(samp_time),np.max(samp_time))) # type: ignore
+    else:
+        ax.set_xlim(trace_opts.time_min_max)
+
+    if trace_opts.legend:
+        ax.legend(prop={"size":plot_opts.font_leg_size},loc='best')
+
+    plt.grid(True)
+    plt.draw()
+
+    return (fig,ax)

pyvale/data/__init__.py

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

pyvale/examples/__init__.py

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

pyvale/examples/analyticdatagen/__init__.py

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

pyvale/examples/analyticdatagen/ex1_1_scalarvisualisation.py

@@ -0,0 +1,38 @@
+'''
+================================================================================
+Analytic test case data - linear
+
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+'''
+import matplotlib.pyplot as plt
+import pyvale
+
+def main() -> None:
+
+    (sim_data,data_gen) = pyvale.AnalyticCaseFactory.scalar_linear_2d()
+
+    (grid_x,grid_y,grid_field) = data_gen.get_visualisation_grid()
+
+    fig, ax = plt.subplots()
+    cs = ax.contourf(grid_x,grid_y,grid_field)
+    cbar = fig.colorbar(cs)
+    plt.axis('scaled')
+
+
+    (sim_data,data_gen) = pyvale.AnalyticCaseFactory.scalar_quadratic_2d()
+
+    (grid_x,grid_y,grid_field) = data_gen.get_visualisation_grid()
+
+    fig, ax = plt.subplots()
+    cs = ax.contourf(grid_x,grid_y,grid_field)
+    cbar = fig.colorbar(cs)
+    plt.axis('scaled')
+
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()

pyvale/examples/analyticdatagen/ex1_2_scalarcasebuild.py

@@ -0,0 +1,46 @@
+'''
+================================================================================
+Analytic test case data - linear
+
+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
+import pyvale
+
+def main() -> None:
+
+    case_data = pyvale.AnalyticCaseData2D()
+    case_data.length_x = 10.0
+    case_data.length_y = 7.5
+    n_elem_mult = 10
+    case_data.num_elem_x = 4*n_elem_mult
+    case_data.num_elem_y = 3*n_elem_mult
+    case_data.time_steps = np.linspace(0.0,1.0,11)
+
+    (sym_y,sym_x,sym_t) = sympy.symbols("y,x,t")
+    case_data.funcs_x = (25.0 * sympy.sin(2*sympy.pi*sym_x/case_data.length_x),)
+    case_data.funcs_y = (10.0/case_data.length_y * sym_y,)
+    case_data.funcs_t = (sym_t,)
+    case_data.offsets_space = (20.0,)
+    case_data.offsets_time = (0.0,)
+
+
+    data_gen = pyvale.AnalyticSimDataGenerator(case_data)
+    sim_data = data_gen.generate_sim_data()
+
+    (grid_x,grid_y,grid_field) = data_gen.get_visualisation_grid()
+
+    fig, ax = plt.subplots()
+    cs = ax.contourf(grid_x,grid_y,grid_field)
+    cbar = fig.colorbar(cs)
+    plt.axis('scaled')
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()