pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/mooseherder/mooserunner.py

@@ -0,0 +1,307 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+import os
+import subprocess
+from pathlib import Path
+from pyvale.mooseherder.simrunner import SimRunner
+from pyvale.mooseherder.mooseconfig import MooseConfig
+
+
+class MooseRunner(SimRunner):
+    """Used to run MOOSE models (*.i) from python."""
+
+    __slots__ = ("_config","_n_threads","_n_tasks","_redirect_stdout",
+                 "_arg_list","_input_path")
+
+    def __init__(self, config: MooseConfig):
+        """Constructor for MOOSE runner taking a MooseConfig object
+        that contains the paths to the main MOOSE install, the MOOSE app and
+        the MOOSE app name. Sets default parallelisation options to 1 MPI task
+        and 1 thread. Sets environment variables required for MPI setup.
+
+
+        Parameters
+        ----------
+        config : MooseConfig
+            moose configuration object containing the required paths and app
+            name to construct the command string.
+        """
+        self._config = config.get_config()
+
+        self._n_threads = 1
+        self._n_tasks = 1
+        self._redirect_stdout = True
+        self._arg_list = list('')
+        self._input_path = None
+
+
+    def set_env_vars(self) -> None:
+        """Sets environment variables for calling MOOSE with MPI."""
+        os.environ['CC'] = 'mpicc'
+        os.environ['CXX'] = 'mpicxx'
+        os.environ['F90'] = 'mpif90'
+        os.environ['F77'] = 'mpif77'
+        os.environ['FC'] = 'mpif90'
+        os.environ['MOOSE_DIR'] = str(self._config['main_path'])
+        if str(self._config['app_path']) not in os.environ["PATH"]:
+            os.environ["PATH"] = os.environ["PATH"] + ':' + str(self._config['app_path'])
+
+    def set_threads(self, n_threads: int) -> None:
+        """Sets the number of threads asked of MOOSE on the command line.
+
+        Parameters
+        ----------
+        n_threads : int
+            Number of threads.
+        """
+        # Need to make sure number is sensible based on cpu
+        if n_threads <= 0:
+            n_threads = 1
+        elif os.cpu_count() is None:
+            n_threads = 1
+        elif n_threads > os.cpu_count(): # type: ignore
+            n_threads = os.cpu_count() # type: ignore
+
+        self._n_threads = int(n_threads)
+
+    def set_tasks(self, n_tasks: int) -> None:
+        """Sets the number of MPI tasks asked of MOOSE on the command line.
+
+        Parameters
+        ----------
+        n_tasks : int
+            Number of mpi tasks.
+
+        Returns
+        -------
+
+        """
+        # Need to make sure is sensible based on cpu
+        if n_tasks <= 0:
+            n_tasks = 1
+        elif os.cpu_count() is None:
+            n_tasks = 1
+        elif n_tasks > os.cpu_count(): # type: ignore
+            n_tasks = os.cpu_count() # type: ignore
+
+        self._n_tasks = int(n_tasks)
+
+    def set_stdout(self, redirect_flag: bool = True) -> None:
+        """Sets MOOSE to redirect output (True) to file instead of console (False).
+
+        Parameters
+        ----------
+        redirect_flag : bool
+            True = output to stdout file, False
+            = output to console. Defaults to True.
+
+        Returns
+        -------
+
+        """
+        self._redirect_stdout = redirect_flag
+
+    def set_run_opts(self, n_tasks: int = 1,
+                    n_threads: int = 1,
+                    redirect_out: bool = True) -> None:
+        """Sets all options for MOOSE run parallelisation and output.
+
+        Parameters
+        ----------
+        n_tasks : int
+            Number of mpi tasks for MOOSE run.
+            Defaults to 1.
+        n_threads : int
+            Number of threads for MOOSE run.
+            Defaults to 1.
+        redirect : bool
+            Redirect MOOSE output from console to
+            file (True). Defaults to False.
+
+        Returns
+        -------
+
+        """
+        self.set_threads(n_threads)
+        self.set_tasks(n_tasks)
+        self.set_stdout(redirect_out)
+
+
+    def get_input_file(self) -> Path | None:
+        """get_input_file
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        Path | None
+            full path to the input file or None if not specified.
+
+        """
+        return self._input_path
+
+
+    def set_input_file(self, input_path: Path) -> None:
+        """Sets the path to the MOOSE input file and checks it exists.
+
+        Parameters
+        ----------
+        input_file : Path
+            full path and name of *.i MOOSE input script.
+
+        Returns
+        -------
+
+        Raises
+        ------
+        FileNotFoundError
+            the MOOSE input script doesn't exist
+
+        """
+        if not input_path.is_file():
+            raise FileNotFoundError("Input file does not exist.")
+
+        self._input_path = input_path
+        self.assemble_arg_list()
+
+    def get_input_dir(self) -> Path | None:
+        """Gets the path to the directory for the specified input file.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        Path
+            path to input file directory, if no input file is specified
+            returns None.
+
+        """
+        if self._input_path is None:
+            return None
+
+        return self._input_path.parent # type: ignore
+
+    def get_input_tag(self) -> str:
+        """Gets the input file name string without the path or the .i
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        str
+            input file string, if no input file is specified returns an
+            empty string.
+
+        """
+        if self._input_path is None:
+            return ""
+
+        return self._input_path.stem # type: ignore
+
+
+    def get_output_path(self) -> Path | None:
+        """Gets the file and path for the output exodus file based
+        on the specified input file. Includes '_out.e'.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        Path
+            output exodus file name with path, returns an empty None
+            if no input file is specified.
+
+        """
+        if self._input_path is None:
+            return None
+
+        return self._input_path.parent / (self._input_path.stem +'_out.e')
+
+
+    def get_arg_list(self) -> list[str]:
+        """Run string getter.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        str
+            command line string to run MOOSE.
+
+        """
+        return self._arg_list
+
+    def assemble_arg_list(self, input_file = None) -> list[str]:
+        """Assmebles the command line string to run MOOSE based on current
+        options.
+
+        Parameters
+        ----------
+        input_file : str
+            Full path to MOOSE input file, if not
+            empty updates the input file. Defaults to "".
+
+        Returns
+        -------
+        str
+            command line string that will be used by the runner when run
+            is called.
+
+        """
+        if input_file is not None:
+            self.set_input_file(input_file)
+
+        if self._input_path is None:
+            raise RuntimeError('No input file specified, set one using set_input_file or by passing on into this function.')
+
+        arg_list = []
+        if self._n_tasks > 1:
+            arg_list = ['mpirun','-np',str(self._n_tasks)]
+
+        arg_list = arg_list + [str(self._config['app_name']) \
+                    ,f'--n-threads={self._n_threads}','-i' \
+                    ,str(self._input_path.name)]
+
+        if self._redirect_stdout:
+            arg_list = arg_list + ['--redirect-stdout']
+
+        self._arg_list = arg_list
+
+        return self._arg_list
+
+
+    def run(self, input_file = None) -> None:
+        """Runs MOOSE based on current options by passing run string to
+        subprocess shell.
+
+        Parameters
+        ----------
+        input_file : Path
+            Full path to MOOSE input file, if not
+            empty updates the input file. Defaults to None.
+
+        Returns
+        -------
+
+        """
+        if input_file is not None:
+            self.set_input_file(input_file)
+
+        if self._input_path is None:
+            raise RuntimeError("Set input path before calling run.")
+
+        self.set_env_vars()
+
+        self.assemble_arg_list()
+        subprocess.run(self._arg_list,
+                       shell=False,
+                       cwd=str(self._input_path.parent),
+                       check=False)

