InputParameters.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

// MOOSE includes
#include "MooseUtils.h"
#include "MooseError.h"
#include "MooseTypes.h"
#include "MultiMooseEnum.h"
#include "ExecFlagEnum.h"
#include "Conversion.h"
#include "DataFileUtils.h"
#include "MoosePassKey.h"

#include "libmesh/parameters.h"

#ifdef LIBMESH_HAVE_FPARSER
#include "libmesh/fparser.hh"
#else
template <typename T>
class FunctionParserBase
{
}
#endif

#include <tuple>
#include <unordered_map>
#include <mutex>
#include <optional>
#include <filesystem>
#include <regex>

#include <gtest/gtest.h>

// Forward declarations
class Action;
class ActionFactory;
class Factory;
class FEProblemBase;
class InputParameters;
class MooseEnum;
class MooseObject;
class MultiMooseEnum;
class Problem;
namespace hit
{
class Node;
}
namespace Moose
{
class Builder;
}
class CommandLine;

class InputParameters : public libMesh::Parameters
{
public:
  InputParameters(const InputParameters & rhs);
  InputParameters(const Parameters & rhs);

  virtual ~InputParameters() = default;

  virtual void clear() override;

  struct CommandLineMetadata
  {
    enum ArgumentType
    {
      NONE,
      OPTIONAL,
      REQUIRED
    };

    std::string syntax;
    std::vector<std::string> switches;
    ArgumentType argument_type;
    bool required;
    bool set_by_command_line = false;
    bool global = false;
  };

  class SetHitNodeKey
  {
    friend class Action;
    friend class ActionFactory;
    friend class Moose::Builder;
    friend class Factory;
    friend class FEProblemBase;
    friend class InputParameters;
    FRIEND_TEST(InputParametersTest, fileNames);
    SetHitNodeKey() {}
    SetHitNodeKey(const SetHitNodeKey &) {}
  };

  class SetParamHitNodeKey
  {
    friend class Moose::Builder;
    FRIEND_TEST(InputParametersTest, fileNames);
    SetParamHitNodeKey() {}
    SetParamHitNodeKey(const SetParamHitNodeKey &) {}
  };

  template <typename T>
  struct isValidCommandLineType
  {
    static constexpr bool value =
        std::is_same_v<T, std::string> || std::is_same_v<T, std::vector<std::string>> ||
        std::is_same_v<T, Real> || std::is_same_v<T, unsigned int> || std::is_same_v<T, int> ||
        std::is_same_v<T, bool> || std::is_same_v<T, MooseEnum>;
  };

  void addClassDescription(const std::string & doc_string);

  std::string getClassDescription() const;

  virtual void set_attributes(const std::string & name, bool inserted_only) override;

  std::optional<std::string> queryDeprecatedParamMessage(const std::string & name) const;

  template <typename T>
  void setHelper(const std::string & name);

  template <typename T>
  T & set(const std::string & name, bool quiet_mode = false);

  template <typename T, typename... Ts>
  void setParameters(const std::string & name, const T & value, Ts... extra_input_parameters);

  template <typename T, typename UP_T>
  std::optional<std::pair<bool, std::string>>
  rangeCheck(const std::string & full_name,
             const std::string & short_name,
             const InputParameters::Parameter<T> & param,
             const bool include_param_path = true);
  template <typename T, typename UP_T>
  std::optional<std::pair<bool, std::string>>
  rangeCheck(const std::string & full_name,
             const std::string & short_name,
             const InputParameters::Parameter<std::vector<T>> & param,
             const bool include_param_path = true);

  template <typename T>
  T getCheckedPointerParam(const std::string & name, const std::string & error_string = "") const;

  template <typename T>
  void addRequiredParam(const std::string & name, const std::string & doc_string);

  template <typename T>
  void
  addRequiredParam(const std::string & name, const T & moose_enum, const std::string & doc_string);


  template <typename T, typename S>
  void addParam(const std::string & name, const S & value, const std::string & doc_string);
  template <typename T>
  void addParam(const std::string & name, const std::string & doc_string);

  template <typename T>
  void addParam(const std::string & name,
                const std::initializer_list<typename T::value_type> & value,
                const std::string & doc_string)
  {
    addParam<T>(name, T{value}, doc_string);
  }

  // BEGIN RANGE CHECKED PARAMETER METHODS
  template <typename T>
  void addRequiredRangeCheckedParam(const std::string & name,
                                    const std::string & parsed_function,
                                    const std::string & doc_string);
  template <typename T>
  void addRangeCheckedParam(const std::string & name,
                            const T & value,
                            const std::string & parsed_function,
                            const std::string & doc_string);
  template <typename T>
  void addRangeCheckedParam(const std::string & name,
                            const std::string & parsed_function,
                            const std::string & doc_string);
  // END RANGE CHECKED PARAMETER METHODS

  template <typename T>
  void addRequiredCustomTypeParam(const std::string & name,
                                  const std::string & custom_type,
                                  const std::string & doc_string);
  template <typename T>
  void addCustomTypeParam(const std::string & name,
                          const T & value,
                          const std::string & custom_type,
                          const std::string & doc_string);
  template <typename T>
  void addCustomTypeParam(const std::string & name,
                          const std::string & custom_type,
                          const std::string & doc_string);
  template <typename T>
  void addDeprecatedCustomTypeParam(const std::string & name,
                                    const std::string & custom_type,
                                    const std::string & doc_string,
                                    const std::string & deprecation_msg);

  template <typename T>
  void addPrivateParam(const std::string & name, const T & value);
  template <typename T>
  void addPrivateParam(const std::string & name);

  template <typename T>
  void addRequiredCommandLineParam(const std::string & name,
                                   const std::string & syntax,
                                   const std::string & doc_string);
  template <typename T>
  void addCommandLineParam(const std::string & name,
                           const std::string & syntax,
                           const std::string & doc_string);
  template <typename T>
  void addCommandLineParam(const std::string & name,
                           const std::string & syntax,
                           const T & value,
                           const std::string & doc_string);
  template <typename T>
  void addCommandLineParam(const std::string & name,
                           const std::string & syntax,
                           const std::initializer_list<typename T::value_type> & value,
                           const std::string & doc_string)
  {
    addCommandLineParam<T>(name, syntax, T{value}, doc_string);
  }

  template <typename T>
  void addOptionalValuedCommandLineParam(const std::string & name,
                                         const std::string & syntax,
                                         const T & value,
                                         const std::string & doc_string);

