pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/mooseherder/gmshrunner.py

@@ -0,0 +1,158 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import subprocess
+from pathlib import Path
+from pyvale.mooseherder.simrunner import SimRunner
+
+
+class GmshRunner(SimRunner):
+    """Used to call gmsh to create a mesh file to be used to run a finite
+    element simulation. Implements the SimRunner abstract interface so that it
+    can be used by the herd workflow manager.
+    """
+
+    __slots__ = ("_gmsh_app","_input_path","_arg_list")
+
+    def __init__(self, gmsh_path: Path | None = None):
+        """
+        Parameters
+        ----------
+        gmsh_path : Path | None, optional
+            Path to the gmsh executable, by default None
+        """
+
+        if gmsh_path is None:
+            self._gmsh_app = None
+        else:
+            self.set_gmsh_app(gmsh_path)
+
+        self._input_path = None
+        self._arg_list = []
+
+    def set_gmsh_app(self, gmsh_app: Path) -> None: # type: ignore
+        """Sets path to the gmsh app.
+
+        Parameters
+        ----------
+        gmsh_app : Path
+            full path to the gmsh app.
+
+        Raises
+        ------
+        FileNotFoundError
+            gmsh app does not exist at the specified path.
+
+        """
+        if not gmsh_app.exists():
+            raise FileNotFoundError('Gmsh app not found at given path.')
+
+        self._gmsh_app = gmsh_app
+
+
+    def get_input_file(self) -> Path | None:
+        """get_input_path: the path to the input file to run gmsh with.
+
+        Returns
+        -------
+        Path | None
+            path to the gmsh *.geo file.
+
+        """
+        return self._input_path
+
+
+    def set_input_file(self, input_path: Path) -> None:
+        """Sets the input geo file for gmsh.
+
+        Parameters
+        ----------
+        input_file : Path
+            Full path to the gmsh *.geo input file.
+
+        Returns
+        -------
+
+        Raises
+        ------
+        FileNotFoundError
+            Not a .geo file
+        FileNotFoundError
+            Geo file does not exist
+
+        """
+        if input_path.suffix != '.geo':
+            raise FileNotFoundError('Incorrect file type. Must be *.geo.')
+
+        if not input_path.exists():
+            raise FileNotFoundError('Specified gmsh geo file does not exist.')
+
+        self._input_path = input_path
+
+
+    def run(self, input_file: Path | None = None, parse_only: bool = True) -> None:
+        """Run the geo file to create the mesh.
+
+        Parameters
+        ----------
+        input_file : Path | None
+            Path to the .geo file containing the input.
+            Can also be preset using set_input_file. Defaults to "" and ises
+            the input file specified using set_input_file.
+        parse_only: bool :
+             (Default value = True)
+
+        Returns
+        -------
+
+        Raises
+        ------
+        RuntimeError
+            the path to the gmsh app is empty and must be
+            specified first.
+        RuntimeError
+            the input file string is empty and must be specified
+            first.
+
+        """
+        if input_file is not None:
+            self.set_input_file(input_file)
+
+        if self._gmsh_app is None:
+            raise RuntimeError("Specify the full path to the gmsh app before calling run.")
+
+        if self._input_path is None:
+            raise RuntimeError("Specify input *.geo file before running gmsh.")
+
+        arg_list = [str(self._gmsh_app)]
+        if parse_only is True:
+            arg_list = arg_list+["-parse_and_exit"]
+
+        self._arg_list = arg_list + [str(self._input_path)]
+
+        print(f'arg_list={self._arg_list}')
+
+        subprocess.run(self._arg_list,
+                       shell=False,
+                       check=False)
+
+
+    def get_output_path(self) -> Path | None:
+        """get_output_path: default return None for gmsh as there is no output
+        to be read after the simulation has run. This information is stored in
+        the exodus.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        Path | None
+            Default returns None.
+
+        """
+        return None
+

pyvale/mooseherder/inputmodifier.py

