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

pyvale/core/experimentsimulator.py

@@ -1,99 +0,0 @@
-"""
-================================================================================
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-"""
-from dataclasses import dataclass
-import numpy as np
-from pyvale.core.sensorarray import ISensorArray
-import mooseherder as mh
-
-# NOTE: This module is a feature under developement.
-
-@dataclass(slots=True)
-class ExperimentStats:
-    """Dataclass holding summary statistics for a series of simulated
-    experiments.
-    """
-    mean: np.ndarray | None = None
-    std: np.ndarray | None = None
-    cov: np.ndarray | None = None
-    max: np.ndarray | None = None
-    min: np.ndarray | None = None
-    med: np.ndarray | None = None
-    q25: np.ndarray | None = None
-    q75: np.ndarray | None = None
-    mad: np.ndarray | None = None
-
-
-class ExperimentSimulator:
-    """An experiment simulator for running monte-carlo analysis by applying a
-    list of sensor arrays to a list of simulations over a given number of user
-    defined experiments. Calculates summary statistics for each sensor array
-    applied to each simulation.
-    """
-    __slots__ = ("sim_list","sensor_arrays","num_exp_per_sim","_exp_data",
-                 "_exp_stats")
-
-    def __init__(self,
-                 sim_list: list[mh.SimData],
-                 sensor_arrays: list[ISensorArray],
-                 num_exp_per_sim: int
-                 ) -> None:
-
-        self.sim_list = sim_list
-        self.sensor_arrays = sensor_arrays
-        self.num_exp_per_sim = num_exp_per_sim
-        self._exp_data = [None]*len(self.sensor_arrays)
-        self._exp_stats = [None]*len(self.sensor_arrays)
-
-    def get_data(self) -> list[np.ndarray | None]:
-        return self._exp_data
-
-    def get_stats(self) -> list[np.ndarray | None]:
-        return self._exp_stats
-
-    def run_experiments(self) -> list[np.ndarray]:
-        n_sims = len(self.sim_list)
-        # shape=list[n_arrays](n_sims,n_exps,n_sens,n_comps,n_time_steps)
-        self._exp_data = [None]*len(self.sensor_arrays)
-
-        for ii,aa in enumerate(self.sensor_arrays):
-            meas_array = np.zeros((n_sims,self.num_exp_per_sim)+
-                                aa.get_measurement_shape())
-
-            for jj,ss in enumerate(self.sim_list):
-                aa.get_field().set_sim_data(ss)
-
-                for ee in range(self.num_exp_per_sim):
-                    meas_array[jj,ee,:,:,:] = aa.calc_measurements()
-
-            self._exp_data[ii] = meas_array
-
-        return self._exp_data
-
-
-    def calc_stats(self) -> list[ExperimentStats]:
-        # shape=list[n_arrays](n_sims,n_exps,n_sens,n_comps,n_time_steps)
-        self._exp_stats = [None]*len(self.sensor_arrays)
-        for ii,_ in enumerate(self.sensor_arrays):
-            array_stats = ExperimentStats()
-            array_stats.max = np.max(self._exp_data[ii],axis=1)
-            array_stats.min = np.min(self._exp_data[ii],axis=1)
-            array_stats.mean = np.mean(self._exp_data[ii],axis=1)
-            array_stats.std = np.std(self._exp_data[ii],axis=1)
-            array_stats.med = np.median(self._exp_data[ii],axis=1)
-            array_stats.q25 = np.quantile(self._exp_data[ii],0.25,axis=1)
-            array_stats.q75 = np.quantile(self._exp_data[ii],0.75,axis=1)
-            array_stats.mad = np.median(np.abs(self._exp_data[ii] -
-                np.median(self._exp_data[ii],axis=1,keepdims=True)),axis=1)
-            self._exp_stats[ii] = array_stats
-
-        return self._exp_stats
-
-
-
-
-

pyvale/core/fieldconverter.py

