InputParameters.C

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
 
#include "InputParameters.h"
 
// MOOSE includes
#include "MooseEnum.h"
#include "MooseTypes.h"
#include "MooseUtils.h"
#include "MultiMooseEnum.h"
#include "ExecFlagEnum.h"
#include "MooseObject.h"
#include "MooseApp.h"
 
#include "libmesh/utility.h"
#include "libmesh/simple_range.h"
 
#include "pcrecpp.h"
#include "hit/parse.h"
 
#include <cmath>
#include <filesystem>
 
InputParameters
emptyInputParameters()
{
  InputParameters params;
  return params;
}
 
InputParameters::InputParameters()
  : Parameters(),
    _collapse_nesting(false),
    _moose_object_syntax_visibility(true),
    _show_deprecated_message(true),
    _allow_copy(true),
    _hit_node(nullptr),
    _finalized(false)
{
}
 
InputParameters::InputParameters(const InputParameters & rhs)
  : Parameters(), _show_deprecated_message(true), _allow_copy(true)
{
  *this = rhs;
}
 
InputParameters::InputParameters(const Parameters & rhs)
  : _show_deprecated_message(true), _allow_copy(true)
{
  _params.clear();
  Parameters::operator=(rhs);
  _collapse_nesting = false;
  _moose_object_syntax_visibility = true;
}
 
void
InputParameters::clear()
{
  Parameters::clear();
  _params.clear();
  _coupled_vars.clear();
  _new_to_deprecated_coupled_vars.clear();
  _collapse_nesting = false;
  _moose_object_syntax_visibility = true;
  _show_deprecated_message = true;
  _allow_copy = true;
  _old_to_new_name_and_dep.clear();
  _new_to_old_names.clear();
  _hit_node = nullptr;
  _finalized = false;
}
 
void
InputParameters::addClassDescription(const std::string & doc_string)
{
  _class_description = doc_string;
}
 
void
InputParameters::set_attributes(const std::string & name_in, bool inserted_only)
{
  const auto & name = checkForRename(name_in);
 
  if (!inserted_only)
  {
    auto & metadata = _params[name];
    metadata._set_by_add_param = false;
 
    // valid_params don't make sense for MooseEnums
    if (!have_parameter<MooseEnum>(name) && !have_parameter<MultiMooseEnum>(name))
      metadata._valid = true;
  }
}
 
std::optional<std::string>
InputParameters::queryDeprecatedParamMessage(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  if (_show_deprecated_message)
  {
    auto deprecation_message = [this](const auto & name, const auto & message) -> std::string
    { return paramMessagePrefix(name) + message; };
 
    if (_params.count(name) && !libmesh_map_find(_params, name)._deprecation_message.empty())
      return deprecation_message(name,
                                 "The parameter '" + name + "' is deprecated.\n" +
                                     libmesh_map_find(_params, name)._deprecation_message);
    else if (auto it = _old_to_new_name_and_dep.find(name_in);
             it != _old_to_new_name_and_dep.end() && !it->second.second.empty())
      return deprecation_message(name_in, it->second.second);
  }
  return {};
}
 
std::string
InputParameters::getClassDescription() const
{
  return _class_description;
}
 
InputParameters &
InputParameters::operator=(const InputParameters & rhs)
{
  // An error to help minimize the segmentation faults that occure when MooseObjects do not have the
  // correct constructor
  if (!rhs._allow_copy)
  {
    // If _allow_parameter_copy is set, these should be too (see
    // InputParameterWarehouse::addInputParameters)
    const std::string & name = rhs.getObjectName();
    const std::string & type = rhs.getObjectType(); // could be empty
    const std::string name_example = type.size() ? type : "the " + name + " object";
    const std::string type_example = type.size() ? type : "MyObject";
    ::mooseError(
        "Copying of the InputParameters object for ",
        name_example,
        " is not allowed.\n\nThe likely cause for this error ",
        "is having a constructor that does not use a const reference, all constructors\nfor "
        "MooseObject based classes should be as follows:\n\n",
        "    ",
        type_example,
        "::",
        type_example,
        "(const InputParameters & parameters);");
  }
 
  Parameters::operator=(rhs);
 
  _params = rhs._params;
 
  _buildable_types = rhs._buildable_types;
  _buildable_rm_types = rhs._buildable_rm_types;
  _collapse_nesting = rhs._collapse_nesting;
  _moose_object_syntax_visibility = rhs._moose_object_syntax_visibility;
  _coupled_vars = rhs._coupled_vars;
  _new_to_deprecated_coupled_vars = rhs._new_to_deprecated_coupled_vars;
  _allow_copy = rhs._allow_copy;
  _old_to_new_name_and_dep = rhs._old_to_new_name_and_dep;
  _new_to_old_names = rhs._new_to_old_names;
  _hit_node = rhs._hit_node;
  _finalized = false;
 
  return *this;
}
 
InputParameters &
InputParameters::operator+=(const InputParameters & rhs)
{
  Parameters::operator+=(rhs);
 
  // TODO: this is not a proper merge - if a particular parameter exists in both this and rhs,
  // then we should actually smartly merge both metadata structs before storing in this.
  for (auto it = rhs._params.begin(); it != rhs._params.end(); ++it)
    _params[it->first] = it->second;
 
  _buildable_types.insert(
      _buildable_types.end(), rhs._buildable_types.begin(), rhs._buildable_types.end());
  _buildable_rm_types.insert(
      _buildable_rm_types.end(), rhs._buildable_rm_types.begin(), rhs._buildable_rm_types.end());
 
  // Collapse nesting and moose object syntax hiding are not modified with +=
  _coupled_vars.insert(rhs._coupled_vars.begin(), rhs._coupled_vars.end());
  _new_to_deprecated_coupled_vars.insert(rhs._new_to_deprecated_coupled_vars.begin(),
                                         rhs._new_to_deprecated_coupled_vars.end());
 
  _old_to_new_name_and_dep.insert(rhs._old_to_new_name_and_dep.begin(),
                                  rhs._old_to_new_name_and_dep.end());
  _new_to_old_names.insert(rhs._new_to_old_names.begin(), rhs._new_to_old_names.end());
  return *this;
}
 
void
InputParameters::setDeprecatedVarDocString(const std::string & new_name,
                                           const std::string & doc_string)
{
  auto coupled_vars_it = _new_to_deprecated_coupled_vars.find(new_name);
  if (coupled_vars_it != _new_to_deprecated_coupled_vars.end())
  {
    auto params_it = _params.find(coupled_vars_it->second);
    if (params_it == _params.end())
      mooseError("There must have been a mistake in the construction of the new to deprecated "
                 "coupled vars map because the old name ",
                 coupled_vars_it->second,
                 " doesn't exist in the parameters data.");
 
    params_it->second._doc_string = doc_string;
  }
}
 
void
InputParameters::addCoupledVar(const std::string & name, Real value, const std::string & doc_string)
{
  addParam<std::vector<VariableName>>(name, doc_string);
  _coupled_vars.insert(name);
  auto & metadata = _params[name];
  metadata._coupled_default.assign(1, value);
  metadata._have_coupled_default = true;
 
  // Set the doc string for any associated deprecated coupled var
  setDeprecatedVarDocString(name, doc_string);
}
 