@@ -0,0 +1,240 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+from pathlib import Path
+
+
+class InputModifier:
+    """Class to modify variables in generic text-based input files. Once
+    variables have been modified by the user by passing in a dictionary of
+    new variables the input can be written to file.
+    """
+
+    __slots__ = ("_vars","_input_file","_input_lines","_comment_chars",
+                 "_end_chars","_var_start_str","_var_end_str","_var_start_ind",
+                 "_var_end_ind")
+
+    def __init__(
+        self,
+        input_file: Path,
+        comment_chars="#",
+        end_chars="",
+        var_start="_*",
+        var_end="**",
+    ) -> None:
+        """Initialise the class by reading in the input file. Find and read
+        any variables that are at the top of the file. Default comment_char
+        and end_char are set based on reading MOOSE *.i files.
+
+
+        Parameters
+        ----------
+        input_file : Path
+            Path to the input text file.
+        comment_chars : str, optional
+            Character or characters for a comment in the input file, by default
+            "#".
+        end_chars : str, optional
+            Character or characters for a line ending the file. If there is no
+            line ending character this should be an empty string, by default "".
+        var_start : str, optional
+            Character sequence to look for in comments for starting the block of
+            text to look for variables in, by default "_*".
+        var_end : str, optional
+            Character sequence to look for in comment for ending the block of
+            text to look for variables in, by default "**"
+        """
+        self._vars = dict({})
+        self._input_file = input_file
+
+        with open(self._input_file, "r", encoding="utf-8") as in_file:
+            self._input_lines = in_file.readlines()
+
+        self._comment_chars = comment_chars
+        self._end_chars = end_chars
+
+        self._var_start_str = var_start
+        self._var_end_str = var_end
+
+        self._var_start_ind = 0
+        self._var_end_ind = -1
+
+        self.find_vars()
+        self.read_vars()
+
+    def _extract_var_str(self, var_line: str) -> tuple[str, str | float, str]:
+        """Helper function to split a string from the input file variable block
+        into the variable key, the variable value and any remaining comment.
+
+        Parameters
+        ----------
+        var_line : str
+            line from the input file to process
+
+        Returns
+        -------
+        [str,str | float,str]
+            returns a three element list. The first element
+            is the variable key, the second is the variable value as a float
+            or string, the third is any comment string remaining.
+
+        """
+
+        extract_var = var_line.strip()
+        extract_var = extract_var.replace(self._end_chars, "")
+        extract_var = extract_var.split(self._comment_chars)[0]  # Remove trailing comments should they exist
+
+        var_key = ""
+        var_val = ""
+        if extract_var and extract_var.find("=") >= 0:
+            var_str = extract_var.split("=", 1)[1]
+            var_str = var_str.strip()
+            try:
+                var_val = float(var_str)
+                if var_val.is_integer():
+                    var_val = int(var_val)
+            except ValueError:
+                var_val = var_str
+
+            var_key = extract_var.split("=", 1)[0].strip()
+
+        if len(var_line.split(self._comment_chars)) > 1:
+            com_loc = var_line.find(self._comment_chars)
+            comment_str = var_line[com_loc + len(self._comment_chars) :]
+        else:
+            comment_str = ""
+
+        return (var_key, var_val, comment_str)
+
+
+    def read_vars(self) -> None:
+        """Reads the variables in the file"""
+        for ss in self._input_lines[self._var_start_ind + 1 : self._var_end_ind]:
+            [var_key, var_val, _] = self._extract_var_str(ss)
+            if len(var_key) != 0:
+                self._vars[var_key] = var_val
+
+
+    def find_vars(self) -> None:
+        """Find what lines the variables are defined on."""
+
+        # TODO: this needs to be made more robust to multiple occurences of variable block characters.
+        # Also need to handle cases when the start and end block characters are the same
+
+        start_string = self._comment_chars + self._var_start_str
+        end_string = self._comment_chars + self._var_end_str
+
+        start_found = False
+        for ii, ll in enumerate(self._input_lines):
+            if start_string in ll and (not start_found):
+                self._var_start_ind = ii
+                start_found = True
+            if end_string in ll:
+                self._var_end_ind = ii
+                break
+
+
+    def update_vars(self, new_vars: dict) -> None:
+        """Updates the variable dictionary that will be written to the input
+        file.
+
+        Parameters
+        ----------
+        new_vars : dict
+            new variables to be written to the input file.
+            The keys must exist within the dictionary of variables
+            extracted from the input file. Only the variables to be edited
+            need to be present.
+        new_vars: dict :
+
+
+        Returns
+        -------
+
+        """
+        for kk in new_vars:
+            if kk in self._vars:
+                self._vars[kk] = new_vars[kk]
+            else:
+                raise KeyError(
+                    f"Key {kk} does not exist in the variables found in the input file. "
+                    + "Check input file to make sure the variable exists."
+                )
+
+
+    def write_file(self, input_write_file: Path) -> None:
+        """Write the input file using the current variable dictionary.
+
+        Parameters
+        ----------
+        input_write_file : str
+            Path to where the file should be written.
+        input_write_file: Path :
+
+
+        Returns
+        -------
+
+        """
+        var_block = self._input_lines[self._var_start_ind + 1 : self._var_end_ind]
+
+        for ii, ll in enumerate(var_block):
+            [var_key, _, com_str] = self._extract_var_str(ll)
+            if (len(var_key) != 0) and (var_key in self._vars):
+                if len(com_str) == 0:
+                    var_line = f"{var_key} = {self._vars[var_key]}{self._end_chars}\n"
+                else:
+                    # NOTE: comment string includes the new line character already
+                    var_line = f"{var_key} = {self._vars[var_key]}{self._end_chars} {self._comment_chars}{com_str}"
+                line_ind = ii + self._var_start_ind + 1
+                self._input_lines[line_ind] = var_line
+
+        with open(input_write_file, "w", encoding="utf-8") as out_file:
+            out_file.writelines(self._input_lines)
+
+
+    def get_vars(self) -> dict:
+        """Gets the variables found in the file.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        dict
+            keys are variable strings and values are variable values.
+
+        """
+        return self._vars
+
+
+    def get_var_keys(self) -> list[str]:
+        """Gets a list of variable names found in the input file.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        list[str]
+            list of variables name as strings
+
+        """
+        return list(self._vars.keys())
+
+
+    def get_input_file(self) -> Path:
+        """Gets the path and input file name.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        Path
+            path and input file name.
+
+        """
+        return self._input_file