@@ -1,154 +0,0 @@
-"""
-================================================================================
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-"""
-import warnings
-import numpy as np
-import pyvista as pv
-from pyvista import CellType
-import mooseherder as mh
-
-
-def simdata_to_pyvista(sim_data: mh.SimData,
-                        components: tuple[str,...] | None,
-                        spat_dim: int
-                        ) -> tuple[pv.UnstructuredGrid,pv.UnstructuredGrid]:
-    """Converts the mesh and field data in a `SimData` object into a pyvista
-    UnstructuredGrid for sampling (interpolating) the data and visualisation.
-
-    Parameters
-    ----------
-    sim_data : mh.SimData
-        Object containing a mesh and associated field data from a simulation.
-    components : tuple[str,...] | None
-        String keys for the components of the field to extract from the
-        simulation data.
-    spat_dim : int
-        Number of spatial dimensions (2 or 3) used to determine the element
-        types in the mesh from the number of nodes per element.
-
-    Returns
-    -------
-    tuple[pv.UnstructuredGrid,pv.UnstructuredGrid]
-        The first UnstructuredGrid has the field components attached as dataset
-        arrays. The second has no field data attached for visualisation.
-    """
-    flat_connect = np.array([],dtype=np.int64)
-    cell_types = np.array([],dtype=np.int64)
-
-    for cc in sim_data.connect:
-        # NOTE: need the -1 here to make element numbers 0 indexed!
-        this_connect = np.copy(sim_data.connect[cc])-1
-        (nodes_per_elem,n_elems) = this_connect.shape
-
-        this_cell_type = _get_pyvista_cell_type(nodes_per_elem,spat_dim)
-
-        # VTK and exodus have different winding for 3D higher order quads
-        this_connect = _exodus_to_pyvista_connect(this_cell_type,this_connect)
-
-        this_connect = this_connect.T.flatten()
-        idxs = np.arange(0,n_elems*nodes_per_elem,nodes_per_elem,dtype=np.int64)
-
-        this_connect = np.insert(this_connect,idxs,nodes_per_elem)
-
-        cell_types = np.hstack((cell_types,np.full(n_elems,this_cell_type)))
-        flat_connect = np.hstack((flat_connect,this_connect),dtype=np.int64)
-
-    cells = flat_connect
-
-    points = sim_data.coords
-    pv_grid = pv.UnstructuredGrid(cells, cell_types, points)
-    pv_grid_vis = pv.UnstructuredGrid(cells, cell_types, points)
-
-    if components is not None and sim_data.node_vars is not None:
-        for cc in components:
-            pv_grid[cc] = sim_data.node_vars[cc]
-
-    return (pv_grid,pv_grid_vis)
-
-
-def _get_pyvista_cell_type(nodes_per_elem: int, spat_dim: int) -> CellType:
-    """Helper function to identify the pyvista element type in the mesh.
-
-    Parameters
-    ----------
-    nodes_per_elem : int
-        Number of nodes per element.
-    spat_dim : int
-        Number of spatial dimensions in the mesh (2 or 3).
-
-    Returns
-    -------
-    CellType
-        Enumeration describing the element type in pyvista.
-    """
-    cell_type = 0
-
-    if spat_dim == 2:
-        if nodes_per_elem == 4:
-            cell_type = CellType.QUAD
-        elif nodes_per_elem == 3:
-            cell_type = CellType.TRIANGLE
-        elif nodes_per_elem == 6:
-            cell_type = CellType.QUADRATIC_TRIANGLE
-        elif nodes_per_elem == 7:
-            cell_type = CellType.BIQUADRATIC_TRIANGLE
-        elif nodes_per_elem == 8:
-            cell_type = CellType.QUADRATIC_QUAD
-        elif nodes_per_elem == 9:
-            cell_type = CellType.BIQUADRATIC_QUAD
-        else:
-            warnings.warn(f"Cell type 2D with {nodes_per_elem} "
-                          + "nodes not recognised. Defaulting to 4 node QUAD")
-            cell_type = CellType.QUAD
-    else:
-        if nodes_per_elem == 8:
-            cell_type =  CellType.HEXAHEDRON
-        elif nodes_per_elem == 4:
-            cell_type = CellType.TETRA
-        elif nodes_per_elem == 10:
-            cell_type = CellType.QUADRATIC_TETRA
-        elif nodes_per_elem == 20:
-            cell_type = CellType.QUADRATIC_HEXAHEDRON
-        elif nodes_per_elem == 27:
-            cell_type = CellType.TRIQUADRATIC_HEXAHEDRON
-        else:
-            warnings.warn(f"Cell type 3D with {nodes_per_elem} "
-                + "nodes not recognised. Defaulting to 8 node HEX")
-            cell_type = CellType.HEXAHEDRON
-
-    return cell_type
-
-
-def _exodus_to_pyvista_connect(cell_type: CellType, connect: np.ndarray) -> np.ndarray:
-    copy_connect = np.copy(connect)
-
-    # NOTE: it looks like VTK does not support TET14
-    # VTK and exodus have different winding for 3D higher order quads
-    if cell_type == CellType.QUADRATIC_HEXAHEDRON:
-        connect[12:16,:] = copy_connect[16:20,:]
-        connect[16:20,:] = copy_connect[12:16,:]
-    elif cell_type == CellType.TRIQUADRATIC_HEXAHEDRON:
-        connect[12:16,:] = copy_connect[16:20,:]
-        connect[16:20,:] = copy_connect[12:16,:]
-        connect[20:24,:] = copy_connect[23:27,:]
-        connect[24,:] = copy_connect[21,:]
-        connect[25,:] = copy_connect[22,:]
-        connect[26,:] = copy_connect[20,:]
-
-    return connect
-
-def scale_length_units(sim_data: mh.SimData,
-                       disp_comps: tuple[str,...],
-                       scale: float) -> mh.SimData:
-
-    sim_data.coords = sim_data.coords*scale
-    for cc in disp_comps:
-        sim_data.node_vars[cc] = sim_data.node_vars[cc]*scale
-
-    return sim_data
-
-