void
InputParameters::addCoupledVar(const std::string & name,
                               const std::vector<Real> & value,
                               const std::string & doc_string)
{
  // std::vector<VariableName>(1, Moose::stringify(value)),
  addParam<std::vector<VariableName>>(name, doc_string);
  _coupled_vars.insert(name);
  auto & metadata = _params[name];
  metadata._coupled_default = value;
  metadata._have_coupled_default = true;
 
  // Set the doc string for any associated deprecated coupled var
  setDeprecatedVarDocString(name, doc_string);
}
 
void
InputParameters::addCoupledVar(const std::string & name, const std::string & doc_string)
{
  addParam<std::vector<VariableName>>(name, doc_string);
  _coupled_vars.insert(name);
 
  // Set the doc string for any associated deprecated coupled var
  setDeprecatedVarDocString(name, doc_string);
}
 
void
InputParameters::addDeprecatedCoupledVar(const std::string & old_name,
                                         const std::string & new_name,
                                         const std::string & removal_date /*=""*/)
{
  mooseDeprecated("Please use 'deprecateCoupledVar'");
 
  _show_deprecated_message = false;
 
  // Set the doc string if we are adding the deprecated var after the new var has already been added
  auto params_it = _params.find(new_name);
  std::string doc_string;
  if (params_it != _params.end())
    doc_string = params_it->second._doc_string;
 
  addParam<std::vector<VariableName>>(old_name, doc_string);
  _coupled_vars.insert(old_name);
  _new_to_deprecated_coupled_vars.emplace(new_name, old_name);
 
  std::string deprecation_message =
      "The coupled variable parameter '" + old_name + "' has been deprecated";
  if (!removal_date.empty())
    deprecation_message += " and will be removed " + removal_date;
  deprecation_message += ". Please use the '" + new_name + "' coupled variable parameter instead.";
  _params[old_name]._deprecation_message = deprecation_message;
  _show_deprecated_message = true;
}
 
void
InputParameters::addCoupledVarWithAutoBuild(const std::string & name,
                                            const std::string & base_name,
                                            const std::string & num_name,
                                            const std::string & doc_string)
{
  addParam<std::vector<VariableName>>(name, doc_string);
  _coupled_vars.insert(name);
  _params[name]._autobuild_vecs = std::make_pair(base_name, num_name);
 
  // Additionally there are two more parameters that need to be added:
  addParam<std::string>(base_name, doc_string + " (base_name)");
  addParam<unsigned int>(num_name, doc_string + " (num_name)");
}
 
void
InputParameters::addRequiredCoupledVarWithAutoBuild(const std::string & name,
                                                    const std::string & base_name,
                                                    const std::string & num_name,
                                                    const std::string & doc_string)
{
  addRequiredParam<std::vector<VariableName>>(name, doc_string);
 
  addCoupledVarWithAutoBuild(name, base_name, num_name, doc_string);
}
 
void
InputParameters::addRequiredCoupledVar(const std::string & name, const std::string & doc_string)
{
  addRequiredParam<std::vector<VariableName>>(name, doc_string);
  _coupled_vars.insert(name);
}
 
std::string
InputParameters::getDocString(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
 
  std::string doc_string;
  auto it = _params.find(name);
  if (it != _params.end())
    for (const auto & ch : it->second._doc_string)
    {
      if (ch == '\n')
        doc_string += " ... ";
      else
        doc_string += ch;
    }
 
  return doc_string;
}
 
void
InputParameters::setDocString(const std::string & name_in, const std::string & doc)
{
  const auto & name = checkForRename(name_in);
 
  auto it = _params.find(name);
  if (it == _params.end())
    mooseError("Unable to set the documentation string (using setDocString) for the \"",
               name,
               "\" parameter, the parameter does not exist.");
  it->second._doc_string = doc;
}
 
std::string
InputParameters::getDocUnit(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  return _params.at(name)._doc_unit;
}
 
void
InputParameters::setDocUnit(const std::string & name_in, const std::string & doc_unit)
{
  const auto & name = checkForRename(name_in);
  _params[name]._doc_unit = doc_unit;
}
 
bool
InputParameters::isParamRequired(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  return _params.count(name) > 0 && _params.at(name)._required;
}
 
void
InputParameters::makeParamNotRequired(const std::string & name_in)
{
  const auto & name = checkForRename(name_in);
 
  if (_params.count(name))
    _params[name]._required = false;
}
 
bool
InputParameters::isParamValid(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  if (have_parameter<MooseEnum>(name))
    return get<MooseEnum>(name).isValid();
  else if (have_parameter<std::vector<MooseEnum>>(name))
  {
    for (auto it = get<std::vector<MooseEnum>>(name).begin();
         it != get<std::vector<MooseEnum>>(name).end();
         ++it)
      if (!it->isValid())
        return false;
    return true;
  }
  else if (have_parameter<MultiMooseEnum>(name))
    return get<MultiMooseEnum>(name).isValid();
  else if (have_parameter<std::vector<MultiMooseEnum>>(name))
  {
    for (auto it = get<std::vector<MultiMooseEnum>>(name).begin();
         it != get<std::vector<MultiMooseEnum>>(name).end();
         ++it)
      if (!it->isValid())
        return false;
    return true;
  }
  else if (have_parameter<ExecFlagEnum>(name))
    return get<ExecFlagEnum>(name).isValid();
  else
    return _params.count(name) > 0 && _params.at(name)._valid;
}
 
bool
InputParameters::isParamSetByAddParam(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  return _params.count(name) > 0 && _params.at(name)._set_by_add_param;
}
 
bool
InputParameters::isParamDeprecated(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  return _params.count(name) > 0 && !_params.at(name)._deprecation_message.empty();
}
 
#ifdef MOOSE_KOKKOS_ENABLED
bool
InputParameters::isKokkosObject() const
{
  return isParamValid(MooseBase::kokkos_object_param);
}
#endif
 
bool
InputParameters::areAllRequiredParamsValid() const
{
  for (const auto & it : *this)
    if (isParamRequired(it.first) && !isParamValid(it.first))
      return false;
  return true;
}
 
bool
InputParameters::isPrivate(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  return _params.count(name) > 0 && _params.at(name)._is_private;
}
 
void
InputParameters::declareControllable(const std::string & input_names,
                                     std::set<ExecFlagType> execute_flags)
{
  std::vector<std::string> names;
  MooseUtils::tokenize<std::string>(input_names, names, 1, " ");
  for (auto & name_in : names)
  {
    const auto & name = checkForRename(name_in);
    auto map_iter = _params.find(name);
    if (map_iter != _params.end()) // error is handled by checkParams method
    {
      map_iter->second._controllable = true;
      map_iter->second._controllable_flags = execute_flags;
    }
    else
      mooseError("The input parameter '",
                 name,
                 "' does not exist, thus cannot be marked as controllable.");
  }
}
 
bool
InputParameters::isControllable(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  return _params.count(name) > 0 && _params.at(name)._controllable;
}
 
const std::set<ExecFlagType> &
InputParameters::getControllableExecuteOnTypes(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  return at(name)._controllable_flags;
}
 
void
InputParameters::registerBase(const std::string & value)
{
  InputParameters::set<std::string>(MooseBase::moose_base_param) = value;
  _params[MooseBase::moose_base_param]._is_private = true;
}
 
bool
InputParameters::hasBase() const
{
  return have_parameter<std::string>(MooseBase::moose_base_param);
}
 
const std::string &
InputParameters::getBase() const
{
  if (!have_parameter<std::string>(MooseBase::moose_base_param))
    mooseError("InputParameters::getBase(): Parameters do not have base; one needs to be set with "
               "registerBase()");
  return get<std::string>(MooseBase::moose_base_param);
}
 