pyvale/mooseherder/outputloader.py

@@ -0,0 +1,17 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+from abc import ABC, abstractmethod
+from pyvale.mooseherder.simdata import SimData, SimLoadConfig
+
+
+class IOutputLoader(ABC):
+    @abstractmethod
+    def load_sim_data(self, read_config: SimLoadConfig) -> SimData:
+        pass
+
+    @abstractmethod
+    def load_all_sim_data(self) -> SimData:
+        pass

pyvale/mooseherder/simdata.py

@@ -0,0 +1,93 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from dataclasses import dataclass
+from collections.abc import Iterable
+import numpy as np
+
+
+@dataclass(slots=True)
+class SimData:
+    """Data class for simulation output. Allows for structured meshes with
+    connectivity tables or for point clouds."""
+
+    num_spat_dims: int = 3
+    """ Number of spatial dimensions in the simulation, required to determine
+    element types given that all coords are padded to [x,y,z]. Allows for 2D and
+    1D simulations using any combination of the [x,y,z] axes.
+    """
+
+    time: np.ndarray | None = None
+    """ Vector of time steps with dimensions [t]. Defaults to None.
+    """
+
+    coords: np.ndarray | None = None
+    """ Array of nodal coordinates in N by 3 where N is the number of nodes
+        columns are [x,y,z] coordinates and rows are the nth node. Defaults to
+        None.
+    """
+
+    connect: dict[str,np.ndarray] | None = None
+    """ Element connectivity table:
+        key = "connectX" where X is the subdomain e.g. connect1
+        Element table given as E by n_e rows where E is the number of elements
+        in the given subdomain. n_e is the number of nodes per element.
+        Defaults to None.
+    """
+
+    side_sets: dict[tuple[str,str],np.ndarray] | None = None
+    """ Sidesets by name and associated node and element numbers.
+        key = (name, "node" or "elem") e.g. ("bottom","node") will return node
+        numbers associated with associated with sideset called "bottom" as a
+        numpy array with n_s entries where n_s is the number of nodes in the
+        sideset.
+        Defaults to None.
+    """
+
+    node_vars: dict[str,np.ndarray] | None = None
+    """ Nodal variable by name.
+        key = "name" e.g. "disp_x" or "temp"
+        Gives the nodal variable as a numpy array, N by t where N is the number
+        of nodes and t is the number of time steps. Note that element variables
+        can be stored as nodal depending on output options or material output
+        order selected.
+        Defaults to None.
+    """
+
+    elem_vars: dict[tuple[str,int],np.ndarray] | None = None
+    """ Element variables by name and block.
+        key = (name, block num)
+        Gives the element variable as a numpy array, E by t where E is the
+        number of elements and t is the number of time steps. Note that element
+        variables might exist as nodal variables only depending on output
+        options and specified material output order.
+        Defaults to None.
+    """
+
+    glob_vars: dict[str,np.ndarray] | None = None
+    """ Global variables by name. Global variable include postprocessors and
+        extracted reactions at boundaries.
+        key = name (as specified in input file post-processor), e.g. "react_y"
+        Gives a numpy array with t entries corresponding to the number of time
+        steps in the simulation.
+        Defaults to None.
+    """
+
+@dataclass(slots=True)
+class SimLoadConfig:
+    """Used to specify names of variables to be read into the SimData class.
+       This class allows the user to only extract the required variables by
+       name.
+    """
+    time: bool = True
+    coords: bool = True
+    connect: bool = True
+    sidesets: Iterable[str] | None = None
+    node_vars: Iterable[str] | None = None
+    elem_vars: Iterable[tuple[str,int]] | None = None
+    glob_vars: Iterable[str] | None = None
+    time_inds: Iterable[int] | slice | None = None
+