pyvale/core/integratorrectangle.py

@@ -1,88 +0,0 @@
-"""
-================================================================================
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-"""
-import numpy as np
-from pyvale.core.field import IField
-from pyvale.core.integratorspatial import (IIntegratorSpatial,
-                                           create_int_pt_array)
-from pyvale.core.sensordata import SensorData
-
-
-#TODO: Docstrings
-
-#NOTE: code below is very similar to quadrature integrator should be able to
-# refactor into injected classes/functions
-
-class Rectangle2D(IIntegratorSpatial):
-    __slots__ = ("_field","sens_data","_area","_area_int","_n_int_pts",
-                 "_int_pt_offsets","_int_pts","_averages")
-
-    def __init__(self,
-                 field: IField,
-                 sens_data: SensorData,
-                 int_pt_offsets: np.ndarray) -> None:
-
-        self._field = field
-        self._sens_data = sens_data
-
-        self._area = (self._sens_data.spatial_dims[0]
-                      * self._sens_data.spatial_dims[1])
-        self._area_int = self._area/int_pt_offsets.shape[0]
-
-        self._n_int_pts = int_pt_offsets.shape[0]
-        self._int_pt_offsets = int_pt_offsets
-        self._int_pts = create_int_pt_array(self._sens_data,
-                                            self._int_pt_offsets)
-
-        self._averages = None
-
-
-    def calc_integrals(self, sens_data: SensorData | None = None) -> np.ndarray:
-        self._averages = self.calc_averages(sens_data)
-        return self._area*self.get_averages()
-
-
-    def get_integrals(self) -> np.ndarray:
-        return self._area*self.get_averages()
-
-    def calc_averages(self, sens_data: SensorData | None = None) -> np.ndarray:
-
-        if sens_data is not None:
-            self._sens_data = sens_data
-
-        # shape=(n_sens*n_int_pts,n_dims)
-        self._int_pts = create_int_pt_array(self._sens_data,
-                                            self._int_pt_offsets)
-
-
-        # shape=(n_int_pts*n_sens,n_comps,n_timesteps)
-        int_vals = self._field.sample_field(self._int_pts,
-                                            self._sens_data.sample_times,
-                                            self._sens_data.angles)
-
-        meas_shape = (self._sens_data.positions.shape[0],
-                      int_vals.shape[1],
-                      int_vals.shape[2])
-
-        # shape=(n_gauss_pts,n_sens,n_comps,n_timesteps)
-        int_vals = int_vals.reshape((self._n_int_pts,)+meas_shape,
-                                     order='F')
-
-        # shape=(n_sensors,n_comps,n_timsteps)
-        self._averages = 1/self._area * np.sum(self._area_int*int_vals,axis=0)
-
-        return self._averages
-
-
-    def get_averages(self) -> np.ndarray:
-        if self._averages is None:
-            self._averages = self.calc_averages()
-
-        return self._averages
-
-
-

pyvale/core/optimcheckfuncs.py