  void setGlobalCommandLineParam(const std::string & name);

  template <typename T>
  void addDeprecatedParam(const std::string & name,
                          const T & value,
                          const std::string & doc_string,
                          const std::string & deprecation_message);

  template <typename T>
  void addDeprecatedParam(const std::string & name,
                          const std::string & doc_string,
                          const std::string & deprecation_message);

  template <typename T>
  void checkConsistentType(const std::string & name) const;

  bool isCommandLineParameter(const std::string & name) const;

  std::optional<InputParameters::CommandLineMetadata>
  queryCommandLineMetadata(const std::string & name) const;

  const InputParameters::CommandLineMetadata &
  getCommandLineMetadata(const std::string & name) const;

  class CommandLineParamSetKey
  {
    friend class CommandLine;
    FRIEND_TEST(InputParametersTest, commandLineParamSetNotCLParam);
    CommandLineParamSetKey() {}
    CommandLineParamSetKey(const CommandLineParamSetKey &) {}
  };
  void commandLineParamSet(const std::string & name, const CommandLineParamSetKey);

  const std::string & getDescription(const std::string & name) const;

  void addParamNamesToGroup(const std::string & space_delim_names, const std::string group_name);

  void renameParameterGroup(const std::string & old_name, const std::string & new_name);

  std::string getGroupName(const std::string & param_name) const;

  template <typename T>
  void suppressParameter(const std::string & name);

  template <typename T>
  void makeParamRequired(const std::string & name);

  template <typename T>
  void makeParamNotRequired(const std::string & name);

  void addCoupledVar(const std::string & name, const std::string & doc_string);

  void addDeprecatedCoupledVar(const std::string & old_name,
                               const std::string & new_name,
                               const std::string & removal_date = "");

  void addCoupledVar(const std::string & name, const Real value, const std::string & doc_string);

  void addCoupledVar(const std::string & name,
                     const std::vector<Real> & value,
                     const std::string & doc_string);


  void addCoupledVarWithAutoBuild(const std::string & name,
                                  const std::string & base_name,
                                  const std::string & num_name,
                                  const std::string & doc_string);
  void addRequiredCoupledVarWithAutoBuild(const std::string & name,
                                          const std::string & base_name,
                                          const std::string & num_name,
                                          const std::string & doc_string);

  std::string getMooseType(const std::string & name) const;
  std::vector<std::string> getVecMooseType(const std::string & name) const;

  bool isMooseBaseObject() const;

  const std::string * queryObjectType() const;

  const std::string & getObjectType() const;
  const std::string & getObjectName() const;

  void addRequiredCoupledVar(const std::string & name, const std::string & doc_string);

  std::string getDocString(const std::string & name) const;

  void setDocString(const std::string & name, const std::string & doc);

  std::string getDocUnit(const std::string & name) const;

  void setDocUnit(const std::string & name, const std::string & doc_unit);

  bool isParamRequired(const std::string & name) const;

  void makeParamNotRequired(const std::string & name);

  bool isParamValid(const std::string & name) const;

  bool isParamSetByAddParam(const std::string & name) const;

  bool isParamDeprecated(const std::string & name) const;

  bool areAllRequiredParamsValid() const;

  std::string type(const std::string & name) const;

  bool isPrivate(const std::string & name) const;

  void declareControllable(const std::string & name, std::set<ExecFlagType> execute_flags = {});

  void markControlled(const std::string & name);

  bool isControllable(const std::string & name) const;

  const std::set<ExecFlagType> & getControllableExecuteOnTypes(const std::string & name) const;

  void registerBase(const std::string & value);

  bool hasBase() const;

  const std::string & getBase() const;

  void registerSystemAttributeName(const std::string & value);

  const std::string & getSystemAttributeName() const;

  void registerBuildableTypes(const std::string & names);

  void addRelationshipManager(
      const std::string & name,
      Moose::RelationshipManagerType rm_type,
      Moose::RelationshipManagerInputParameterCallback input_parameter_callback = nullptr);

  void clearRelationshipManagers() { _buildable_rm_types.clear(); }

  const std::vector<std::string> & getBuildableTypes() const;

  const std::vector<std::tuple<std::string,
                               Moose::RelationshipManagerType,
                               Moose::RelationshipManagerInputParameterCallback>> &
  getBuildableRelationshipManagerTypes() const;


  void collapseSyntaxNesting(bool collapse);
  bool collapseSyntaxNesting() const;


  void mooseObjectSyntaxVisibility(bool visibility);
  bool mooseObjectSyntaxVisibility() const;


  using Parameters::operator=;
  using Parameters::operator+=;
  InputParameters & operator=(const InputParameters & rhs);
  InputParameters & operator+=(const InputParameters & rhs);

  void checkParams(const std::string & parsing_syntax);

  std::optional<std::pair<bool, std::string>> parameterRangeCheck(const Parameters::Value & value,
                                                                  const std::string & long_name,
                                                                  const std::string & short_name,
                                                                  const bool include_param_path);

  void finalize(const std::string & parsing_syntax);

  std::filesystem::path
  getFileBase(const std::optional<std::string> & param_name = std::optional<std::string>()) const;

  inline std::set<std::string>::const_iterator coupledVarsBegin() const
  {
    return _coupled_vars.begin();
  }
  inline std::set<std::string>::const_iterator coupledVarsEnd() const
  {
    return _coupled_vars.end();
  }

  const std::set<std::string> & getCoupledVariableParamNames() const { return _coupled_vars; }

  const std::unordered_map<std::string, std::string> & getNewToDeprecatedVarMap() const
  {
    return _new_to_deprecated_coupled_vars;
  }

  bool isRangeChecked(const std::string & param_name) const;

  std::string rangeCheckedFunction(const std::string & name) const;

  bool hasDefault(const std::string & param_name) const;

  bool hasCoupledValue(const std::string & coupling_name) const;

  bool hasDefaultCoupledValue(const std::string & coupling_name) const;

  Real defaultCoupledValue(const std::string & coupling_name, unsigned int i = 0) const;

  unsigned int numberDefaultCoupledValues(const std::string & coupling_name) const;

  void defaultCoupledValue(const std::string & coupling_name, Real value, unsigned int i = 0);

  std::map<std::string, std::pair<std::string, std::string>> getAutoBuildVectors() const;

