pyvale 2025.4.0__py3-none-any.whl → 2025.5.1__py3-none-any.whl

pyvale/core/visualexpplotter.py

@@ -1,151 +0,0 @@
-"""
-================================================================================
-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.visualopts import (PlotOptsGeneral,
-                                   TraceOptsExperiment)
-from pyvale.core.experimentsimulator import ExperimentSimulator
-
-#TODO: Docstrings
-
-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]:
-
-    if trace_opts is None:
-        trace_opts = TraceOptsExperiment()
-
-    if plot_opts is None:
-        plot_opts = PlotOptsGeneral()
-
-    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]
-
-    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_portrait,
-                           layout='constrained')
-    fig.set_dpi(plot_opts.resolution)
-
-    #---------------------------------------------------------------------------
-    # Plot all simulated experimental points
-    if trace_opts.plot_all_exp_points:
-        for ss in 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[ss % plot_opts.n_colors])
-
-    for ss in 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,
-                    lw=plot_opts.lw,
-                    ms=plot_opts.ms,
-                    color=plot_opts.colors[ss % 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,
-                    lw=plot_opts.lw,
-                    ms=plot_opts.ms,
-                    color=plot_opts.colors[ss % 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[ss % 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[ss % 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)
-
-    trace_opts.legend = False
-    if trace_opts.legend:
-        ax.legend(prop={"size":plot_opts.font_leg_size},loc='best')
-
-    plt.grid(True)
-    plt.draw()
-
-    return (fig,ax)

pyvale/core/visualopts.py

@@ -1,180 +0,0 @@
-"""
-================================================================================
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-"""
-from pathlib import Path
-import enum
-from dataclasses import dataclass
-import numpy as np
-import matplotlib as plt
-
-
-@dataclass(slots=True)
-class PlotOptsGeneral:
-    """ Dataclass for controlling the properties of figures and graphs such as
-    figure size, resolution, font sizes, marker sizes, line widths and
-    colormaps.
-    """
-    aspect_ratio: float = 1.62
-    # These are in inches because of matplotlib
-    a4_width: float = 8.25
-    a4_height: float = 11.75
-    a4_margin_width: float = 0.5
-    a4_margin_height: float = 0.5
-    a4_print_width: float = a4_width-2*a4_margin_width
-    a4_print_height: float = a4_height-2*a4_margin_height
-
-    single_fig_scale: float = 0.5
-
-    single_fig_size_square: tuple[float,float] = (
-        a4_print_width*single_fig_scale,
-        a4_print_width*single_fig_scale
-     )
-    single_fig_size_portrait: tuple[float,float] = (
-        a4_print_width*single_fig_scale/aspect_ratio,
-        a4_print_width*single_fig_scale
-     )
-    single_fig_size_landscape: tuple[float,float] = (
-        a4_print_width*single_fig_scale,
-        a4_print_width*single_fig_scale/aspect_ratio
-     )
-
-    resolution: float = 300.0
-
-    font_name: str = 'Liberation Sans'
-    font_def_weight: str = 'normal'
-    font_def_size: float = 8.0
-    font_tick_size: float = 8.0
-    font_head_size: float = 9.0
-    font_ax_size: float = 8.0
-    font_leg_size: float = 8.0
-
-    ms: float = 3.2
-    lw: float = 0.8
-
-    cmap_seq: str = "cividis"
-    cmap_div: str = "RdBu"
-
-    colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
-    n_colors = len(plt.rcParams['axes.prop_cycle'].by_key()['color'])
-
-    def __post_init__(self) -> None:
-        plt.rc('font', size=self.font_def_size)
-        plt.rc('axes', titlesize=self.font_def_size)
-
-
-@dataclass(slots=True)
-class TraceOptsSensor:
-    """Dataclass for controlling the properties of sensor trace plots.
-    """
-    legend: bool = True
-
-    x_label: str = r"x [$m$]"
-    y_label: str = r"y [$m$]"
-    z_label: str = r"z [$m$]"
-    time_label: str = r"Time, $t$ [$s$]"
-
-    truth_line: str | None = "-"
-    sim_line: str | None = "-"
-    meas_line: str = "--o"
-
-    sensors_to_plot: np.ndarray | None = None
-    time_min_max: tuple[float,float] | None = None
-
-
-@dataclass(slots=True)
-class TraceOptsExperiment:
-    """Dataclass for contorlling the properties of sensor trace plots from
-    batches of simulated experiments.
-    """
-    legend: bool = True
-
-    x_label: str = r"x [$m$]"
-    y_label: str = r"y [$m$]"
-    z_label: str = r"z [$m$]"
-    time_label: str = r"Time, $t$ [$s$]"
-
-    truth_line: str | None = None
-    sim_line: str | None = None
-    exp_mean_line: str = "-"
-    exp_marker_line: str = "+"
-
-    sensors_to_plot: np.ndarray | None = None
-    time_min_max: tuple[float,float] | None = None
-
-    centre: str = "mean"
-    plot_all_exp_points: bool = False
-    fill_between: str | None = "3std"
-
-
-@dataclass(slots=True)
-class VisOptsSimSensors:
-    """Dataclass for controlling displays of the simulation mesh and sensor
-    locations using pyvista.
-    """
-    # pyvista ops
-    window_size_px: tuple[int,int] = (1280,800)
-    camera_position: np.ndarray | str = "xy"
-    show_edges: bool = True
-    interactive: bool = True
-
-    font_colour: str = "black"
-    background_colour: str = "white" # "white"
-
-    time_label_font_size: float = 12
-    time_label_position: str = "upper_left"
-    time_label_show: bool = True
-
-    colour_bar_font_size: float = 18
-    colour_bar_show: bool = True
-    colour_bar_lims: tuple[float,float] | None = None
-    colour_bar_vertical: bool = True
-
-    # pyvale ops
-    show_perturbed_pos: bool = True
-    sens_colour_nom: str = "red"
-    sens_colour_pert: str = "blue"
-    sens_point_size: float = 20
-    sens_label_font_size: float = 30
-    sens_label_colour: str = "grey"
-
-
-class EImageType(enum.Enum):
-    PNG = enum.auto()
-    SVG = enum.auto()
-
-@dataclass(slots=True)
-class VisOptsImageSave:
-    """Dataclass for image save options.
-    """
-    path: Path | None = None
-    image_type: EImageType = EImageType.PNG
-    transparent_background: bool = False
-
-
-class EAnimationType(enum.Enum):
-    MP4 = enum.auto()
-    GIF = enum.auto()
-
-@dataclass(slots=True)
-class VisOptsAnimation:
-    """Dataclass for animation save options.
-    """
-    frames_per_second: float = 10.0
-    off_screen: bool = False
-
-    # save options
-    save_animation: EAnimationType | None = None
-    save_path: Path | None = None
-
-
-
-
-
-
-
-
-

pyvale/core/visualsimplotter.py

@@ -1,182 +0,0 @@
-"""
-================================================================================
-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

@@ -1,81 +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 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
-
-