void
InputParameters::registerSystemAttributeName(const std::string & value)
{
  InputParameters::set<std::string>("_moose_warehouse_system_name") = value;
  _params["_moose_warehouse_system_name"]._is_private = true;
}
 
const std::string &
InputParameters::getSystemAttributeName() const
{
  mooseAssert(have_parameter<std::string>("_moose_warehouse_system_name"),
              "SystemAttributeName is not available! Call 'registerSystemAttributeName' (usually "
              "in the validParams function) before you try accessing it!");
  return Parameters::get<std::string>("_moose_warehouse_system_name");
}
 
void
InputParameters::registerBuildableTypes(const std::string & names)
{
  _buildable_types.clear();
  MooseUtils::tokenize(names, _buildable_types, 1, " \t\n\v\f\r"); // tokenize on whitespace
}
 
void
InputParameters::addRelationshipManager(
    const std::string & name,
    Moose::RelationshipManagerType rm_type,
    Moose::RelationshipManagerInputParameterCallback input_parameter_callback)
{
  _buildable_rm_types.emplace_back(name, rm_type, input_parameter_callback);
}
 
const std::vector<std::string> &
InputParameters::getBuildableTypes() const
{
  return _buildable_types;
}
 
const std::vector<std::tuple<std::string,
                             Moose::RelationshipManagerType,
                             Moose::RelationshipManagerInputParameterCallback>> &
InputParameters::getBuildableRelationshipManagerTypes() const
{
  return _buildable_rm_types;
}
 
void
InputParameters::collapseSyntaxNesting(bool collapse)
{
  _collapse_nesting = collapse;
}
 
bool
InputParameters::collapseSyntaxNesting() const
{
  return _collapse_nesting;
}
 
void
InputParameters::mooseObjectSyntaxVisibility(bool visibility)
{
  _moose_object_syntax_visibility = visibility;
}
 
bool
InputParameters::mooseObjectSyntaxVisibility() const
{
  return _moose_object_syntax_visibility;
}
 
#define checkMooseType(param_type, name)                                                           \
  if (have_parameter<param_type>(name) || have_parameter<std::vector<param_type>>(name))           \
    error = "non-controllable type '" + type(name) + "' for parameter '" +                         \
            paramFullpath(param_name) + "' marked controllable";
 
void
InputParameters::checkParams(const std::string & parsing_syntax)
{
  const std::string parampath = blockFullpath() != "" ? blockFullpath() : parsing_syntax;
 
  // Required parameters
  std::vector<std::string> required_param_errors;
  for (const auto & it : *this)
  {
    const auto & param_name = checkForRename(it.first);
    if (!isParamValid(param_name) && isParamRequired(param_name))
    {
      // check if an old, deprecated name exists for this parameter that may be specified
      auto oit = _new_to_deprecated_coupled_vars.find(param_name);
      if (oit != _new_to_deprecated_coupled_vars.end() && isParamValid(oit->second))
        continue;
 
      required_param_errors.push_back("missing required parameter '" + parampath + "/" +
                                      param_name + "'\n\tDoc String: \"" +
                                      getDocString(param_name) + "\"");
    }
  }
 
  if (required_param_errors.size())
    mooseError(MooseUtils::stringJoin(required_param_errors, "\n"));
 
  // Range checked parameters
  for (const auto & [name, param_ptr] : *this)
  {
    if (const auto error = parameterRangeCheck(*param_ptr, parampath + "/" + name, name, false))
    {
      if (error->first)
        paramError(name, error->second);
      else
        mooseError("For range checked parameter '" + name + "': " + error->second);
    }
  }
 
  // Controllable parameters
  for (const auto & param_name : getControllableParameters())
  {
    if (isPrivate(param_name))
      paramError(param_name,
                 "private parameter '" + paramFullpath(param_name) + "' marked controllable");
 
    std::optional<std::string> error;
    checkMooseType(NonlinearVariableName, param_name);
    checkMooseType(AuxVariableName, param_name);
    checkMooseType(VariableName, param_name);
    checkMooseType(BoundaryName, param_name);
    checkMooseType(SubdomainName, param_name);
    checkMooseType(PostprocessorName, param_name);
    checkMooseType(VectorPostprocessorName, param_name);
    checkMooseType(UserObjectName, param_name);
    checkMooseType(MaterialPropertyName, param_name);
    if (error)
      paramError(param_name, *error);
  }
}
 
std::optional<std::pair<bool, std::string>>
InputParameters::parameterRangeCheck(const Parameters::Value & value,
                                     const std::string & long_name,
                                     const std::string & short_name,
                                     const bool include_param_path)
{
#define dynamicCastRangeCheck(type, up_type, long_name, short_name)                                \
  do                                                                                               \
  {                                                                                                \
    if (const auto scalar_p = dynamic_cast<const InputParameters::Parameter<type> *>(&value))      \
      return rangeCheck<type, up_type>(long_name, short_name, *scalar_p, include_param_path);      \
    if (const auto vector_p =                                                                      \
            dynamic_cast<const InputParameters::Parameter<std::vector<type>> *>(&value))           \
      return rangeCheck<type, up_type>(long_name, short_name, *vector_p, include_param_path);      \
  } while (0)
 
  dynamicCastRangeCheck(Real, Real, long_name, short_name);
  dynamicCastRangeCheck(int, long, long_name, short_name);
  dynamicCastRangeCheck(long, long, long_name, short_name);
  dynamicCastRangeCheck(unsigned int, long, long_name, short_name);
#undef dynamicCastRangeCheck
 
  return {};
}
 
void
InputParameters::finalize(const std::string & parsing_syntax)
{
  mooseAssert(!isFinalized(), "Already finalized");
 
  checkParams(parsing_syntax);
 
  // Set parameters that represent file types
  for (const auto & name_value : *this)
  {
    const auto & param_name = name_value.first;
    const auto & param_value = name_value.second;
 
    // Helper for setting a file typed parameter value
    const auto set_filename = [&](auto & value)
    {
      constexpr bool is_data_file_name =
          std::is_same_v<std::decay_t<decltype(value)>, DataFileName>;
 
      // We have behavior (which is gross) that requires that for
      // everything but DataFileName, if the value is empty we
      // don't bother looking for it
      if constexpr (!is_data_file_name)
      {
        if (value.empty())
          return;
      }
 
      // Setup options for searching for the path
      Moose::DataFileUtils::GetPathOptions options;
      // Associate relative path searches with the folder
      // that input file that has this parameter is located
      options.base = getFileBase(param_name);
      // If we don't explicitly have a DataFileName parameter,
      // we only want to augment cases where a data name is
      // explicitly set (like moose:file). We don't want to
      // search all other data. To presere previous behavior,
      // we also don't want to error if nothing is found; for
      // example if a relative or absolute path is not found.
      // The only time we'll error is if the data name is
      // explicitly set and the path doesn't exist in the data
      // or if that data name isn't registered.
      if constexpr (!is_data_file_name)
      {
        options.search_all_data = false;
        options.graceful = true;
      }
 
      Moose::DataFileUtils::Path path;
      try
      {
        Moose::ScopedThrowOnError scoped_throw_on_error;
        path = Moose::DataFileUtils::getPath(value, options);
      }
      catch (std::exception & e)
      {
        paramError(param_name, e.what());
      }
 
      value = path.path;
      at(param_name)._data_file_name_path = path;
    };
 
#define set_if_filename(type)                                                                      \
  else if (auto type_value = dynamic_cast<Parameters::Parameter<type> *>(param_value.get()))       \
      set_filename(type_value->set());                                                             \
  else if (auto type_values = dynamic_cast<Parameters::Parameter<std::vector<type>> *>(            \
               param_value.get())) for (auto & value : type_values->set()) set_filename(value)
 
    if (false)
      ;
    set_if_filename(FileName);
    set_if_filename(FileNameNoExtension);
    set_if_filename(MeshFileName);
    set_if_filename(MatrixFileName);
    set_if_filename(DataFileName);
#undef set_if_filename
  }
 
  _finalized = true;
}
 