  // BEGIN APPLY PARAMETER METHODS
  void applyParameters(const InputParameters & common,
                       const std::vector<std::string> & exclude = {},
                       const bool allow_private = false);

  void applySpecificParameters(const InputParameters & common,
                               const std::vector<std::string> & include,
                               bool allow_private = false);

  void applyParameter(const InputParameters & common,
                      const std::string & common_name,
                      bool allow_private = false,
                      bool override_default = false);
  // END APPLY PARAMETER METHODS

  void applyCoupledVar(const InputParameters & common, const std::string & var_name);

  bool paramSetByUser(const std::string & name) const;

  bool isParamSetByUser(const std::string & name) const;

  bool isParamDefined(const std::string & name) const;

  /*
   * These methods are here to retrieve parameters for scalar and vector types respectively. We will
   * throw errors
   * when returning most scalar and vector types.
   */
  template <typename T>
  static const T & getParamHelper(const std::string & name, const InputParameters & pars);

  using Parameters::get;

  template <typename R1,
            typename R2,
            typename V1 = typename std::conditional<std::is_same<R1, MooseEnumItem>::value,
                                                    MultiMooseEnum,
                                                    std::vector<R1>>::type,
            typename V2 = typename std::conditional<std::is_same<R2, MooseEnumItem>::value,
                                                    MultiMooseEnum,
                                                    std::vector<R2>>::type>
  std::vector<std::pair<R1, R2>> get(const std::string & param1, const std::string & param2) const;

  std::set<std::string> getParametersList() const;

  std::set<std::string> getControllableParameters() const;

  std::set<std::string> getGroupParameters(const std::string & group) const;

  void setReservedValues(const std::string & name, const std::set<std::string> & reserved);

  std::set<std::string> reservedValues(const std::string & name) const;

  std::string blockLocation() const;

  std::string blockFullpath() const;

  const hit::Node * getHitNode(const std::string & param) const;
  void setHitNode(const std::string & param, const hit::Node & node, const SetParamHitNodeKey);

  std::string inputLocation(const std::string & param) const;

  std::string paramFullpath(const std::string & param) const;

  std::string paramLocationPrefix(const std::string & param) const;

  template <typename... Args>
  std::string paramMessage(const std::string & param, Args... args) const;

  template <typename... Args>
  [[noreturn]] void mooseError(Args &&... args) const;

  template <typename... Args>
  [[noreturn]] void paramError(const std::string & param, Args... args) const;

  std::string rawParamVal(const std::string & param) const;

  template <typename T>
  void ignoreParameter(const std::string & name);

  bool shouldIgnore(const std::string & name);

  template <typename T>
  bool isType(const std::string & name) const;

  std::string varName(const std::string & var_param_name,
                      const std::string & moose_object_with_var_param_name) const;

  void renameParam(const std::string & old_name,
                   const std::string & new_name,
                   const std::string & new_docstring);

  void renameCoupledVar(const std::string & old_name,
                        const std::string & new_name,
                        const std::string & new_docstring);

  void deprecateParam(const std::string & old_name,
                      const std::string & new_name,
                      const std::string & removal_date);

  void deprecateCoupledVar(const std::string & old_name,
                           const std::string & new_name,
                           const std::string & removal_date);

  std::string checkForRename(const std::string & name) const;

  template <typename T>
  const T & get(std::string_view name) const;

  template <typename T>
  bool have_parameter(std::string_view name) const;

  template <typename T>
  void transferParam(const InputParameters & source_param,
                     const std::string & name,
                     const std::string & new_name = "",
                     const std::string & new_description = "");

  std::vector<std::string> paramAliases(const std::string & param_name) const;

  const hit::Node * getHitNode() const { return _hit_node; }
  void setHitNode(const hit::Node & node, const SetHitNodeKey) { _hit_node = &node; }

  bool isFinalized() const { return _finalized; }

  std::optional<Moose::DataFileUtils::Path> queryDataFileNamePath(const std::string & name) const;

  std::optional<std::string> setupVariableNames(std::vector<VariableName> & names,
                                                const hit::Node & node,
                                                const Moose::PassKey<Moose::Builder>);

private:
  // Private constructor so that InputParameters can only be created in certain places.
  InputParameters();

  void setParameters() {}

  template <typename T>
  static constexpr bool isFunctorNameType();

  template <typename T>
  std::string appendFunctorDescription(const std::string & doc_string) const;

  void setDeprecatedVarDocString(const std::string & new_name, const std::string & doc_string);

  void renameParamInternal(const std::string & old_name,
                           const std::string & new_name,
                           const std::string & docstring,
                           const std::string & removal_date);

  void renameCoupledVarInternal(const std::string & old_name,
                                const std::string & new_name,
                                const std::string & docstring,
                                const std::string & removal_date);

  std::pair<std::string, const hit::Node *> paramMessageContext(const std::string & param) const;
  std::string paramMessagePrefix(const std::string & param) const;

  struct Metadata
  {
    std::string _doc_string;
    std::string _doc_unit;
    std::string _custom_type;
    std::optional<CommandLineMetadata> _cl_data;
    std::optional<Moose::DataFileUtils::Path> _data_file_name_path;
    std::string _group;
    std::string _range_function;
    std::pair<std::string, std::string> _autobuild_vecs;
    bool _required = false;
    bool _valid = false;
    bool _is_private = false;
    bool _have_coupled_default = false;
    std::vector<Real> _coupled_default = {0};
    bool _set_by_add_param = false;
    std::set<std::string> _reserved_values;
    std::string _deprecation_message;
    const hit::Node * _hit_node;
    bool _controllable = false;
    std::set<ExecFlagType> _controllable_flags;
    bool _ignore = false;
  };

  Metadata & at(const std::string & param_name)
  {
    const auto param = checkForRename(param_name);
    if (_params.count(param) == 0)
      mooseError("param '", param, "' not present in InputParams");
    return _params[param];
  }
  const Metadata & at(const std::string & param_name) const
  {
    const auto param = checkForRename(param_name);
    if (_params.count(param) == 0)
      mooseError("param '", param, "' not present in InputParams");
    return _params.at(param);
  }

  void allowCopy(bool status) { _allow_copy = status; }

  void checkParamName(const std::string & name) const;

  template <typename T, typename S>
  void setParamHelper(const std::string & name, T & l_value, const S & r_value);

  template <typename T>
  void addCommandLineParamHelper(const std::string & name,
                                 const std::string & syntax,
                                 const bool required,
                                 const bool value_required);