@@ -1,153 +0,0 @@
-"""
-OPTIMISATION TEST FUNCTIONS - N DIMS
-https://gist.github.com/denis-bz/da697d8bc74fae4598bf
-https://www.sfu.ca/~ssurjano/optimization.html
-https://en.wikipedia.org/wiki/Test_functions_for_optimization
-"""
-from typing import Callable,Any
-import numpy as np
-import matplotlib.pyplot as plt
-from pyvale.core.visualopts import PlotOptsGeneral
-
-
-def ackley(x: np.ndarray,
-             a: float = 20.0,
-             b: float = 0.2,
-             c: float = 2*np.pi) -> np.ndarray:
-    """ACKLEY
-    Dimension: N
-    Local Minima: many
-    Global Minimum: f(x) = 0 @ (0,0,....,0)
-    Eval: [-32.768,32.768] or smaller
-    """
-    n = x.shape[1]
-    sum1 = np.sum(x**2,axis=1)
-    sum2 = np.sum(np.cos(c*x),axis=1)
-    f =  -a*np.exp(-b*np.sqrt(sum1/n)) - np.exp(sum2/n) + a + np.exp(1)
-    return f
-
-
-def dixonprice(x: np.ndarray) -> np.ndarray:
-    """DIXON-PRICE
-    Dimension: N
-    Local Minima: Large valley
-    Global Minimum: f(x) = 0 @ x_i = 2^-((2^i-2)/2^i) for i = 1,...,d
-    Eval: [-10.0,10.0] or smaller
-    """
-    n = x.shape[1]
-    j = np.arange( 2, n+1 )
-    x2 = 2 * x**2
-    f = np.sum( j * (x2[:,1:] - x[:,:-1]) **2, axis=1) + (x[:,0] - 1) **2
-    return f
-
-
-def griewank(x: np.ndarray, div: float = 4000.0) -> np.ndarray:
-    """GRIEWANK
-    Dimension: N
-    Local Minima: many
-    Global Minimum: f(x) = 0 @ (0,0,....,0)
-    Eval: [-600,600] or smaller
-    """
-    n = x.shape[1]
-    j = np.arange( 1., n+1 )
-    sum1 = np.sum( x**2, axis=1 )
-    p = np.prod( np.cos( x / np.sqrt(j) ), axis=1)
-    f = sum1/div - p + 1
-    return f
-
-
-def rastrigin(x: np.ndarray, a: float = 10) -> np.ndarray:
-    """RASTRIGIN
-    Dimension: N
-    Local Minima: many
-    Global Minimum: f(x) = 0 @ (0,0,....,0)
-    Eval: [-5.12,5.12] or smaller
-    """
-    n = x.shape[1]
-    sum1 = np.sum(x**2 - a*np.cos(2*np.pi*x),axis=1)
-    f = a*n + sum1
-    return f
-
-
-def rosenbrock(x: np.ndarray, a: float = 100) -> float:
-    """ROSENBROCK
-    Dimension: N
-    Local Minima: Large valley
-    Global minimum: at (x,y) = (1,1) where f(x,y)=0
-    Eval: [-5.0,10.0] or smaller
-    """
-    x0 = x[:,:-1] # x_(i) ... to n-1
-    x1 = x[:,1:]  # x_(i+1) ... to n-1
-    f = a*np.sum((x1-x0**2)**2,axis=1) + np.sum((1-x0)**2, axis=1)
-    return f
-
-
-def sphere(x: np.ndarray) -> np.ndarray:
-    """SPHERE
-    Dimension: N
-    Local Minima: none
-    Global minimum: f(x) = 0 @ (0,0,....,0)
-    Eval: [-inf,inf] or smaller
-    """
-    f = np.sum(x**2,axis=1)
-    return f
-
-
-def get_mesh_x_2d(xlim1: tuple[float,float],
-                  xlim2: tuple[float,float],
-                  n: int = 100):
-    xv1 = np.linspace(xlim1[0],xlim1[1],n)
-    xv2 = np.linspace(xlim2[0],xlim2[1],n)
-    (xm1,xm2) = np.meshgrid(xv1,xv2)
-    return (xm1,xm2)
-
-
-def get_flat_x_2d(xlim1: tuple[float,float],
-                  xlim2: tuple[float,float],
-                  n: int = 100) -> np.ndarray:
-
-    (xm1,xm2) = get_mesh_x_2d(xlim1,xlim2,n)
-    xf1 = xm1.flatten()
-    xf2 = xm2.flatten()
-    return np.column_stack((xf1,xf2))
-
-
-def f_mesh_2d(fun: Callable,
-              xlim1: tuple[float,float],
-              xlim2: tuple[float,float],
-              n: int = 100) -> np.ndarray:
-
-    (xm1,_) = get_mesh_x_2d(xlim1,xlim2,n)
-    xf = get_flat_x_2d(xlim1,xlim2,n)
-    f_flat = fun(xf)
-    f_mesh = f_flat.reshape(xm1.shape)
-
-    return f_mesh
-
-
-def plot_fun_2d(tStr: str,
-                fun: Callable,
-                xlim1: tuple[float,float],
-                xlim2: tuple[float,float],
-                n: int =100) -> tuple[Any,Any]:
-
-    (xm1,xm2) = get_mesh_x_2d(xlim1,xlim2,n)
-    f_mesh = f_mesh_2d(fun,xlim1,xlim2,n)
-    # Plot the function
-    pp = PlotOptsGeneral()
-    fig, ax = plt.subplots(figsize=pp.single_fig_size_square,
-                           layout="constrained")
-    fig.set_dpi(pp.resolution)
-
-    plt.contourf(xm1, xm2, f_mesh, 20, cmap=pp.cmap_seq)
-
-    plt.colorbar()
-    plt.title(tStr,fontsize=pp.font_head_size,fontname=pp.font_name)
-    plt.xlabel("x1",fontsize=pp.font_ax_size,fontname=pp.font_name)
-    plt.ylabel("x2",fontsize=pp.font_ax_size,fontname=pp.font_name)
-
-    #plt.show()
-    #plt.savefig(save_path+save_name, dpi=pp.resolution, format="png", bbox_inches="tight")
-    return fig,ax
-
-