std::filesystem::path
InputParameters::getFileBase(const std::optional<std::string> & param_name) const
{
  mooseAssert(!have_parameter<std::string>("_app_name"),
              "Not currently setup to work with app FileName parameters");
 
  const hit::Node * hit_node = nullptr;
 
  // Context from the individual parameter
  if (param_name)
    hit_node = getHitNode(*param_name);
  // Context from the parameters
  if (!hit_node)
    hit_node = getHitNode();
  // No hit node, so use the cwd (no input files)
  if (!hit_node)
    return std::filesystem::current_path();
 
  // Find any context that isn't command line arguments
  while (hit_node && hit_node->filename() == "CLI_ARGS")
    hit_node = hit_node->parent();
 
  // Failed to find a node up the tree that isn't a command line argument
  if (!hit_node)
  {
    const std::string error = "Input context was set via a command-line argument and does not have "
                              "sufficient context for determining a file path.";
    if (param_name)
      paramError(*param_name, error);
    else
      mooseError(error);
  }
 
  return std::filesystem::absolute(std::filesystem::path(hit_node->filename()).parent_path());
}
 
bool
InputParameters::isRangeChecked(const std::string & param_name) const
{
  const auto & name = checkForRename(param_name);
  return !_params.find(name)->second._range_function.empty();
}
 
std::string
InputParameters::rangeCheckedFunction(const std::string & param_name) const
{
  const auto & name = checkForRename(param_name);
  return _params.at(name)._range_function;
}
 
bool
InputParameters::hasDefault(const std::string & param_name) const
{
  const auto & name = checkForRename(param_name);
  if (hasDefaultCoupledValue(name))
    return true;
  // If it has a default, it's already valid
  else if (isParamSetByAddParam(name))
    return true;
  else if (isParamValid(name))
    mooseError("No way to know if the parameter '", param_name, "' has a default");
  else
    return false;
}
 
bool
InputParameters::hasCoupledVar(const std::string & coupling_name) const
{
  return _coupled_vars.find(coupling_name) != _coupled_vars.end();
}
 
void
InputParameters::setCoupledVar(const std::string & coupling_name, const std::string & value)
{
  setCoupledVar(coupling_name, std::vector<VariableName>{value});
}
 
void
InputParameters::setCoupledVar(const std::string & coupling_name,
                               const std::vector<VariableName> & values)
{
  const auto & actual_name = checkForRename(coupling_name);
 
  if (!hasCoupledVar(actual_name))
    mooseError("Unable to set coupled variable parameter '",
               coupling_name,
               "' because it was not added with addCoupledVar or addRequiredCoupledVar.");
 
  set<std::vector<VariableName>>(actual_name) = values;
}
 
const std::vector<VariableName> &
InputParameters::getCoupledVar(const std::string & coupling_name) const
{
  const auto & actual_name = checkForRename(coupling_name);
 
  if (!hasCoupledVar(actual_name))
    mooseError("Unable to get coupled variable parameter '",
               coupling_name,
               "' because it was not added with addCoupledVar or addRequiredCoupledVar.");
 
  return get<std::vector<VariableName>>(actual_name);
}
 
bool
InputParameters::hasDefaultCoupledValue(const std::string & coupling_name) const
{
  return _params.count(coupling_name) > 0 && _params.at(coupling_name)._have_coupled_default &&
         _coupled_vars.count(coupling_name) > 0;
}
 
void
InputParameters::defaultCoupledValue(const std::string & coupling_name, Real value, unsigned int i)
{
  const auto & actual_name = checkForRename(coupling_name);
  _params[actual_name]._coupled_default.resize(i + 1);
  _params[actual_name]._coupled_default[i] = value;
  _params[actual_name]._have_coupled_default = true;
}
 
Real
InputParameters::defaultCoupledValue(const std::string & coupling_name, unsigned int i) const
{
  auto value_it = _params.find(coupling_name);
 
  if (value_it == _params.end() || !value_it->second._have_coupled_default)
    mooseError("Attempted to retrieve default value for coupled variable '",
               coupling_name,
               "' when none was provided. \n\nThere are three reasons why this may have "
               "occurred:\n 1. The other version of params.addCoupledVar() should be used in order "
               "to provide a default value. \n 2. This should have been a required coupled "
               "variable added with params.addRequiredCoupledVar() \n 3. The call to get the "
               "coupled value should have been properly guarded with isCoupled()\n");
 
  return value_it->second._coupled_default.at(i);
}
 
unsigned int
InputParameters::numberDefaultCoupledValues(const std::string & coupling_name) const
{
  auto value_it = _params.find(coupling_name);
  if (value_it == _params.end())
    mooseError("Attempted to retrieve default value for coupled variable '",
               coupling_name,
               "' when none was provided.");
  return value_it->second._coupled_default.size();
}
 
std::map<std::string, std::pair<std::string, std::string>>
InputParameters::getAutoBuildVectors() const
{
  std::map<std::string, std::pair<std::string, std::string>> abv;
  for (auto it = _params.begin(); it != _params.end(); ++it)
  {
    if (!it->second._autobuild_vecs.first.empty())
      abv[it->first] = it->second._autobuild_vecs;
  }
  return abv;
}
 
std::string
InputParameters::type(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  if (!_values.count(name))
    mooseError("Parameter \"", name, "\" not found.\n\n", *this);
 
  if (_coupled_vars.find(name) != _coupled_vars.end())
    return "std::vector<VariableName>";
  else if (_params.count(name) > 0 && !_params.at(name)._custom_type.empty())
    return _params.at(name)._custom_type;
  return _values.at(name)->type();
}
 
std::string
InputParameters::getMooseType(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  std::string var;
 
  if (have_parameter<VariableName>(name))
    var = get<VariableName>(name);
  else if (have_parameter<NonlinearVariableName>(name))
    var = get<NonlinearVariableName>(name);
  else if (have_parameter<LinearVariableName>(name))
    var = get<LinearVariableName>(name);
  else if (have_parameter<AuxVariableName>(name))
    var = get<AuxVariableName>(name);
  else if (have_parameter<PostprocessorName>(name))
    var = get<PostprocessorName>(name);
  else if (have_parameter<VectorPostprocessorName>(name))
    var = get<VectorPostprocessorName>(name);
  else if (have_parameter<FunctionName>(name))
    var = get<FunctionName>(name);
  else if (have_parameter<UserObjectName>(name))
    var = get<UserObjectName>(name);
  else if (have_parameter<MaterialPropertyName>(name))
    var = get<MaterialPropertyName>(name);
  else if (have_parameter<std::string>(name))
    var = get<std::string>(name);
 
  return var;
}
 