  [[noreturn]] void callMooseError(std::string msg,
                                   const bool with_prefix = true,
                                   const hit::Node * node = nullptr) const;

  std::map<std::string, Metadata> _params;

  std::set<std::string> _coupled_vars;

  std::string _class_description;

  std::vector<std::string> _buildable_types;

  std::vector<std::tuple<std::string,
                         Moose::RelationshipManagerType,
                         Moose::RelationshipManagerInputParameterCallback>>
      _buildable_rm_types;

  bool _collapse_nesting;

  bool _moose_object_syntax_visibility;

  bool _show_deprecated_message;

  bool _allow_copy;

  std::unordered_map<std::string, std::string> _new_to_deprecated_coupled_vars;

  std::map<std::string, std::pair<std::string, std::string>> _old_to_new_name_and_dep;

  std::multimap<std::string, std::string> _new_to_old_names;

  const hit::Node * _hit_node;

  bool _finalized;

  // These are the only objects allowed to _create_ InputParameters
  friend InputParameters emptyInputParameters();
  friend class InputParameterWarehouse;
  friend class Parser;
  // for the printInputFile function in the action warehouse
  friend class ActionWarehouse;
};

template <typename T>
void
InputParameters::setHelper(const std::string & /*name*/)
{
}

// Template and inline function implementations
template <typename T>
T &
InputParameters::set(const std::string & name_in, bool quiet_mode)
{
  const auto name = checkForRename(name_in);

  checkParamName(name);
  checkConsistentType<T>(name);

  T & result = this->Parameters::set<T>(name);

  if (quiet_mode)
    _params[name]._set_by_add_param = true;

  setHelper<T>(name);

  return result;
}

template <typename T, typename... Ts>
void
InputParameters::setParameters(const std::string & name,
                               const T & value,
                               Ts... extra_input_parameters)
{
  this->set<T>(name) = value;
  this->setParameters(extra_input_parameters...);
}

template <typename T, typename UP_T>
std::optional<std::pair<bool, std::string>>
InputParameters::rangeCheck(const std::string & full_name,
                            const std::string & short_name,
                            const InputParameters::Parameter<std::vector<T>> & param,
                            const bool include_param_path)
{
  if (!isParamValid(short_name))
    return {};

  const auto & range_function = _params[short_name]._range_function;
  if (range_function.empty())
    return {};

  FunctionParserBase<UP_T> fp;
  std::vector<std::string> vars;
  if (fp.ParseAndDeduceVariables(range_function, vars) != -1) // -1 for success
    return {{false,
             "Error parsing expression '" + range_function + "' for parameter " + short_name + ""}};

  // Fparser parameter buffer
  std::vector<UP_T> parbuf(vars.size());

  // parameter vector
  const std::vector<T> & value = param.get();

  // iterate over all vector values (maybe ;)
  bool need_to_iterate = false;
  unsigned int i = 0;
  do
  {
    // set parameters
    for (unsigned int j = 0; j < vars.size(); j++)
    {
      if (vars[j] == short_name)
      {
        if (value.size() == 0)
        {
          std::ostringstream oss;
          oss << "Range checking empty vector";
          if (include_param_path)
            oss << " parameter " << full_name;
          oss << "; expression = '" << range_function << "'";
          return {{true, oss.str()}};
        }

        parbuf[j] = value[i];
        need_to_iterate = true;
      }
      else if (vars[j] == short_name + "_size")
        parbuf[j] = value.size();
      else
      {
        if (vars[j].substr(0, short_name.size() + 1) != short_name + "_")
          return {{false, "Error parsing expression '" + range_function + "'"}};
        std::istringstream iss(vars[j]);
        iss.seekg(short_name.size() + 1);

        size_t index;
        if (iss >> index && iss.eof())
        {
          if (index >= value.size())
          {
            std::ostringstream oss;
            oss << "Error parsing expression '" + range_function + "'";
            if (include_param_path)
              oss << " for parameter " << full_name;
            oss << "; out of range variable '" + vars[j] << "'";
            return {{true, oss.str()}};
          }
          parbuf[j] = value[index];
        }
        else
          return {{false,
                   "Error parsing expression '" + range_function + "'; invalid variable '" +
                       vars[j] + "'"}};
      }
    }

    // ensure range-checked input file parameter comparison functions
    // do absolute floating point comparisons instead of using a default epsilon.
    auto tmp_eps = fp.epsilon();
    fp.setEpsilon(0);
    UP_T result = fp.Eval(&parbuf[0]);
    fp.setEpsilon(tmp_eps);

    // test function using the parameters determined above
    if (fp.EvalError())
      return {{false, "Error evaluating expression '" + range_function + "'"}};

    if (!result)
    {
      std::ostringstream oss;
      oss << "Range check failed";
      if (include_param_path)
        oss << " for parameter " << full_name;
      oss << "; expression = '" << range_function << "'";
      if (need_to_iterate)
        oss << ", component " << i;
      return {{true, oss.str()}};
    }

  } while (need_to_iterate && ++i < value.size());

  return {};
}

template <typename T, typename UP_T>
std::optional<std::pair<bool, std::string>>
InputParameters::rangeCheck(const std::string & full_name,
                            const std::string & short_name,
                            const InputParameters::Parameter<T> & param,
                            const bool include_param_path)
{
  if (!isParamValid(short_name))
    return {};

  const auto & range_function = _params[short_name]._range_function;
  if (range_function.empty())
    return {};

  // Parse the expression
  FunctionParserBase<UP_T> fp;
  if (fp.Parse(range_function, short_name) != -1) // -1 for success
    return {{false,
             "Error parsing expression '" + range_function + "'" + " for parameter " + short_name}};

  // ensure range-checked input file parameter comparison functions
  // do absolute floating point comparisons instead of using a default epsilon.
  auto tmp_eps = fp.epsilon();
  fp.setEpsilon(0);
  // We require a non-const value for the implicit upscaling of the parameter type
  std::vector<UP_T> value(1, param.get());
  UP_T result = fp.Eval(&value[0]);
  fp.setEpsilon(tmp_eps);

  if (fp.EvalError())
    return {{true,
             "Error evaluating expression '" + range_function + "' for parameter " + short_name +
                 "; perhaps you used the wrong variable name?"}};

  if (!result)
  {
    std::ostringstream oss;
    oss << "Range check failed";
    if (include_param_path)
      oss << " for parameter " << full_name;
    oss << "; expression = '" << range_function << "', value = " << value[0];
    return {{true, oss.str()}};
  }

  return {};
}