pyvale/mooseherder/simloaderbyfield.py

@@ -0,0 +1,211 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from pathlib import Path
+from multiprocessing.pool import Pool
+import numpy as np
+import pandas as pd
+from pyvale.mooseherder.outputloader import IOutputLoader
+from pyvale.mooseherder.simdata import SimData, SimLoadConfig
+from pyvale.mooseherder.simloadtools import (str_to_path,
+                                          load_array,
+                                          load_connectivity,
+                                          load_field_files,
+                                          check_sim_data_consistency,
+                                          load_glob_vars,
+                                          inv_group_dict)
+from pyvale.mooseherder.simloadopts import SimLoadOpts
+from pyvale.mooseherder.exceptions import SimLoadErr
+
+
+class SimLoaderByField(IOutputLoader):
+    """Class for loading simulation data (i.e. a `SimData` object) from a series
+    of plain text delimited files or binary numpy npy files.
+
+    Implements the `IOutputLoader` interface.
+    """
+
+    __slots__ = ("_coords","_time_steps","_fields_dir","_file_patterns",
+                 "_field_slices","_load_opts","_connect","_glob_file",
+                 "_glob_slices")
+
+    def __init__(self,
+                 load_dir: Path,
+                 coords_file: str | Path | None,
+                 time_step_file: str | Path | None,
+                 node_field_files: dict[str,str] | None,
+                 connect_files: str | list[str] | None = None,
+                 glob_file: str | None = None,
+                 glob_slices: dict[str,slice] | None = None,
+                 load_opts: SimLoadOpts | None = None) -> None:
+        """
+        Parameters
+        ----------
+        load_dir : Path
+            Directory to load the simulation data files from.
+        coords_file : str | Path | None
+            String or full path specifying the coordinates file. If None then
+            no coordinates are loaded and they can be manually specified in the
+            SimData object.
+        time_step_file : str | Path | None
+            String or full path to the file containing the simulation time 
+            steps. If None then no time step file is loaded and the time steps
+            can be manually specified in the SimData object.
+        node_field_files : dict[str,str] | None
+            Dicitionary keyed by the node field variable name where the value is
+            the file name for that field variable to be found in the load 
+            directory. If None then no nodal field variables are loaded.
+        connect_files : str | list[str] | None, optional
+            Wildcard pattern specifying how to identify connectivity files in 
+            the load directory or list of strings for the connectivity files, 
+            by default None. If None then no connectivity tables are loaded.
+        glob_file : str | None, optional
+            File name for the global variables file in the load directory, by 
+            default None. If None then global variables are not loaded.
+        glob_slices : dict[str,slice] | None, optional
+            Dictionary keyed with the global variable names with slices 
+            specifying which columns to extract for the given global variable, 
+            by default None. If None then no global variables are loaded.
+        load_opts : SimLoadOpts | None, optional
+            Options for loading the simulation data including the number of 
+            threads for using multi-processing to load field files, by default 
+            None. If None then a default load options dataclass is created.
+
+        Raises
+        ------
+        SimLoadErr
+            The specified load directory is not a directory.
+        """
+        self._load_dir = load_dir
+
+        self._glob_file = glob_file
+        self._glob_slices = glob_slices
+
+        self._load_opts = load_opts
+
+        self._coords = None
+        self._time_steps = None
+        self._connect = None
+        self._node_file_pattern = None
+        self._node_slices = None
+
+        if not load_dir.is_dir():
+            raise SimLoadErr(f"Load directory: {load_dir.resolve}, is not a "
+                + "directory.")
+
+        if coords_file is not None:
+            coords_path = str_to_path(load_dir,coords_file)
+            self._coords = load_array(coords_path,
+                                      load_opts.coord_header,
+                                      load_opts.delimiter)
+
+        if time_step_file is not None:
+            time_step_path = str_to_path(load_dir,time_step_file)
+            self._time_steps = load_array(time_step_path,
+                                          load_opts.time_header,
+                                          load_opts.delimiter)
+
+            # Fix for column of nans from reading a 1 column csv
+            if self._time_steps.ndim != 1:
+                self._time_steps = self._time_steps[:,0]
+
+        if connect_files is not None:
+            self._connect = load_connectivity(load_dir,
+                                              connect_files,
+                                              load_opts)
+
+
+        
+        if node_field_files is not None:
+            # We are loading by field so only need empty slicesx
+            self._node_slices = {kk: slice(None) for kk in node_field_files}
+
+            # We invert the keys and values of this dictionary grouping
+            # duplicate keys as values - that way we can loop over this and use
+            # the value lists to index into the slices opening a file with a
+            # given pattern a single time.
+            self._node_file_pattern = inv_group_dict(node_field_files)
+
+
+    # NOTE: interface function
+    def load_sim_data(self, load_config: SimLoadConfig) -> SimData:
+        """Loads the simulation data object based on the specified config.
+
+        Parameters
+        ----------
+        load_config : SimLoadConfig
+            Configuration specifying which parts of the SimData object to load.
+
+        Returns
+        -------
+        SimData
+            The SimData object assembled from loading files from disk.
+        """
+        #-----------------------------------------------------------------------
+        # 1. Create SimData object to populate
+        sim_data = SimData()
+
+        if load_config.coords:
+            sim_data.coords = self._coords
+
+        if load_config.time:
+            sim_data.time = self._time_steps
+
+        if load_config.connect:
+            sim_data.connect = self._connect
+
+        #-----------------------------------------------------------------------
+        # 2. Load global variables file
+        if self._glob_file is not None and self._glob_slices is not None:
+            sim_data.glob_vars = load_glob_vars(self._load_dir/self._glob_file,
+                                                self._glob_slices,
+                                                self._load_opts)
+
+        #-----------------------------------------------------------------------
+        # 3. Load node field variables by field
+        if self._node_file_pattern is not None:
+            node_vars = {}
+            for file_pattern,field_keys in self._node_file_pattern.items():
+
+                slices_to_ext = {}
+                for kk in field_keys:
+                    slices_to_ext[kk] = self._node_slices[kk]
+
+                this_node_vars = load_field_files(
+                    self._load_dir,
+                    file_pattern,
+                    slices_to_ext,
+                    self._load_opts.node_field_header,
+                    self._load_opts.delimiter,
+                    load_config.time_inds,
+                    self._load_opts.workers,
+                )
+
+                node_vars.update(this_node_vars)
+
+            # Needed to get around extra axis issue for components in load func
+            for nn in node_vars:
+                node_vars[nn] = np.squeeze(node_vars[nn])
+
+            sim_data.node_vars = node_vars
+
+            check_sim_data_consistency(sim_data)
+
+        return sim_data
+
+
+    # NOTE: interface function
+    def load_all_sim_data(self) -> SimData:
+        """Loads all simulation data into a SimData object.
+
+        Returns
+        -------
+        SimData
+            The SimData object assembled from loading files from disk.
+        """
+        # Default load config reads all available data
+        load_config = SimLoadConfig()
+        return self.load_sim_data(load_config)