std::vector<std::string>
InputParameters::getVecMooseType(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  std::vector<std::string> svars;
 
  if (have_parameter<std::vector<VariableName>>(name))
  {
    std::vector<VariableName> vars = get<std::vector<VariableName>>(name);
    std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
  }
  else if (have_parameter<std::vector<NonlinearVariableName>>(name))
  {
    std::vector<NonlinearVariableName> vars = get<std::vector<NonlinearVariableName>>(name);
    std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
  }
  else if (have_parameter<std::vector<AuxVariableName>>(name))
  {
    std::vector<AuxVariableName> vars = get<std::vector<AuxVariableName>>(name);
    std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
  }
  else if (have_parameter<std::vector<MaterialPropertyName>>(name))
  {
    std::vector<MaterialPropertyName> vars = get<std::vector<MaterialPropertyName>>(name);
    std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
  }
  else if (have_parameter<std::vector<std::string>>(name))
  {
    std::vector<std::string> vars = get<std::vector<std::string>>(name);
    std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
  }
 
  return svars;
}
 
bool
InputParameters::isMooseBaseObject() const
{
  return have_parameter<std::string>(MooseBase::type_param) &&
         get<std::string>(MooseBase::type_param).size() &&
         have_parameter<std::string>(MooseBase::name_param);
}
 
const std::string *
InputParameters::queryObjectType() const
{
  return have_parameter<std::string>(MooseBase::type_param)
             ? &get<std::string>(MooseBase::type_param)
             : nullptr;
}
 
const std::string &
InputParameters::getObjectType() const
{
  if (const auto type_ptr = queryObjectType())
    return *type_ptr;
  ::mooseError("InputParameters::getObjectType(): Missing '", MooseBase::type_param, "' param");
}
 
const std::string &
InputParameters::getObjectName() const
{
  if (!have_parameter<std::string>(MooseBase::name_param))
    ::mooseError("InputParameters::getObjectName(): Missing '", MooseBase::name_param, "' param");
  return get<std::string>(MooseBase::name_param);
}
 
void
InputParameters::addParamNamesToGroup(const std::string & space_delim_names,
                                      const std::string group_name)
{
  std::vector<std::string> elements;
  MooseUtils::tokenize(space_delim_names, elements, 1, " \t\n\v\f\r"); // tokenize on whitespace
 
  // Since we don't require types (templates) for this method, we need
  // to get a raw list of parameter names to compare against.
  std::set<std::string> param_names;
  for (const auto & it : *this)
    param_names.insert(it.first);
 
  for (const auto & param_name : elements)
    if (_params.count(param_name) > 0)
    {
      std::string & group = _params[param_name]._group;
      if (!group.empty() && group == group_name)
        mooseError(
            "The parameter '", param_name, "' has already been added to the group '", group, "'.");
      group = group_name;
    }
    else
      mooseError("Unable to find a parameter with name: ",
                 param_name,
                 " when adding to group ",
                 group_name,
                 '.');
}
 
void
InputParameters::moveParamToGroup(const std::string & name, const std::string & group_name)
{
  if (_params.count(name) == 0)
    mooseError(
        "Unable to find a parameter with name: ", name, " when moving to group ", group_name, '.');
  _params[name]._group = group_name;
}
 
void
InputParameters::renameParameterGroup(const std::string & old_name, const std::string & new_name)
{
  for (auto & param : _params)
    if (param.second._group == old_name)
      param.second._group = new_name;
}
 
void
InputParameters::setGlobalCommandLineParam(const std::string & name)
{
  auto & cl_data = at(checkForRename(name))._cl_data;
  if (!cl_data)
    mooseError("InputParameters::setGlobalCommandLineParam: The parameter '",
               name,
               "' is not a command line parameter");
  cl_data->global = true;
}
 
bool
InputParameters::isCommandLineParameter(const std::string & name) const
{
  return at(checkForRename(name))._cl_data.has_value();
}
 
std::optional<InputParameters::CommandLineMetadata>
InputParameters::queryCommandLineMetadata(const std::string & name) const
{
  const auto & cl_data = at(checkForRename(name))._cl_data;
  if (!cl_data)
    return {};
  return *cl_data;
}
 
const InputParameters::CommandLineMetadata &
InputParameters::getCommandLineMetadata(const std::string & name) const
{
  const auto & cl_data = at(checkForRename(name))._cl_data;
  if (!cl_data)
    mooseError("InputParameters::getCommandLineMetadata: The parameter '",
               name,
               "' is not a command line parameter");
  return *cl_data;
}
 
void
InputParameters::commandLineParamSet(const std::string & name, const CommandLineParamSetKey)
{
  auto & cl_data = at(checkForRename(name))._cl_data;
  if (!cl_data)
    mooseError("InputParameters::commandLineParamSet: The parameter '",
               name,
               "' is not a command line parameter");
  cl_data->set_by_command_line = true;
}
 
std::string
InputParameters::getGroupName(const std::string & param_name_in) const
{
  const auto & param_name = checkForRename(param_name_in);
  auto it = _params.find(param_name);
  if (it != _params.end())
    return it->second._group;
  return std::string();
}
 
void
InputParameters::applyParameters(const InputParameters & common,
                                 const std::vector<std::string> & exclude,
                                 const bool allow_private)
{
  // If we're applying all of the things, also associate the top level hit node
  if (exclude.empty() && !getHitNode() && common.getHitNode())
    setHitNode(*common.getHitNode(), {});
 
  // Loop through the common parameters
  for (const auto & it : common)
  {
    // Common parameter name
    const std::string & common_name = it.first;
    // Continue to next parameter, if the current is in list of  excluded parameters
    if (std::find(exclude.begin(), exclude.end(), common_name) != exclude.end())
      continue;
 
    applyParameter(common, common_name, allow_private);
  }
 
  // Loop through the coupled variables
  for (const auto & var_name : common._coupled_vars)
  {
    // Continue to next variable, if the current is in list of  excluded parameters
    if (std::find(exclude.begin(), exclude.end(), var_name) != exclude.end())
      continue;
 
    applyCoupledVar(common, var_name);
  }
}
 
void
InputParameters::applyCommonUserSetParameters(const InputParameters & common,
                                              const std::vector<std::string> & exclude,
                                              const bool allow_private)
{
  for (const auto & it : common)
  {
    const std::string & common_name = it.first;
    if (std::find(exclude.begin(), exclude.end(), common_name) != exclude.end())
      continue;
    if (!common.isParamSetByUser(common_name))
      continue;
    applyParameter(common, common_name, allow_private);
  }
 
  for (const auto & var_name : common._coupled_vars)
  {
    if (std::find(exclude.begin(), exclude.end(), var_name) != exclude.end())
      continue;
    if (!common.isParamSetByUser(var_name))
      continue;
    applyCoupledVar(common, var_name);
  }
}
 
void
InputParameters::applySpecificParameters(const InputParameters & common,
                                         const std::vector<std::string> & include,
                                         bool allow_private)
{
  // Loop through the common parameters
  for (const auto & it : common)
  {
    // Common parameter name
    const std::string & common_name = it.first;
 
    // Continue to next parameter, if the current is not in list of included parameters
    if (std::find(include.begin(), include.end(), common_name) == include.end())
      continue;
 
    applyParameter(common, common_name, allow_private);
  }
 
  // Loop through the coupled variables
  for (std::set<std::string>::const_iterator it = common.coupledVarsBegin();
       it != common.coupledVarsEnd();
       ++it)
  {
    // Variable name
    const std::string var_name = *it;
 
    // Continue to next variable, if the current is not in list of included parameters
    if (std::find(include.begin(), include.end(), var_name) == include.end())
      continue;
 
    applyCoupledVar(common, var_name);
  }
}
 