template <typename T>
T
InputParameters::getCheckedPointerParam(const std::string & name_in,
                                        const std::string & error_string) const
{
  const auto name = checkForRename(name_in);

  T param = this->get<T>(name);

  // Note: You will receive a compile error on this line if you attempt to pass a non-pointer
  // template type to this method
  if (!param)
    mooseError("Parameter ", name, " is NULL.\n", error_string);
  return this->get<T>(name);
}

template <typename T>
void
InputParameters::addRequiredParam(const std::string & name, const std::string & doc_string)
{
  checkParamName(name);
  checkConsistentType<T>(name);

  InputParameters::insert<T>(name);
  auto & metadata = _params[name];
  metadata._required = true;
  if constexpr (isFunctorNameType<T>())
    metadata._doc_string = appendFunctorDescription<T>(doc_string);
  else
    metadata._doc_string = doc_string;
}

template <typename T>
void
InputParameters::addRequiredParam(const std::string & /*name*/,
                                  const T & /*value*/,
                                  const std::string & /*doc_string*/)
{
  mooseError("You cannot call addRequiredParam and supply a default value for this type, please "
             "use addParam instead");
}

template <typename T, typename S>
void
InputParameters::addParam(const std::string & name, const S & value, const std::string & doc_string)
{
  checkParamName(name);
  checkConsistentType<T>(name);

  T & l_value = InputParameters::set<T>(name);
  auto & metadata = _params[name];
  if constexpr (isFunctorNameType<T>())
    metadata._doc_string = appendFunctorDescription<T>(doc_string);
  else
    metadata._doc_string = doc_string;

  // Set the parameter now
  setParamHelper(name, l_value, value);

  /* Indicate the default value, as set via addParam, is being used. The parameter is removed from
     the list whenever
     it changes, see set_attributes */
  metadata._set_by_add_param = true;
}

template <typename T>
void
InputParameters::addParam(const std::string & name, const std::string & doc_string)
{
  checkParamName(name);
  checkConsistentType<T>(name);

  InputParameters::insert<T>(name);
  if constexpr (isFunctorNameType<T>())
    _params[name]._doc_string = appendFunctorDescription<T>(doc_string);
  else
    _params[name]._doc_string = doc_string;
}

template <typename T, typename S>
void
InputParameters::setParamHelper(const std::string & /*name*/, T & l_value, const S & r_value)
{
  l_value = r_value;
}

template <typename T>
void
InputParameters::addCommandLineParamHelper(const std::string & name,
                                           const std::string & syntax,
                                           const bool required,
                                           const bool value_required)
{
  static_assert(isValidCommandLineType<T>::value,
                "This type is not a supported command line parameter type. See "
                "CommandLine::populateCommandLineParams to add it as a supported type.");

  auto & cl_data = at(name)._cl_data;
  cl_data = CommandLineMetadata();

  // Split up the syntax by whitespace
  std::vector<std::string> syntax_split;
  MooseUtils::tokenize(syntax, syntax_split, 1, " \t\n\v\f\r");

  // Set the single syntax string as the combined syntax with removed whitespace
  cl_data->syntax = MooseUtils::stringJoin(syntax_split);
  mooseAssert(cl_data->syntax.size(), "Empty token");

  // Set the switches; only parse those that begin with "-" as we also
  // provide examples within the syntax
  for (const auto & val : syntax_split)
    if (val.rfind("-", 0) == 0)
    {
      if (!std::regex_search(val, std::regex("^\\-+[a-zA-Z]")))
        mooseError("The switch '",
                   val,
                   "' for the command line parameter '",
                   name,
                   "' is invalid. It must begin with an alphabetical character.");

      cl_data->switches.push_back(val);
      libMesh::add_command_line_name(val);
    }

  cl_data->required = required;
  cl_data->global = false;

  // No arguments needed for a boolean parameter
  if constexpr (std::is_same_v<T, bool>)
  {
    (void)value_required; // purposely unused; doesn't take a value
    cl_data->argument_type = CommandLineMetadata::ArgumentType::NONE;
  }
  // MooseEnums require a value
  else if constexpr (std::is_same_v<T, MooseEnum>)
  {
    (void)value_required; // purposely unused; always required
    cl_data->argument_type = CommandLineMetadata::ArgumentType::REQUIRED;
  }
  // The user didn't specify a default, so a value is required
  else if (value_required)
    cl_data->argument_type = CommandLineMetadata::ArgumentType::REQUIRED;
  // Otherwise, it's optional (user specified a default)
  else
    cl_data->argument_type = CommandLineMetadata::ArgumentType::OPTIONAL;
}

template <typename T>
void
InputParameters::addRequiredRangeCheckedParam(const std::string & name,
                                              const std::string & parsed_function,
                                              const std::string & doc_string)
{
  addRequiredParam<T>(name, doc_string);
  _params[name]._range_function = parsed_function;
}

template <typename T>
void
InputParameters::addRangeCheckedParam(const std::string & name,
                                      const T & value,
                                      const std::string & parsed_function,
                                      const std::string & doc_string)
{
  addParam<T>(name, value, doc_string);
  _params[name]._range_function = parsed_function;
}

template <typename T>
void
InputParameters::addRangeCheckedParam(const std::string & name,
                                      const std::string & parsed_function,
                                      const std::string & doc_string)
{
  addParam<T>(name, doc_string);
  _params[name]._range_function = parsed_function;
}

template <typename T>
void
InputParameters::addRequiredCustomTypeParam(const std::string & name,
                                            const std::string & custom_type,
                                            const std::string & doc_string)
{
  addRequiredParam<T>(name, doc_string);
  _params[name]._custom_type = custom_type;
}

template <typename T>
void
InputParameters::addCustomTypeParam(const std::string & name,
                                    const T & value,
                                    const std::string & custom_type,
                                    const std::string & doc_string)
{
  addParam<T>(name, value, doc_string);
  _params[name]._custom_type = custom_type;
}

template <typename T>
void
InputParameters::addCustomTypeParam(const std::string & name,
                                    const std::string & custom_type,
                                    const std::string & doc_string)
{
  addParam<T>(name, doc_string);
  _params[name]._custom_type = custom_type;
}