pyvale/core/sensordescriptor.py

@@ -1,101 +0,0 @@
-
-"""
-================================================================================
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-"""
-from dataclasses import dataclass
-import numpy as np
-
-#TODO: Docstrings
-
-@dataclass(slots=True)
-class SensorDescriptor:
-    name: str = 'Measured Value'
-    units: str = r"-"
-    time_units: str = r"s"
-    symbol: str = r"m"
-    tag: str = 'S'
-    components: tuple[str,...] | None = None
-
-    def create_label(self, comp_ind: int | None = None) -> str:
-        label = ""
-        if self.name != "":
-            label = label + rf"{self.name} "
-
-
-        symbol = rf"${self.symbol}$ "
-        if comp_ind is not None and self.components is not None:
-            symbol = rf"${self.symbol}_{{{self.components[comp_ind]}}}$ "
-        if symbol != "":
-            label = label + symbol
-
-        if self.units != "":
-            label = label + "\n" + rf"[${self.units}$]"
-
-        return label
-
-    def create_label_flat(self, comp_ind: int | None = None) -> str:
-        label = ""
-        if self.name != "":
-            label = label + rf"{self.name} "
-
-
-        symbol = rf"${self.symbol}$ "
-        if comp_ind is not None and self.components is not None:
-            symbol = rf"${self.symbol}_{{{self.components[comp_ind]}}}$ "
-        if symbol != "":
-            label = label + symbol
-
-        if self.units != "":
-            label = label + " " + rf"[${self.units}$]"
-
-        return label
-
-    def create_sensor_tags(self,n_sensors: int) -> list[str]:
-        z_width = int(np.log10(n_sensors))+1
-
-        sensor_names = list()
-        for ss in range(n_sensors):
-            num_str = f'{ss+1}'.zfill(z_width)
-            sensor_names.append(f'{self.tag}{num_str}')
-
-        return sensor_names
-
-
-class SensorDescriptorFactory:
-    @staticmethod
-    def temperature_descriptor() -> SensorDescriptor:
-        descriptor = SensorDescriptor()
-        descriptor.name = 'Temp.'
-        descriptor.symbol = 'T'
-        descriptor.units = r'^{\circ}C'
-        descriptor.tag = 'TC'
-        return descriptor
-
-    @staticmethod
-    def displacement_descriptor() -> SensorDescriptor:
-        descriptor = SensorDescriptor()
-        descriptor.name = 'Disp.'
-        descriptor.symbol = 'u'
-        descriptor.units = r'm'
-        descriptor.tag = 'DS'
-        descriptor.components = ('x','y','z')
-        return descriptor
-
-    @staticmethod
-    def strain_descriptor(spat_dims: int = 3) -> SensorDescriptor:
-        descriptor = SensorDescriptor()
-        descriptor.name = 'Strain'
-        descriptor.symbol = r'\varepsilon'
-        descriptor.units = r'-'
-        descriptor.tag = 'SG'
-
-        if spat_dims == 2:
-            descriptor.components = ('xx','yy','xy')
-        else:
-            descriptor.components = ('xx','yy','zz','xy','yz','xz')
-
-        return descriptor