pyvale/mooseherder/mooseconfig.py

@@ -0,0 +1,212 @@
+
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+from typing import Self
+import json
+from pathlib import Path
+
+
+class MooseConfig:
+    """Moose configuration class that handles 1) the path to the main moose
+    build, 2) the path to the moose app, and 3) the name of the app to be used
+    to construct the command string. These are stored as a dictionary keyed
+    with 'main_path', 'app_path' and 'app_name'. This class can also write and
+    read json files containing the moose config.
+    """
+    __slots__ = ("_required_keys","_config")
+
+    def __init__(self, config: dict[str,Path | str] | None = None) -> None:
+
+        self._required_keys = ['main_path','app_path','app_name']
+
+        if config is not None:
+            self._check_config_valid(config)
+
+        self._config = config
+
+
+    def get_config(self) -> dict[str,Path | str]:
+        """get_config: returns the config dictionary after checking it is
+        valid.
+
+        Returns
+        -------
+        dict[str, Path | str]
+            dictionary containing the moose config.
+
+        """
+        self._check_config_valid(self._config)
+        return self._config # type: ignore
+
+
+    def _check_config_valid(self,
+                            config: dict[str,Path | str] | None = None
+                            ) -> None:
+        """_check_config_valid: helper function to check if the moose config
+        is valid.
+
+        Parameters
+        ----------
+        config : dict[str, Path | str] | None = None
+            Dictionary containing the moose config. Defaults to None.
+
+        Raises
+        ------
+        MooseConfigError
+            Dicitionary not initialised.
+        MooseConfigError
+            Dicitionary does not contain the required keys.
+        MooseConfigError
+            Path to MOOSE does not exist.
+        MooseConfigError
+            Path to MOOSE app does not exist.
+
+        """
+        if config is None:
+            raise MooseConfigError(
+                'Config dictionary must be initialised, load config file first.')
+
+        for kk in self._required_keys:
+            if kk not in config:
+                raise MooseConfigError(
+                    f'Config dictionary must contain all keys: {self._required_keys}')
+
+        if not config['main_path'].is_dir(): # type: ignore
+            raise MooseConfigError(
+                "Main path to MOOSE does not exist. Check path at key 'main_path'.")
+
+        if not config['app_path'].is_dir(): # type: ignore
+            raise MooseConfigError(
+                "MOOSE app path does not exist. Check path at key: 'app_path'.")
+
+
+    def convert_path_to_str(self, in_config: dict[str,Path | str] | None
+                             ) -> dict[str,str] | None:
+        """convert_path_to_str: converts all paths in the config dictionary to
+        strings so that it can be saved to json.
+
+        Parameters
+        ----------
+        in_config : dict[str, Path | str] | None
+            Dictionary containing the moose config. Defaults to None.
+
+        Returns
+        -------
+        dict[str,str] | None
+            as input with Paths converted to strings.
+
+        """
+        if in_config is None:
+            return None
+
+        conv_config = dict({})
+        for kk in in_config:
+            conv_config[kk] = str(in_config[kk])
+
+        return conv_config
+
+
+    def convert_str_to_path(self, in_config: dict[str,str] | None = None
+                             ) -> dict[str, Path | str] | None:
+        """convert_str_to_path: helper function to convert string to Path for
+        readin in json dictionary. Does not check if the paths exist.
+
+        Parameters
+        ----------
+        in_config : dict[str, Path | str] | None
+            Dictionary containing the moose config. Defaults to None.
+
+        Returns
+        -------
+        dict[str, Path | str] | None
+            as in_config but strings to main_path
+            and app_path are converted to Path.
+
+        """
+        if in_config is None:
+            return None
+
+        conv_config = dict({})
+        for kk in in_config:
+            if 'path' in kk:
+                conv_config[kk] = Path(in_config[kk])
+            else:
+                conv_config[kk] = in_config[kk]
+
+        return conv_config
+
+
+    def save_config(self, config_path: Path) -> None:
+        """save_config: saves the moose config dictionary as a json file in the
+        specified path.
+
+        Parameters
+        ----------
+        config_path : Path
+            path and file name with extension .json to save the moose config
+            dictionary.
+
+        Raises
+        ------
+        MooseConfigError
+            Parent path to save config file does not exist.
+
+        """
+        if not config_path.parent.is_dir():
+            raise MooseConfigError('Parent path to save config file does not exist.')
+
+        with open(config_path, 'w', encoding='utf-8') as cf:
+            config_strs = self.convert_path_to_str(self._config)
+            json.dump(config_strs, cf, indent=4)
+
+
+    def read_config(self, config_path: Path) -> Self:
+        """read_config: reads the moose json configuration file at the
+        specified path. Checks if the configuration is valid and raises a
+        MooseConfigError if it is not.
+
+        Parameters
+        ----------
+        config_path : Path
+            path to the json config file containing the
+
+        Returns
+        -------
+        Self
+            returns a MooseConfig object allowing the config to be
+            initialised by directly loading a json config file.
+
+        Raises
+        ------
+        MooseConfigError
+            MOOSE config file does not exist.
+
+        """
+        if not config_path.is_file():
+            raise MooseConfigError(
+                f'MOOSE config file does not exist at: {str(config_path)}.')
+
+        with open(config_path, 'r', encoding='utf-8') as cf:
+            config_strs = json.load(cf)
+            config_paths = self.convert_str_to_path(config_strs)
+
+        self._check_config_valid(config_paths)
+
+        self._config = config_paths
+        return self
+
+
+class MooseConfigError(Exception):
+    """MooseConfigError: custom error class for flagging errors with the moose
+    configuration.
+
+    Parameters
+    ----------
+
+    Returns
+    -------
+
+    """