template <typename T>
void
InputParameters::addDeprecatedCustomTypeParam(const std::string & name,
                                              const std::string & custom_type,
                                              const std::string & doc_string,
                                              const std::string & deprecation_message)
{
  _show_deprecated_message = false;
  addParam<T>(name, doc_string);
  auto & metadata = _params[name];
  metadata._custom_type = custom_type;

  metadata._deprecation_message = deprecation_message;
  _show_deprecated_message = true;
}

template <typename T>
void
InputParameters::addPrivateParam(const std::string & name)
{
  checkParamName(name);
  checkConsistentType<T>(name);

  InputParameters::insert<T>(name);
  _params[name]._is_private = true;
}

template <typename T>
void
InputParameters::addPrivateParam(const std::string & name, const T & value)
{
  checkParamName(name);
  checkConsistentType<T>(name);

  InputParameters::set<T>(name) = value;
  auto & metadata = _params[name];
  metadata._is_private = true;
  metadata._set_by_add_param = true;
}

template <typename T>
void
InputParameters::addRequiredCommandLineParam(const std::string & name,
                                             const std::string & syntax,
                                             const std::string & doc_string)
{
  static_assert(!std::is_same_v<T, bool>, "Cannot be used for a bool");

  addRequiredParam<T>(name, doc_string);
  addCommandLineParamHelper<T>(name, syntax, /* required = */ true, /* value_required = */ true);
}

template <typename T>
void
InputParameters::addCommandLineParam(const std::string & name,
                                     const std::string & syntax,
                                     const std::string & doc_string)
{
  static_assert(!std::is_same_v<T, MooseEnum>,
                "addCommandLineParam() without a value cannot be used with a MooseEnum because a "
                "MooseEnum requires initialization");

  auto constexpr is_bool = std::is_same_v<T, bool>;
  if constexpr (is_bool)
    addParam<T>(name, false, doc_string);
  else
    addParam<T>(name, doc_string);

  addCommandLineParamHelper<T>(
      name, syntax, /* required = */ false, /* value_required = */ !is_bool);
}

template <typename T>
void
InputParameters::addCommandLineParam(const std::string & name,
                                     const std::string & syntax,
                                     const T & value,
                                     const std::string & doc_string)
{
  if constexpr (std::is_same_v<T, bool>)
    mooseAssert(!value, "Default for bool must be false");

  addParam<T>(name, value, doc_string);
  addCommandLineParamHelper<T>(name, syntax, /* required = */ false, /* value_required = */ true);
}

template <typename T>
void
InputParameters::addOptionalValuedCommandLineParam(const std::string & name,
                                                   const std::string & syntax,
                                                   const T & value,
                                                   const std::string & doc_string)
{
  mooseAssert(name == "csg_only" || name == "mesh_only" || name == "recover" || name == "run",
              "Not supported for new parameters");
  static_assert(!std::is_same_v<T, bool>, "Cannot be used for a bool (does not take a value)");
  addParam<T>(name, value, doc_string);
  addCommandLineParamHelper<T>(name, syntax, /* required = */ false, /* value_required = */ false);
}

template <typename T>
void
InputParameters::checkConsistentType(const std::string & name_in) const
{
  const auto name = checkForRename(name_in);

  // If we don't currently have the Parameter, can't be any inconsistency
  InputParameters::const_iterator it = _values.find(name);
  if (it == _values.end())
    return;

  // Now, if we already have the Parameter, but it doesn't have the
  // right type, throw an error.
  if (!this->Parameters::have_parameter<T>(name))
    mooseError("Attempting to set parameter \"",
               name,
               "\" with type (",
               libMesh::demangle(typeid(T).name()),
               ")\nbut the parameter already exists as type (",
               it->second->type(),
               ")");
}

template <typename T>
void
InputParameters::suppressParameter(const std::string & name_in)
{
  const auto name = checkForRename(name_in);
  if (!this->have_parameter<T>(name))
    mooseError("Unable to suppress nonexistent parameter: ", name);

  auto & metadata = _params[name];
  metadata._required = false;
  metadata._is_private = true;
  metadata._controllable = false;
}

template <typename T>
void
InputParameters::ignoreParameter(const std::string & name_in)
{
  const auto name = checkForRename(name_in);
  suppressParameter<T>(name);
  _params[name]._ignore = true;
}

template <typename T>
void
InputParameters::makeParamRequired(const std::string & name_in)
{
  const auto name = checkForRename(name_in);

  if (!this->have_parameter<T>(name))
    mooseError("Unable to require nonexistent parameter: ", name);

  _params[name]._required = true;
}

template <typename T>
void
InputParameters::makeParamNotRequired(const std::string & name_in)
{
  const auto name = checkForRename(name_in);

  if (!this->have_parameter<T>(name))
    mooseError("Unable to un-require nonexistent parameter: ", name);

  _params[name]._required = false;
}

template <typename T>
void
InputParameters::addDeprecatedParam(const std::string & name,
                                    const T & value,
                                    const std::string & doc_string,
                                    const std::string & deprecation_message)
{
  _show_deprecated_message = false;
  mooseAssert(!_old_to_new_name_and_dep.count(name),
              "Attempting to deprecate via addDeprecatedParam the parameter, '"
                  << name << "', already deprecated via deprecateParam or renamed via renameParam");
  addParam<T>(name, value, doc_string);

  _params[name]._deprecation_message = deprecation_message;
  _show_deprecated_message = true;
}

template <typename T>
void
InputParameters::addDeprecatedParam(const std::string & name,
                                    const std::string & doc_string,
                                    const std::string & deprecation_message)
{
  _show_deprecated_message = false;
  mooseAssert(!_old_to_new_name_and_dep.count(name),
              "Attempting to deprecate via addDeprecatedParam the parameter, '"
                  << name << "', already deprecated via deprecateParam or renamed via renameParam");
  addParam<T>(name, doc_string);

  _params[name]._deprecation_message = deprecation_message;
  _show_deprecated_message = true;
}

// Forward declare MooseEnum specializations for add*Param
template <>
void InputParameters::addRequiredParam<MooseEnum>(const std::string & name,
                                                  const MooseEnum & moose_enum,
                                                  const std::string & doc_string);

template <>
void InputParameters::addRequiredParam<MultiMooseEnum>(const std::string & name,
                                                       const MultiMooseEnum & moose_enum,
                                                       const std::string & doc_string);