void
InputParameters::applyCoupledVar(const InputParameters & common, const std::string & var_name)
{
  // Disable the display of deprecated message when applying common parameters, this avoids a dump
  // of messages
  _show_deprecated_message = false;
 
  // If the local parameters has a coupled variable, populate it with the value from the common
  // parameters, if the common parameters has the coupled variable too
  if (hasCoupledVar(var_name))
  {
    if (common.hasDefaultCoupledValue(var_name))
    {
      // prepare a vector of default coupled values
      std::vector<Real> defaults(common.numberDefaultCoupledValues(var_name));
      for (unsigned int j = 0; j < common.numberDefaultCoupledValues(var_name); ++j)
        defaults[j] = common.defaultCoupledValue(var_name, j);
      addCoupledVar(var_name, defaults, common.getDocString(var_name));
    }
    else if (common.hasCoupledVar(var_name))
      addCoupledVar(var_name, common.getDocString(var_name));
  }
 
  // Enable deprecated message printing
  _show_deprecated_message = true;
}
 
void
InputParameters::applyParameter(const InputParameters & common,
                                const std::string & common_name,
                                bool allow_private)
{
  // Disable the display of deprecated message when applying common parameters, this avoids a dump
  // of messages
  _show_deprecated_message = false;
 
  const auto & local_name = checkForRename(common_name);
 
  // Extract the properties from the local parameter for the current common parameter name
  const bool local_exist = _values.find(local_name) != _values.end();
  const bool local_set = _params.count(local_name) > 0 && !_params[local_name]._set_by_add_param;
  const bool local_priv = allow_private ? false : isPrivate(local_name);
  const bool local_valid = isParamValid(local_name);
 
  // Extract the properties from the common parameter
  const bool common_exist = common._values.find(common_name) != common._values.end();
  const bool common_priv = allow_private ? false : common.isPrivate(common_name);
  const bool common_valid = common.isParamValid(common_name);
 
  /* In order to apply a common parameter 4 statements must be satisfied
   * (1) A local parameter must exist with the same name as the common parameter
   * (2) Common parameter must be valid and exist
   * (3) Local parameter must be invalid OR not have been set from its default
   * (4) Both cannot be private
   */
  if (local_exist && common_exist && common_valid && (!local_valid || !local_set) &&
      (!common_priv || !local_priv))
  {
    remove(local_name);
    _values[local_name] = common._values.find(common_name)->second->clone();
    set_attributes(local_name, false);
    _params[local_name]._set_by_add_param =
        libmesh_map_find(common._params, common_name)._set_by_add_param;
    // Keep track of where this param came from if we can. This will enable us to
    // produce param errors from objects created within an action that link to
    // the parameter in the action
    at(local_name)._hit_node = common.getHitNode(common_name);
  }
  else if (!local_exist && !common_exist)
    mooseError("InputParameters::applyParameter(): Attempted to apply invalid parameter \"",
               common_name,
               "\"");
 
  // Enable deprecated message printing
  _show_deprecated_message = true;
}
 
bool
InputParameters::paramSetByUser(const std::string & name) const
{
  mooseDeprecated("paramSetByUser() is deprecated. Use isParamSetByUser() instead.");
  return isParamSetByUser(name);
}
 
bool
InputParameters::isParamSetByUser(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  // Invalid; for sure not set by the user
  if (!isParamValid(name))
    return false;
  // Parameter is not located in the list (called Parameters::set)
  if (!_params.count(name))
    return false;
  // Special case for a command line option, which is a private parameter
  if (const auto cl_data = queryCommandLineMetadata(name))
    return cl_data->set_by_command_line;
  // Not a command line option, not set by addParam and not private
  return !_params.at(name)._set_by_add_param && !_params.at(name)._is_private;
}
 
bool
InputParameters::isParamDefined(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  return _params.count(name) > 0;
}
 
const std::string &
InputParameters::getDescription(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  auto it = _params.find(name);
  if (it == _params.end())
    mooseError("No parameter exists with the name ", name);
  return it->second._doc_string;
}
 
template <>
void
InputParameters::addRequiredParam<MooseEnum>(const std::string & name,
                                             const MooseEnum & moose_enum,
                                             const std::string & doc_string)
{
  InputParameters::set<MooseEnum>(name) = moose_enum; // valid parameter is set by set_attributes
  auto & metadata = _params[name];
  metadata._required = true;
  metadata._doc_string = doc_string;
}
 
template <>
void
InputParameters::addRequiredParam<MultiMooseEnum>(const std::string & name,
                                                  const MultiMooseEnum & moose_enum,
                                                  const std::string & doc_string)
{
  InputParameters::set<MultiMooseEnum>(name) =
      moose_enum; // valid parameter is set by set_attributes
  auto & metadata = _params[name];
  metadata._required = true;
  metadata._doc_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)
{
  InputParameters::set<std::vector<MooseEnum>>(name) =
      moose_enums; // valid parameter is set by set_attributes
  auto & metadata = _params[name];
  metadata._required = true;
  metadata._doc_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)
{
  mooseAssert(
      moose_enums.size() == 1,
      "Only 1 MultiMooseEnum is supported in addRequiredParam<std::vector<MultiMooseEnum>> for " +
          name);
  mooseAssert(!moose_enums[0].items().empty(),
              "The MultiMooseEnum in addRequiredParam<std::vector<MultiMooseEnum>> is empty for " +
                  name);
  InputParameters::set<std::vector<MultiMooseEnum>>(name) =
      moose_enums; // valid parameter is set by set_attributes
  auto & metadata = _params[name];
  metadata._required = true;
  metadata._doc_string = doc_string;
}
 
template <>
void
InputParameters::addParam<MooseEnum>(const std::string & /*name*/,
                                     const std::string & /*doc_string*/)
{
  mooseError("You must supply a MooseEnum object when using addParam, even if the parameter is not "
             "required!");
}
 
template <>
void
InputParameters::addParam<MultiMooseEnum>(const std::string & /*name*/,
                                          const std::string & /*doc_string*/)
{
  mooseError("You must supply a MultiMooseEnum object when using addParam, even if the parameter "
             "is not required!");
}
 
template <>
void
InputParameters::addParam<std::vector<MooseEnum>>(const std::string & /*name*/,
                                                  const std::string & /*doc_string*/)
{
  mooseError("You must supply a vector of MooseEnum object(s) when using addParam, even if the "
             "parameter is not required!");
}
 
template <>
void
InputParameters::addParam<std::vector<MultiMooseEnum>>(const std::string & /*name*/,
                                                       const std::string & /*doc_string*/)
{
  mooseError(
      "You must supply a vector of MultiMooseEnum object(s) when using addParam, even if the "
      "parameter is not required!");
}
 
template <>
void
InputParameters::addRequiredParam<std::vector<MultiMooseEnum>>(const std::string & /*name*/,
                                                               const std::string & /*doc_string*/)
{
  mooseError("You must supply a vector of MultiMooseEnum object(s) when using addRequiredParam!");
}
 
template <>
void
InputParameters::addPrivateParam<MooseEnum>(const std::string & /*name*/)
{
  mooseError("You must supply a MooseEnum object when using addPrivateParam, even if the parameter "
             "is not required!");
}
 
