pyvale 2025.4.0__tar.gz

pyvale-2025.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2025 The Computer Aided Validation Team at UKAEA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyvale-2025.4.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: pyvale
+Version: 2025.4.0
+Summary: An all-in-one package for sensor simulation, sensor uncertainty quantification, sensor placement optimisation and simulation calibration or validation.
+Author-email: "scepticalrabbit et al." <thescepticalrabbit@gmail.com>
+License: MIT License
+        
+        Copyright (C) 2025 The Computer Aided Validation Team at UKAEA
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Repository, https://github.com/Digital-Validation-Laboratory/pyvale
+Project-URL: Issue Tracker, https://github.com/Digital-Validation-Laboratory/pyvale/issues
+Requires-Python: ==3.11.*
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mooseherder>=0.1.0
+Requires-Dist: numpy<2.0.0
+Requires-Dist: scipy>=1.14.0
+Requires-Dist: netCDF4>=1.6.5
+Requires-Dist: pyvista>=0.43.3
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: shapely>=2.0.4
+Requires-Dist: sympy>=1.13.0
+Requires-Dist: PyQT6>=6.7.1
+Requires-Dist: imageio>=2.36.1
+Requires-Dist: imageio-ffmpeg>=0.5.1
+Requires-Dist: numba>=0.59.1
+Requires-Dist: pymoo>=0.6.1.3
+Requires-Dist: Cython>=3.0.0
+Requires-Dist: bpy>=4.2.0
+Dynamic: license-file
+
+# pyvale
+The python validation engine (`pyvale`): An all-in-one package for sensor simulation, sensor uncertainty quantification, sensor placement optimisation and simulation calibration/validation.​ Used to simulate experimental data from an input multi-physics simulation by explicitly modelling sensors with realistic uncertainties. Useful for experimental design, sensor placement optimisation, testing simulation validation metrics and virtually testing digital shadows/twins.
+
+## Quick Demo: Simulating Point Sensors
+Here we demonstrate how `pyvale` can be used to simulate thermocouples and strain gauges applied to a [MOOSE](https://mooseframework.inl.gov/index.html) thermo-mechanical simulation of a fusion divertor armour heatsink. The figures below show visualisations of the virtual thermocouple and strain gauge locations on the simualtion mesh as well as time traces for each sensor over a series of simulated experiments. The code to run the simulated experiments and produce the output shown here comes from [this example](https://github.com/Computer-Aided-Validation-Laboratory/pyvale/blob/main/src/pyvale/examples/ex6_2_multiphysics3d_expsim.py).
+
+|![fig_thermomech3d_tc_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_sg_vis.svg)|![fig_thermomech3d_sg_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_sg_vis.svg)|
+|--|--|
+|*Visualisation of the thermcouple locations.*|*Visualisation of the strain gauge locations.*|
+
+|![fig_thermomech3d_tc_traces](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_tc_traces.png)|![fig_thermomech3d_sg_traces](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_sg_traces.png)|
+|--|--|
+|*Thermocouples time traces over a series of simulated experiments.*|*Strain gauge time traces over a series of simulated experiments.*|
+
+
+## Quick Install
+`pyvale` can be installed from pypi:
+```shell
+pip install pyvale
+```
+
+## Detailed Install: Ubuntu
+### Managing Python Versions
+To be compatible with `bpy` (the Blender python interface), `pyvale` uses python 3.11. To install python 3.11 without corrupting your operating systems python installation first add the deadsnakes repository to apt:
+```shell
+sudo add-apt-repository ppa:deadsnakes/ppa
+sudo apt update && sudo apt upgrade -y
+```
+
+Install python 3.11:
+```shell
+sudo apt install python3.11
+```
+
+Add `venv` to your python 3.11 install:
+```shell
+sudo apt install python3.11-venv
+```
+
+Check your python 3.11 install is working using the following command which should open an interactive python interpreter:
+```shell
+python3.11
+```
+
+### Virtual Environment
+
+We recommend installing `pyvale` in a virtual environment using `venv` or `pyvale` can be installed into an existing environment of your choice. To create a specific virtual environment for `pyvale` navigate to the directory you want to install the environment and use:
+
+```shell
+python3.11 -m venv .pyvale-env
+source .pyvale-env/bin/activate
+```
+
+### Standard Installation
+`pyvale` can be installed from pypi. Ensure you virtual environment is activated and run:
+```shell
+pip install pyvale
+```
+
+### Developer Installation
+
+Clone `pyvale` to your local system along with submodules using
+```shell
+git clone --recurse-submodules git@github.com:Computer-Aided-Validation-Laboratory/pyvale.git
+```
+
+`cd` to the root directory of `pyvale`. Ensure you virtual environment is activated and run the following commmand from the `pyvale` directory:
+```shell
+pip install -e .
+pip install -e ./dependencies/mooseherder
+```
+
+### MOOSE
+`pyvale` come pre-packaged with example `moose` physics simulation outputs (as *.e exodus files) to demonstrate its functionality. If you need to run additional simulation cases we recommend `proteus` (https://github.com/aurora-multiphysics/proteus) which has build scripts for common linux distributions.
+
+## Getting Started
+The examples folder in "pyvale/examples" includes a sequence of examples of increasing complexity that demonstrate the functionality of `pyvale`.
+
+## Contributors
+The Computer Aided Validation Team at UKAEA:
+- Lloyd Fletcher (ScepticalRabbit), UK Atomic Energy Authority
+- John Charlton (coolmule0), UK Atomic Energy Authority
+- Joel Hirst (JoelPhys), UK Atomic Energy Authority
+- Lorna Sibson (lornasibson), UK Atomic Energy Authority
+- Adel Tayeb (3adelTayeb), UK Atomic Energy Authority
+- Alex Marsh (alexmarsh2), UK Atomic Energy Authority
+- Rory Spencer (fusmatrs), UK Atomic Energy Authority
+
+
+
+
+

pyvale-2025.4.0/README.md

@@ -0,0 +1,92 @@
+# pyvale
+The python validation engine (`pyvale`): An all-in-one package for sensor simulation, sensor uncertainty quantification, sensor placement optimisation and simulation calibration/validation.​ Used to simulate experimental data from an input multi-physics simulation by explicitly modelling sensors with realistic uncertainties. Useful for experimental design, sensor placement optimisation, testing simulation validation metrics and virtually testing digital shadows/twins.
+
+## Quick Demo: Simulating Point Sensors
+Here we demonstrate how `pyvale` can be used to simulate thermocouples and strain gauges applied to a [MOOSE](https://mooseframework.inl.gov/index.html) thermo-mechanical simulation of a fusion divertor armour heatsink. The figures below show visualisations of the virtual thermocouple and strain gauge locations on the simualtion mesh as well as time traces for each sensor over a series of simulated experiments. The code to run the simulated experiments and produce the output shown here comes from [this example](https://github.com/Computer-Aided-Validation-Laboratory/pyvale/blob/main/src/pyvale/examples/ex6_2_multiphysics3d_expsim.py).
+
+|![fig_thermomech3d_tc_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_sg_vis.svg)|![fig_thermomech3d_sg_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_sg_vis.svg)|
+|--|--|
+|*Visualisation of the thermcouple locations.*|*Visualisation of the strain gauge locations.*|
+
+|![fig_thermomech3d_tc_traces](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_tc_traces.png)|![fig_thermomech3d_sg_traces](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_sg_traces.png)|
+|--|--|
+|*Thermocouples time traces over a series of simulated experiments.*|*Strain gauge time traces over a series of simulated experiments.*|
+
+
+## Quick Install
+`pyvale` can be installed from pypi:
+```shell
+pip install pyvale
+```
+
+## Detailed Install: Ubuntu
+### Managing Python Versions
+To be compatible with `bpy` (the Blender python interface), `pyvale` uses python 3.11. To install python 3.11 without corrupting your operating systems python installation first add the deadsnakes repository to apt:
+```shell
+sudo add-apt-repository ppa:deadsnakes/ppa
+sudo apt update && sudo apt upgrade -y
+```
+
+Install python 3.11:
+```shell
+sudo apt install python3.11
+```
+
+Add `venv` to your python 3.11 install:
+```shell
+sudo apt install python3.11-venv
+```
+
+Check your python 3.11 install is working using the following command which should open an interactive python interpreter:
+```shell
+python3.11
+```
+
+### Virtual Environment
+
+We recommend installing `pyvale` in a virtual environment using `venv` or `pyvale` can be installed into an existing environment of your choice. To create a specific virtual environment for `pyvale` navigate to the directory you want to install the environment and use:
+
+```shell
+python3.11 -m venv .pyvale-env
+source .pyvale-env/bin/activate
+```
+
+### Standard Installation
+`pyvale` can be installed from pypi. Ensure you virtual environment is activated and run:
+```shell
+pip install pyvale
+```
+
+### Developer Installation
+
+Clone `pyvale` to your local system along with submodules using
+```shell
+git clone --recurse-submodules git@github.com:Computer-Aided-Validation-Laboratory/pyvale.git
+```
+
+`cd` to the root directory of `pyvale`. Ensure you virtual environment is activated and run the following commmand from the `pyvale` directory:
+```shell
+pip install -e .
+pip install -e ./dependencies/mooseherder
+```
+
+### MOOSE
+`pyvale` come pre-packaged with example `moose` physics simulation outputs (as *.e exodus files) to demonstrate its functionality. If you need to run additional simulation cases we recommend `proteus` (https://github.com/aurora-multiphysics/proteus) which has build scripts for common linux distributions.
+
+## Getting Started
+The examples folder in "pyvale/examples" includes a sequence of examples of increasing complexity that demonstrate the functionality of `pyvale`.
+
+## Contributors
+The Computer Aided Validation Team at UKAEA:
+- Lloyd Fletcher (ScepticalRabbit), UK Atomic Energy Authority
+- John Charlton (coolmule0), UK Atomic Energy Authority
+- Joel Hirst (JoelPhys), UK Atomic Energy Authority
+- Lorna Sibson (lornasibson), UK Atomic Energy Authority
+- Adel Tayeb (3adelTayeb), UK Atomic Energy Authority
+- Alex Marsh (alexmarsh2), UK Atomic Energy Authority
+- Rory Spencer (fusmatrs), UK Atomic Energy Authority
+
+
+
+
+

pyvale-2025.4.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyvale"
+version = "2025.4.0"
+description = "An all-in-one package for sensor simulation, sensor uncertainty quantification, sensor placement optimisation and simulation calibration or validation."
+authors = [
+  { name = "scepticalrabbit et al.", email = "thescepticalrabbit@gmail.com" },
+]
+license = { file = "LICENSE" }
+readme = "README.md"
+requires-python = "==3.11.*"
+dependencies = [
+  "mooseherder>=0.1.0",
+  "numpy<2.0.0",
+  "scipy>=1.14.0",
+  "netCDF4>=1.6.5",
+  "pyvista>=0.43.3",
+  "matplotlib>=3.8",
+  "shapely>=2.0.4",
+  "sympy>=1.13.0",
+  "PyQT6>=6.7.1",
+  "imageio>=2.36.1",
+  "imageio-ffmpeg>=0.5.1",
+  "numba>=0.59.1",
+  "pymoo>=0.6.1.3",
+  "Cython>=3.0.0",
+  "bpy>=4.2.0",
+]
+
+[project.urls]
+"Repository" = "https://github.com/Digital-Validation-Laboratory/pyvale"
+"Issue Tracker" = "https://github.com/Digital-Validation-Laboratory/pyvale/issues"
+
+[tool.setuptools.package-data]
+"pyvale.data" = ["*.e","*.tiff"]
+"pyvale.simcases" = ["*.i","*.geo"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

pyvale-2025.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyvale-2025.4.0/src/pyvale/__init__.py

@@ -0,0 +1,75 @@
+"""
+`pyvale`: the python validation engine. Used to simulate experimental data from
+an input multi-physics simulation by explicitly modelling sensors with realistic
+uncertainties. Useful for experimental design, sensor placement optimisation,
+testing simulation validation metrics and testing digital shadows/twins.
+"""
+
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+# NOTE: this simplifies and decouples how the user calls pyvale from the
+# underlying project structure: the user should be able to use 'pyvale.'
+# and access everything in one layer without multiple import dots
+
+from pyvale.core.dataset import *
+
+from pyvale.core.field import *
+from pyvale.core.fieldscalar import *
+from pyvale.core.fieldvector import *
+from pyvale.core.fieldtensor import *
+from pyvale.core.fieldconverter import *
+from pyvale.core.fieldtransform import *
+
+from pyvale.core.integratorspatial import *
+from pyvale.core.integratorquadrature import *
+from pyvale.core.integratorrectangle import *
+from pyvale.core.integratorfactory import *
+
+from pyvale.core.sensordescriptor import *
+from pyvale.core.sensortools import *
+from pyvale.core.sensorarray import *
+from pyvale.core.sensorarrayfactory import *
+from pyvale.core.sensorarraypoint import *
+from pyvale.core.sensordata import *
+
+from pyvale.core.camera import *
+from pyvale.core.cameradata import *
+from pyvale.core.cameradata2d import *
+from pyvale.core.cameratools import *
+
+import pyvale.core.cython.rastercyth as rastercyth
+from pyvale.core.rastercy import *
+
+from pyvale.core.rendermesh import *
+from pyvale.core.rasternp import *
+
+from pyvale.core.imagedef2d import *
+
+from pyvale.core.errorintegrator import *
+from pyvale.core.errorrand import *
+from pyvale.core.errorsysindep import *
+from pyvale.core.errorsysdep import *
+from pyvale.core.errorsysfield import *
+from pyvale.core.errordriftcalc import *
+
+from pyvale.core.generatorsrandom import *
+
+from pyvale.core.visualopts import *
+from pyvale.core.visualtools import *
+from pyvale.core.visualsimplotter import *
+from pyvale.core.visualsimanimator import *
+from pyvale.core.visualexpplotter import *
+from pyvale.core.visualtraceplotter import *
+from pyvale.core.visualimages import *
+from pyvale.core.visualimagedef import *
+
+from pyvale.core.analyticmeshgen import *
+from pyvale.core.analyticsimdatagenerator import *
+from pyvale.core.analyticsimdatafactory import *
+
+from pyvale.core.experimentsimulator import *

pyvale-2025.4.0/src/pyvale/core/__init__.py

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

pyvale-2025.4.0/src/pyvale/core/analyticmeshgen.py

@@ -0,0 +1,59 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+import numpy as np
+
+# NOTE: This module is a feature under developement.
+
+def rectangle_mesh_2d(leng_x: float,
+                      leng_y: float,
+                      n_elem_x: int,
+                      n_elem_y: int) -> tuple[np.ndarray,np.ndarray]:
+
+    n_elems = n_elem_x*n_elem_y
+    n_node_x = n_elem_x+1
+    n_node_y = n_elem_y+1
+    nodes_per_elem = 4
+
+    coord_x = np.linspace(0,leng_x,n_node_x)
+    coord_y = np.linspace(0,leng_y,n_node_y)
+    (coord_grid_x,coord_grid_y) = np.meshgrid(coord_x,coord_y)
+
+    coord_x = np.atleast_2d(coord_grid_x.flatten()).T
+    coord_y = np.atleast_2d(coord_grid_y.flatten()).T
+    coord_z = np.zeros_like(coord_x)
+    coords = np.hstack((coord_x,coord_y,coord_z))
+
+    connect = np.zeros((n_elems,nodes_per_elem)).astype(np.int64)
+    row = 1
+    nn = 0
+    for ee in range(n_elems):
+        nn += 1
+        if nn >= row*n_node_x:
+            row += 1
+            nn += 1
+
+        connect[ee,:] = np.array([nn,nn+1,nn+n_node_x+1,nn+n_node_x])
+    connect = connect.T
+
+    return (coords,connect)
+
+
+def fill_dims(coord_x: np.ndarray,
+              coord_y: np.ndarray,
+              time: np.ndarray) -> tuple[np.ndarray,np.ndarray,np.ndarray]:
+
+    full_x = np.repeat(np.atleast_2d(coord_x).T,
+                       time.shape[0],
+                       axis=1)
+    full_y = np.repeat(np.atleast_2d(coord_y).T,
+                       time.shape[0],
+                       axis=1)
+    full_time = np.repeat(np.atleast_2d(time),
+                          coord_x.shape[0],
+                          axis=0)
+    return (full_x,full_y,full_time)

pyvale-2025.4.0/src/pyvale/core/analyticsimdatafactory.py

@@ -0,0 +1,63 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+import numpy as np
+import sympy
+import mooseherder as mh
+from pyvale.core.analyticsimdatagenerator import (AnalyticCaseData2D,
+                                                  AnalyticSimDataGenerator)
+
+# NOTE: This module is a feature under developement.
+
+def standard_case_2d() -> AnalyticCaseData2D:
+    case_data = 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)
+    return case_data
+
+
+class AnalyticCaseFactory:
+
+    @staticmethod
+    def scalar_linear_2d() -> tuple[mh.SimData,AnalyticSimDataGenerator]:
+
+        case_data = standard_case_2d()
+        (sym_y,sym_x,sym_t) = sympy.symbols("y,x,t")
+        case_data.funcs_x = (20.0/case_data.length_x * sym_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 = AnalyticSimDataGenerator(case_data)
+
+        sim_data = data_gen.generate_sim_data()
+
+        return (sim_data,data_gen)
+
+    @staticmethod
+    def scalar_quadratic_2d() -> tuple[mh.SimData,AnalyticSimDataGenerator]:
+
+        case_data = standard_case_2d()
+        (sym_y,sym_x,sym_t) = sympy.symbols("y,x,t")
+        case_data.funcs_x = (sym_x*(sym_x - case_data.length_x),)
+        case_data.funcs_y = (sym_y*(sym_y - case_data.length_y),)
+        case_data.funcs_t = (sym_t,)
+
+        data_gen = AnalyticSimDataGenerator(case_data)
+
+        sim_data = data_gen.generate_sim_data()
+
+        return (sim_data,data_gen)
+
+
+
+

pyvale-2025.4.0/src/pyvale/core/analyticsimdatagenerator.py

@@ -0,0 +1,160 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from dataclasses import dataclass
+import numpy as np
+import sympy
+import mooseherder as mh
+from pyvale.core.analyticmeshgen import rectangle_mesh_2d, fill_dims
+
+# NOTE: This module is a feature under developement.
+
+@dataclass
+class AnalyticCaseData2D:
+    length_x: float = 10.0
+    length_y: float = 7.5
+    num_elem_x: int = 4
+    num_elem_y: int = 3
+    time_steps: np.ndarray | None = None
+    field_keys: tuple[str,...] = ('scalar',)
+    funcs_x: tuple[sympy.Expr,...] | None = None
+    funcs_y: tuple[sympy.Expr,...] | None = None
+    funcs_t: tuple[sympy.Expr,...] | None = None
+    symbols: tuple[sympy.Symbol,...] = (sympy.Symbol("y"),
+                                        sympy.Symbol("x"),
+                                        sympy.Symbol("t"))
+    offsets_space: tuple[float,...] = (0.0,)
+    offsets_time: tuple[float,...] = (0.0,)
+    nodes_per_elem: int = 4
+
+
+class AnalyticSimDataGenerator:
+    def __init__(self, case_data: AnalyticCaseData2D
+                 ) -> None:
+
+        self._case_data = case_data
+        (self._coords,self._connect) = rectangle_mesh_2d(case_data.length_x,
+                                                         case_data.length_y,
+                                                         case_data.num_elem_x,
+                                                         case_data.num_elem_y)
+
+        self._field_sym_funcs = dict()
+        self._field_lam_funcs = dict()
+        for ii,kk in enumerate(case_data.field_keys):
+            self._field_sym_funcs[kk] = ((case_data.funcs_x[ii] *
+                                          case_data.funcs_y[ii] +
+                                          case_data.offsets_space[ii]) *
+                                        (case_data.funcs_t[ii] +
+                                         case_data.offsets_time[ii]))
+
+            self._field_lam_funcs[kk] = sympy.lambdify(case_data.symbols,
+                                                self._field_sym_funcs[kk],
+                                                'numpy')
+        self._field_eval = dict()
+
+
+    def evaluate_field_truth(self,
+                       field_key: str,
+                       coords: np.ndarray,
+                       time_steps: np.ndarray | None = None) -> np.ndarray:
+
+        if time_steps is None:
+            time_steps = self._case_data.time_steps
+
+        (x_eval,y_eval,t_eval) = fill_dims(coords[:,0],
+                                            coords[:,1],
+                                            time_steps)
+
+        field_vals = self._field_lam_funcs[field_key](y_eval,
+                                                x_eval,
+                                                t_eval)
+        return field_vals
+
+
+    def evaluate_all_fields_truth(self,
+                       coords: np.ndarray,
+                       time_steps: np.ndarray | None = None) -> np.ndarray:
+
+        if time_steps is None:
+            time_steps = self._case_data.time_steps
+
+        (x_eval,y_eval,t_eval) = fill_dims(coords[:,0],
+                                            coords[:,1],
+                                            time_steps)
+
+        eval_comps = dict()
+        for kk in  self._case_data.field_keys:
+            eval_comps[kk] = self._field_lam_funcs[kk](y_eval,
+                                                        x_eval,
+                                                        t_eval)
+        return eval_comps
+
+
+    def evaluate_field_at_nodes(self, field_key: str) -> np.ndarray:
+        (x_eval,y_eval,t_eval) = fill_dims(self._coords[:,0],
+                                           self._coords[:,1],
+                                           self._case_data.time_steps)
+
+        self._field_eval[field_key] = self._field_lam_funcs[field_key](y_eval,
+                                                                        x_eval,
+                                                                        t_eval)
+        return self._field_eval[field_key]
+
+    def evaluate_all_fields_at_nodes(self) -> dict[str,np.ndarray]:
+        (x_eval,y_eval,t_eval) = fill_dims(self._coords[:,0],
+                                           self._coords[:,1],
+                                           self._case_data.time_steps)
+        eval_comps = dict()
+        for kk in  self._case_data.field_keys:
+            eval_comps[kk] = self._field_lam_funcs[kk](y_eval,
+                                                        x_eval,
+                                                        t_eval)
+        self._field_eval = eval_comps
+        return self._field_eval
+
+
+    def generate_sim_data(self) -> mh.SimData:
+
+        sim_data = mh.SimData()
+        sim_data.num_spat_dims = 2
+        sim_data.time = self._case_data.time_steps
+        sim_data.coords = self._coords
+        sim_data.connect = {'connect1': self._connect}
+
+        if not self._field_eval:
+            self.evaluate_all_fields_at_nodes()
+        sim_data.node_vars = self._field_eval
+
+        return sim_data
+
+
+    def get_visualisation_grid(self,
+                               field_key: str | None = None,
+                               time_step: int = -1
+                               ) -> tuple[np.ndarray,np.ndarray,np.ndarray]:
+
+        if field_key is None:
+            field_key = self._case_data.field_keys[0]
+
+        grid_shape = (self._case_data.num_elem_y+1,
+                      self._case_data.num_elem_x+1)
+
+        grid_x = np.atleast_2d(self._coords[:,0]).T.reshape(grid_shape)
+        grid_y = np.atleast_2d(self._coords[:,1]).T.reshape(grid_shape)
+
+        if not self._field_eval:
+            self.evaluate_all_fields_at_nodes()
+
+        scalar_grid = np.reshape(self._field_eval[field_key][:,time_step],grid_shape)
+
+        return (grid_x,grid_y,scalar_grid)
+
+
+
+
+
+