template <>
void InputParameters::addRequiredParam<std::vector<MooseEnum>>(
    const std::string & name,
    const std::vector<MooseEnum> & moose_enums,
    const std::string & doc_string);

template <>
void InputParameters::addRequiredParam<std::vector<MultiMooseEnum>>(
    const std::string & name,
    const std::vector<MultiMooseEnum> & moose_enums,
    const std::string & doc_string);

template <>
void InputParameters::addParam<MooseEnum>(const std::string & /*name*/,
                                          const std::string & /*doc_string*/);

template <>
void InputParameters::addParam<MultiMooseEnum>(const std::string & /*name*/,
                                               const std::string & /*doc_string*/);

template <>
void InputParameters::addParam<std::vector<MooseEnum>>(const std::string & /*name*/,
                                                       const std::string & /*doc_string*/);

template <>
void InputParameters::addParam<std::vector<MultiMooseEnum>>(const std::string & /*name*/,
                                                            const std::string & /*doc_string*/);

template <>
void
InputParameters::addRequiredParam<std::vector<MultiMooseEnum>>(const std::string & /*name*/,
                                                               const std::string & /*doc_string*/);

template <>
void InputParameters::addPrivateParam<MooseEnum>(const std::string & /*name*/);

template <>
void InputParameters::addPrivateParam<MultiMooseEnum>(const std::string & /*name*/);

template <>
void InputParameters::addDeprecatedParam<MooseEnum>(const std::string & /*name*/,
                                                    const std::string & /*doc_string*/,
                                                    const std::string & /*deprecation_message*/);

template <>
void
InputParameters::addDeprecatedParam<MultiMooseEnum>(const std::string & /*name*/,
                                                    const std::string & /*doc_string*/,
                                                    const std::string & /*deprecation_message*/);

template <>
void InputParameters::addDeprecatedParam<std::vector<MooseEnum>>(
    const std::string & /*name*/,
    const std::string & /*doc_string*/,
    const std::string & /*deprecation_message*/);

// Forward declare specializations for setParamHelper
template <>
void InputParameters::setParamHelper<PostprocessorName, Real>(const std::string & name,
                                                              PostprocessorName & l_value,
                                                              const Real & r_value);

template <>
void InputParameters::setParamHelper<PostprocessorName, int>(const std::string & name,
                                                             PostprocessorName & l_value,
                                                             const int & r_value);

template <>
void InputParameters::setParamHelper<FunctionName, Real>(const std::string & /*name*/,
                                                         FunctionName & l_value,
                                                         const Real & r_value);

template <>
void InputParameters::setParamHelper<FunctionName, int>(const std::string & /*name*/,
                                                        FunctionName & l_value,
                                                        const int & r_value);

template <>
void InputParameters::setParamHelper<MaterialPropertyName, Real>(const std::string & /*name*/,
                                                                 MaterialPropertyName & l_value,
                                                                 const Real & r_value);

template <>
void InputParameters::setParamHelper<MaterialPropertyName, int>(const std::string & /*name*/,
                                                                MaterialPropertyName & l_value,
                                                                const int & r_value);

template <>
void InputParameters::setParamHelper<MooseFunctorName, Real>(const std::string & /*name*/,
                                                             MooseFunctorName & l_value,
                                                             const Real & r_value);

template <>
void InputParameters::setParamHelper<MooseFunctorName, int>(const std::string & /*name*/,
                                                            MooseFunctorName & l_value,
                                                            const int & r_value);

template <typename T>
const T &
InputParameters::getParamHelper(const std::string & name_in, const InputParameters & pars)
{
  const auto name = pars.checkForRename(name_in);

  if (!pars.isParamValid(name))
    pars.mooseError("The parameter \"", name, "\" is being retrieved before being set.");

  return pars.get<T>(name);
}

// Declare specializations so we don't fall back on the generic
// implementation, but the definition will be in InputParameters.C so
// we won't need to bring in *MooseEnum header files here.
template <>
const MooseEnum & InputParameters::getParamHelper<MooseEnum>(const std::string & name,
                                                             const InputParameters & pars);

template <>
const MultiMooseEnum &
InputParameters::getParamHelper<MultiMooseEnum>(const std::string & name,
                                                const InputParameters & pars);

template <typename R1, typename R2, typename V1, typename V2>
std::vector<std::pair<R1, R2>>
InputParameters::get(const std::string & param1_in, const std::string & param2_in) const
{
  const auto param1 = checkForRename(param1_in);
  const auto param2 = checkForRename(param2_in);

  const auto & v1 = get<V1>(param1);
  const auto & v2 = get<V2>(param2);

  auto controllable = getControllableParameters();
  if (controllable.count(param1) || controllable.count(param2))
    mooseError("Parameters ",
               param1,
               " and/or ",
               param2 + " are controllable parameters and cannot be retireved using "
                        "the MooseObject::getParam/InputParameters::get methods for pairs");

  if (v1.size() != v2.size())
    paramError(param1,
               "Vector parameters ",
               param1,
               "(size: ",
               v1.size(),
               ") and " + param2,
               "(size: ",
               v2.size(),
               ") are of different lengths \n");

  std::vector<std::pair<R1, R2>> parameter_pairs;
  auto i1 = v1.begin();
  auto i2 = v2.begin();
  for (; i1 != v1.end() && i2 != v2.end(); ++i1, ++i2)
    parameter_pairs.emplace_back(std::make_pair(*i1, *i2));
  return parameter_pairs;
}

InputParameters emptyInputParameters();

template <typename T>
bool
InputParameters::isType(const std::string & name_in) const
{
  const auto name = checkForRename(name_in);

  if (!_params.count(name))
    mooseError("Parameter \"", name, "\" is not valid.");
  return have_parameter<T>(name);
}

template <typename T>
const T &
InputParameters::get(std::string_view name_in) const
{
  const auto name = checkForRename(std::string(name_in));

  return Parameters::get<T>(name);
}

template <typename T>
bool
InputParameters::have_parameter(std::string_view name_in) const
{
  const auto name = checkForRename(std::string(name_in));

  return Parameters::have_parameter<T>(name);
}