template <>
void
InputParameters::addPrivateParam<MultiMooseEnum>(const std::string & /*name*/)
{
  mooseError("You must supply a MultiMooseEnum object when using addPrivateParam, even if the "
             "parameter is not required!");
}
 
template <>
void
InputParameters::addDeprecatedParam<MooseEnum>(const std::string & /*name*/,
                                               const std::string & /*doc_string*/,
                                               const std::string & /*deprecation_message*/)
{
  mooseError("You must supply a MooseEnum object and the deprecation string when using "
             "addDeprecatedParam, even if the parameter is not required!");
}
 
template <>
void
InputParameters::addDeprecatedParam<MultiMooseEnum>(const std::string & /*name*/,
                                                    const std::string & /*doc_string*/,
                                                    const std::string & /*deprecation_message*/)
{
  mooseError("You must supply a MultiMooseEnum object and the deprecation string when using "
             "addDeprecatedParam, even if the parameter is not required!");
}
 
template <>
void
InputParameters::addDeprecatedParam<std::vector<MooseEnum>>(
    const std::string & /*name*/,
    const std::string & /*doc_string*/,
    const std::string & /*deprecation_message*/)
{
  mooseError("You must supply a vector of MooseEnum object(s) and the deprecation string when "
             "using addDeprecatedParam, even if the parameter is not required!");
}
 
template <>
void
InputParameters::setParamHelper<PostprocessorName, Real>(const std::string & /*name*/,
                                                         PostprocessorName & l_value,
                                                         const Real & r_value)
{
  // Assign the default value so that it appears in the dump
  std::ostringstream oss;
  oss << r_value;
  l_value = oss.str();
}
 
template <>
void
InputParameters::setParamHelper<PostprocessorName, int>(const std::string & /*name*/,
                                                        PostprocessorName & l_value,
                                                        const int & r_value)
{
  // Assign the default value so that it appears in the dump
  std::ostringstream oss;
  oss << r_value;
  l_value = oss.str();
}
 
template <>
void
InputParameters::setParamHelper<FunctionName, Real>(const std::string & /*name*/,
                                                    FunctionName & l_value,
                                                    const Real & r_value)
{
  // Assign the default value so that it appears in the dump
  std::ostringstream oss;
  oss << r_value;
  l_value = oss.str();
}
 
template <>
void
InputParameters::setParamHelper<FunctionName, int>(const std::string & /*name*/,
                                                   FunctionName & l_value,
                                                   const int & r_value)
{
  // Assign the default value so that it appears in the dump
  std::ostringstream oss;
  oss << r_value;
  l_value = oss.str();
}
 
template <>
void
InputParameters::setParamHelper<MaterialPropertyName, Real>(const std::string & /*name*/,
                                                            MaterialPropertyName & l_value,
                                                            const Real & r_value)
{
  // Assign the default value so that it appears in the dump
  std::ostringstream oss;
  oss << r_value;
  l_value = oss.str();
}
 
template <>
void
InputParameters::setParamHelper<MaterialPropertyName, int>(const std::string & /*name*/,
                                                           MaterialPropertyName & l_value,
                                                           const int & r_value)
{
  // Assign the default value so that it appears in the dump
  std::ostringstream oss;
  oss << r_value;
  l_value = oss.str();
}
 
template <>
void
InputParameters::setParamHelper<MooseFunctorName, Real>(const std::string & /*name*/,
                                                        MooseFunctorName & l_value,
                                                        const Real & r_value)
{
  // Assign the default value so that it appears in the dump
  std::ostringstream oss;
  oss << r_value;
  l_value = oss.str();
}
 
template <>
void
InputParameters::setParamHelper<MooseFunctorName, int>(const std::string & /*name*/,
                                                       MooseFunctorName & l_value,
                                                       const int & r_value)
{
  // Assign the default value so that it appears in the dump
  std::ostringstream oss;
  oss << r_value;
  l_value = oss.str();
}
 
template <>
const MooseEnum &
InputParameters::getParamHelper<MooseEnum>(const std::string & name_in,
                                           const InputParameters & pars)
{
  const auto & name = pars.checkForRename(name_in);
  return pars.get<MooseEnum>(name);
}
 
template <>
const MultiMooseEnum &
InputParameters::getParamHelper<MultiMooseEnum>(const std::string & name_in,
                                                const InputParameters & pars)
{
  const auto & name = pars.checkForRename(name_in);
  return pars.get<MultiMooseEnum>(name);
}
 
void
InputParameters::setReservedValues(const std::string & name_in,
                                   const std::set<std::string> & reserved)
{
  const auto & name = checkForRename(name_in);
  _params[name]._reserved_values = reserved;
}
 
std::set<std::string>
InputParameters::reservedValues(const std::string & name_in) const
{
  const auto & name = checkForRename(name_in);
  auto it = _params.find(name);
  if (it == _params.end())
    return std::set<std::string>();
  return it->second._reserved_values;
}
 
std::string
InputParameters::blockLocation() const
{
  if (const auto hit_node = getHitNode())
    return hit_node->fileLocation(/* with_column = */ false);
  return "";
}
 
std::string
InputParameters::blockFullpath() const
{
  if (const auto hit_node = getHitNode())
    return hit_node->fullpath();
  return "";
}
 
const hit::Node *
InputParameters::getHitNode(const std::string & param) const
{
  return at(param)._hit_node;
}
 
void
InputParameters::setHitNode(const std::string & param,
                            const hit::Node & node,
                            const InputParameters::SetParamHitNodeKey)
{
  mooseAssert(node.type() == hit::NodeType::Field, "Must be a field");
  at(param)._hit_node = &node;
}
 
std::string
InputParameters::inputLocation(const std::string & param) const
{
  if (const auto hit_node = getHitNode(param))
    return hit_node->fileLocation(/* with_column = */ false);
  return "";
}
 
std::string
InputParameters::paramFullpath(const std::string & param) const
{
  if (const auto hit_node = getHitNode(param))
    return hit_node->fullpath();
  return "";
}
 
void
InputParameters::checkParamName(const std::string & name) const
{
  const static pcrecpp::RE valid("[\\w:/]+");
  if (!valid.FullMatch(name))
    mooseError("Invalid parameter name: '", name, "'");
}
 
bool
InputParameters::shouldIgnore(const std::string & name_in)
{
  const auto & name = checkForRename(name_in);
  auto it = _params.find(name);
  if (it != _params.end())
    return it->second._ignore;
  mooseError("Parameter ", name, " does not exist");
}
 
std::set<std::string>
InputParameters::getGroupParameters(const std::string & group) const
{
  std::set<std::string> names;
  for (auto it = _params.begin(); it != _params.end(); ++it)
    if (it->second._group == group)
      names.emplace(it->first);
  return names;
}
 
std::set<std::string>
InputParameters::getParametersList() const
{
  std::set<std::string> param_set;
  for (auto it = _params.begin(); it != _params.end(); ++it)
    param_set.emplace(it->first);
  return param_set;
}
 
std::set<std::string>
InputParameters::getControllableParameters() const
{
  std::set<std::string> controllable;
  for (auto it = _params.begin(); it != _params.end(); ++it)
    if (it->second._controllable)
      controllable.emplace(it->first);
  return controllable;
}
 
std::string
InputParameters::paramLocationPrefix(const std::string & param) const
{
  auto prefix = param + ":";
  if (!inputLocation(param).empty())
    prefix = inputLocation(param) + ": (" + paramFullpath(param) + ")";
  return prefix;
}
 