template <typename T>
void
InputParameters::transferParam(const InputParameters & source_params,
                               const std::string & name_in,
                               const std::string & new_name,
                               const std::string & new_description)
{
  const auto name = source_params.checkForRename(std::string(name_in));
  const auto p_name = new_name.empty() ? name_in : new_name;
  if (!source_params.have_parameter<T>(name) && !source_params.hasCoupledValue(name))
    mooseError("The '",
               name_in,
               "' parameter could not be transferred because it does not exist with type '",
               MooseUtils::prettyCppType<T>(),
               "' in the source parameters");
  if (name != name_in)
    mooseWarning("The transferred parameter " + name_in + " is deprecated in favor of " + name +
                 " in the source parameters. The new name should likely be used for the parameter "
                 "transfer instead.");
  const std::string description =
      new_description.empty() ? source_params.getDescription(name) : new_description;

  if (source_params.isParamRequired(name))
  {
    // Check for a variable parameter
    if (source_params.hasCoupledValue(name))
      addRequiredCoupledVar(p_name, description);
    // Enums parameters have a default list of options
    else if constexpr (std::is_same_v<MooseEnum, T> || std::is_same_v<MultiMooseEnum, T>)
      addRequiredParam<T>(p_name, source_params.get<T>(name), description);
    else if (source_params.isRangeChecked(name))
      addRequiredRangeCheckedParam<T>(
          p_name, source_params.rangeCheckedFunction(name), description);
    else
      addRequiredParam<T>(p_name, description);
  }
  else
  {
    // Check for a variable parameter
    if (source_params.hasCoupledValue(name))
    {
      if (!source_params.hasDefaultCoupledValue(name))
        addCoupledVar(p_name, description);
      else if (source_params.numberDefaultCoupledValues(name) == 1)
        addCoupledVar(p_name, source_params.defaultCoupledValue(name), description);
      else
      {
        std::vector<Real> coupled_values;
        for (const auto i : libMesh::make_range(source_params.numberDefaultCoupledValues(name)))
          coupled_values.push_back(source_params.defaultCoupledValue(name, i));
        addCoupledVar(p_name, coupled_values, description);
      }
    }
    else if (source_params.isRangeChecked(name))
    {
      if (source_params.hasDefault(name))
        addRangeCheckedParam<T>(p_name,
                                source_params.get<T>(name),
                                source_params.rangeCheckedFunction(name),
                                description);
      else
        addRangeCheckedParam<T>(p_name, source_params.rangeCheckedFunction(name), description);
    }
    else if constexpr (std::is_same_v<MooseEnum, T> || std::is_same_v<MultiMooseEnum, T>)
      addParam<T>(p_name, source_params.get<T>(name), description);
    else
    {
      if (source_params.hasDefault(name))
        addParam<T>(p_name, source_params.get<T>(name), description);
      else
        addParam<T>(p_name, description);
    }
  }

  // Copy other attributes
  if (source_params.isPrivate(name))
    _params[p_name]._is_private = true;
  if (source_params.isControllable(name))
    _params[p_name]._controllable = true;
}

template <typename... Args>
[[noreturn]] void
InputParameters::mooseError(Args &&... args) const
{
  std::ostringstream oss;
  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
  callMooseError(oss.str());
}

template <typename... Args>
std::string
InputParameters::paramMessage(const std::string & param, Args... args) const
{
  std::ostringstream oss;
  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
  return paramMessagePrefix(param) + oss.str();
}

template <typename... Args>
[[noreturn]] void
InputParameters::paramError(const std::string & param, Args... args) const
{
  std::ostringstream oss;
  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
  const auto [prefix, node] = paramMessageContext(param);

  Moose::show_trace = false;
  callMooseError(prefix + oss.str(), false, node);
  Moose::show_trace = true;
}

namespace Moose
{
namespace internal
{
template <typename T>
constexpr T *
getNullptrExample()
{
  return nullptr;
}

#ifdef MOOSE_MFEM_ENABLED

template <typename T>
constexpr bool
isMFEMFunctorNameTypeHelper(T *)
{
  return std::is_same_v<T, MFEMScalarCoefficientName> ||
         std::is_same_v<T, MFEMVectorCoefficientName>;
}

template <typename T, typename A>
constexpr bool
isMFEMFunctorNameTypeHelper(std::vector<T, A> *)
{
  return isMFEMFunctorNameTypeHelper(getNullptrExample<T>());
}

#endif

template <typename T>
constexpr bool
isScalarFunctorNameTypeHelper(T *)
{
  return std::is_same_v<T, MooseFunctorName>
#ifdef MOOSE_MFEM_ENABLED
         || std::is_same_v<T, MFEMScalarCoefficientName>
#endif
      ;
}

template <typename T, typename A>
constexpr bool
isScalarFunctorNameTypeHelper(std::vector<T, A> *)
{
  return isScalarFunctorNameTypeHelper(getNullptrExample<T>());
}

template <typename T>
constexpr bool
isVectorFunctorNameTypeHelper(T *)
{
#ifdef MOOSE_MFEM_ENABLED
  return std::is_same_v<T, MFEMVectorCoefficientName>;
#else
  return false;
#endif
}

template <typename T, typename A>
constexpr bool
isVectorFunctorNameTypeHelper(std::vector<T, A> *)
{
  return isVectorFunctorNameTypeHelper(getNullptrExample<T>());
}

template <typename T>
constexpr bool
isFunctorNameTypeHelper(T * ex)
{
  return isScalarFunctorNameTypeHelper(ex) || isVectorFunctorNameTypeHelper(ex);
}
}
}

template <typename T>
constexpr bool
InputParameters::isFunctorNameType()
{
  return Moose::internal::isFunctorNameTypeHelper(Moose::internal::getNullptrExample<T>());
}

template <typename T>
std::string
InputParameters::appendFunctorDescription(const std::string & doc_string) const
{
  auto numeric_value_type = []()
  {
    if constexpr (Moose::internal::isScalarFunctorNameTypeHelper(
                      Moose::internal::getNullptrExample<T>()))
      return "number";
    else if constexpr (Moose::internal::isVectorFunctorNameTypeHelper(
                           Moose::internal::getNullptrExample<T>()))
      return "numeric vector value (enclosed in curly braces)";
    else
    {
      mooseAssert(false, "We control instantiations of this method");
      return "";
    }
  };

  return MooseUtils::trim(doc_string, ". ") + ". A functor is any of the following: a variable, " +
         (
#ifdef MOOSE_MFEM_ENABLED
             Moose::internal::isMFEMFunctorNameTypeHelper(Moose::internal::getNullptrExample<T>())
                 ? "an MFEM"
                 :
#endif
                 "a functor") +
         " material property, a function, a postprocessor or a " + numeric_value_type() + ".";
}