std::string
InputParameters::rawParamVal(const std::string & param) const
{
  if (const auto hit_node = getHitNode(param))
    return hit_node->strVal();
  return "";
}
 
std::string
InputParameters::varName(const std::string & var_param_name,
                         const std::string & moose_object_with_var_param_name) const
{
  // Try the scalar version first
  std::string variable_name = getMooseType(var_param_name);
  if (variable_name == "")
  {
    auto vec = getVecMooseType(var_param_name);
 
    // Catch the (very unlikely) case where a user specifies
    // variable = '' (the empty string)
    // in their input file. This could happen if e.g. something goes
    // wrong with dollar bracket expression expansion.
    if (vec.empty())
      mooseError("Error constructing object '",
                 moose_object_with_var_param_name,
                 "' while retrieving value for '",
                 var_param_name,
                 "' parameter! Did you forget to set '",
                 var_param_name,
                 "' or set it to '' (empty string) by accident?");
 
    // When using vector variables, we are only going to use the first one in the list at the
    // interface level...
    variable_name = vec[0];
  }
 
  return variable_name;
}
 
void
InputParameters::renameParamInternal(const std::string & old_name,
                                     const std::string & new_name,
                                     const std::string & docstring,
                                     const std::string & removal_date)
{
  auto params_it = _params.find(old_name);
  if (params_it == _params.end())
    mooseError("Requested to rename parameter '",
               old_name,
               "' but that parameter name doesn't exist in the parameters object.");
  mooseAssert(params_it->second._deprecation_message.empty(),
              "Attempting to rename the parameter, '" << old_name << "', that is deprecated");
 
  auto new_metadata = std::move(params_it->second);
  if (!docstring.empty())
    new_metadata._doc_string = docstring;
  _params.emplace(new_name, std::move(new_metadata));
  _params.erase(params_it);
 
  auto values_it = _values.find(old_name);
  auto new_value = std::move(values_it->second);
  _values.emplace(new_name, std::move(new_value));
  _values.erase(values_it);
 
  std::string deprecation_message;
  if (!removal_date.empty())
    deprecation_message = "'" + old_name + "' has been deprecated and will be removed on " +
                          removal_date + ". Please use '" + new_name + "' instead.";
 
  _old_to_new_name_and_dep.emplace(old_name, std::make_pair(new_name, deprecation_message));
  _new_to_old_names.emplace(new_name, old_name);
}
 
void
InputParameters::renameCoupledVarInternal(const std::string & old_name,
                                          const std::string & new_name,
                                          const std::string & docstring,
                                          const std::string & removal_date)
{
  auto coupled_vars_it = _coupled_vars.find(old_name);
  if (coupled_vars_it == _coupled_vars.end())
    mooseError("Requested to rename coupled variable '",
               old_name,
               "' but that coupled variable name doesn't exist in the parameters object.");
 
  _coupled_vars.insert(new_name);
  _coupled_vars.erase(coupled_vars_it);
 
  renameParamInternal(old_name, new_name, docstring, removal_date);
}
 
void
InputParameters::renameParam(const std::string & old_name,
                             const std::string & new_name,
                             const std::string & new_docstring)
{
  renameParamInternal(old_name, new_name, new_docstring, "");
}
 
void
InputParameters::renameCoupledVar(const std::string & old_name,
                                  const std::string & new_name,
                                  const std::string & new_docstring)
{
  renameCoupledVarInternal(old_name, new_name, new_docstring, "");
}
 
void
InputParameters::deprecateParam(const std::string & old_name,
                                const std::string & new_name,
                                const std::string & removal_date)
{
  renameParamInternal(old_name, new_name, "", removal_date);
}
 
void
InputParameters::deprecateCoupledVar(const std::string & old_name,
                                     const std::string & new_name,
                                     const std::string & removal_date)
{
  renameCoupledVarInternal(old_name, new_name, "", removal_date);
}
 
const std::string &
InputParameters::checkForRename(const std::string & name) const
{
  if (auto it = _old_to_new_name_and_dep.find(name); it != _old_to_new_name_and_dep.end())
    return it->second.first;
  else
    return name;
}
 
std::vector<std::string>
InputParameters::paramAliases(const std::string & param_name) const
{
  mooseAssert(_values.find(param_name) != _values.end(),
              "The parameter we are searching for aliases for should exist in our parameter map");
  std::vector<std::string> aliases = {param_name};
 
  for (const auto & pr : as_range(_new_to_old_names.equal_range(param_name)))
    aliases.push_back(pr.second);
 
  return aliases;
}
 
std::optional<Moose::DataFileUtils::Path>
InputParameters::queryDataFileNamePath(const std::string & name) const
{
  return at(checkForRename(name))._data_file_name_path;
}
 
std::optional<std::string>
InputParameters::setupVariableNames(std::vector<VariableName> & names,
                                    const hit::Node & node,
                                    const Moose::PassKey<Moose::Builder>)
{
  // Whether or not a name was found
  bool has_name = false;
  // Whether or not a default value (real) was found
  bool has_default = false;
 
  // Search through the names for values that convert to Real values,
  // which are default values. If defaults are found, set appropriately
  // in the InputParameters object. Keep track of if names or defaults
  // were found because we don't allow having both
  for (const auto i : index_range(names))
  {
    auto & name = names[i];
    Real real_value;
    if (MooseUtils::convert<Real>(name, real_value, false))
    {
      has_default = true;
      defaultCoupledValue(node.path(), real_value, i);
    }
    else
      has_name = true;
  }
 
  if (has_default)
  {
    if (has_name)
      return {"invalid value for '" + node.fullpath() +
              "': coupled vectors where some parameters are reals and others are variables are not "
              "supported"};
 
    // Don't actually use the names if these don't represent names
    names.clear();
  }
 
  return {};
}
 
std::pair<std::string, const hit::Node *>
InputParameters::paramMessageContext(const std::string & param) const
{
  const hit::Node * node = nullptr;
 
  std::string fullpath;
  // First try to find the parameter
  if (const hit::Node * param_node = getHitNode(param))
  {
    fullpath = param_node->fullpath();
    node = param_node;
  }
  // If no parameter node, hope for a block node
  else if (const hit::Node * block_node = getHitNode())
  {
    node = block_node;
    fullpath = block_node->fullpath() + "/" + param;
  }
  // Didn't find anything, at least use the parameter
  else
    fullpath = param;
 
  return {fullpath + ": ", node};
}
 
std::string
InputParameters::paramMessagePrefix(const std::string & param) const
{
  auto [prefix, node] = paramMessageContext(param);
  if (node)
    prefix = Moose::hitMessagePrefix(*node) + prefix;
  return prefix;
}
 
[[noreturn]] void
InputParameters::callMooseError(std::string msg,
                                const bool with_prefix /* = true */,
                                const hit::Node * node /* = nullptr */,
                                const bool show_trace /* = true */) const
{
  // Find the context of the app if we can. This will let our errors be
  // prefixed by the multiapp name (if applicable) and will flush the
  // console before outputting an error
  MooseApp * app = nullptr;
  if (isMooseBaseObject() && have_parameter<MooseApp *>(MooseBase::app_param))
    app = get<MooseApp *>(MooseBase::app_param);
 
  MooseBase::callMooseError(app, *this, msg, with_prefix, node, show_trace);
}