InputParameters.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 "libmesh/parameters.h"
 
#ifdef LIBMESH_HAVE_FPARSER
#include "libmesh/fparser.hh"
#else
template <typename T>
class FunctionParserBase
{
};
#endif
 
#include <tuple>
 
// Forward declarations
class Action;
class InputParameters;
class MooseApp;
class MooseEnum;
class MooseObject;
class MultiMooseEnum;
class Problem;
 
template <class T>
InputParameters validParams();
 
class InputParameters : public Parameters
{
public:
  InputParameters(const InputParameters & rhs);
  InputParameters(const Parameters & rhs);
 
  virtual ~InputParameters() = default;
 
  virtual void clear() override;
 
  void addClassDescription(const std::string & doc_string);
 
  std::string getClassDescription() const;
 
  virtual void set_attributes(const std::string & name, bool inserted_only) override;
 
  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 UP_T>
  void rangeCheck(const std::string & full_name,
                  const std::string & short_name,
                  InputParameters::Parameter<T> * param,
                  std::ostream & oss = Moose::out);
  template <typename T, typename UP_T>
  void rangeCheck(const std::string & full_name,
                  const std::string & short_name,
                  InputParameters::Parameter<std::vector<T>> * param,
                  std::ostream & oss = Moose::out);
 
  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);
 
  // 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 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 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;
 
  std::vector<std::string> getSyntax(const std::string & name);
 
  const std::string & getDescription(const std::string & name);
 
  void addParamNamesToGroup(const std::string & space_delim_names, const std::string group_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 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;
 
  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);
 
  bool isParamRequired(const std::string & name) const;
 
  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);
 
  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 std::set<ExecFlagType> & getControllableExecuteOnTypes(const std::string & name);
 
  void registerBase(const std::string & value);
 
  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);
 
  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; }
 
  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;
 
  const PostprocessorValue & getDefaultPostprocessorValue(const std::string & name,
                                                          bool suppress_error = false,
                                                          unsigned int index = 0) const;
 
  void setDefaultPostprocessorValue(const std::string & name,
                                    const PostprocessorValue & value,
                                    unsigned int index = 0);
 
  bool hasDefaultPostprocessorValue(const std::string & name, unsigned int index = 0) const;
 
  // BEGIN APPLY PARAMETER METHODS
  void applyParameters(const InputParameters & common,
                       std::vector<std::string> exclude = std::vector<std::string>());
 
  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);
  // 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;
 
  /*
   * These methods are here to retrieve parameters for scalar and vector types respectively. We will
   * throw errors
   * when returning most scalar types, but will allow retrieving empty vectors.
   */
  template <typename T>
  static const T &
  getParamHelper(const std::string & name, const InputParameters & pars, const T * the_type);
 
  template <typename T>
  static const std::vector<T> & getParamHelper(const std::string & name,
                                               const InputParameters & pars,
                                               const std::vector<T> * the_type);
 
  std::set<std::string> getControllableParameters() const
  {
    std::set<std::string> controllable;
    for (auto it = _params.begin(); it != _params.end(); ++it)
      if (it->second._controllable)
        controllable.insert(it->first);
    return controllable;
  }
 
  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() { return _block_location; };
 
 
  std::string & blockFullpath() { return _block_fullpath; }
  const std::string & blockFullpath() const { return _block_fullpath; }
 
 
  const std::string & inputLocation(const std::string & param) const
  {
    return at(param)._input_location;
  };
  std::string & inputLocation(const std::string & param) { return at(param)._input_location; };
 
 
  const std::string & paramFullpath(const std::string & param) const
  {
    return at(param)._param_fullpath;
  };
  std::string & paramFullpath(const std::string & param) { return at(param)._param_fullpath; };
 
  std::string & rawParamVal(const std::string & param) { return _params[param]._raw_val; };
 
  template <typename T>
  void ignoreParameter(const std::string & name);
 
  bool shouldIgnore(const std::string & name);
 
  bool isSinglePostprocessor(const std::string & pp_name) const
  {
    return !_params.find(pp_name)->second._vector_of_postprocessors;
  }
 
private:
  // Private constructor so that InputParameters can only be created in certain places.
  InputParameters();
 
  struct Metadata
  {
    std::string _doc_string;
    std::string _custom_type;
    std::vector<std::string> _cli_flag_names;
    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 _vector_of_postprocessors = false;
    std::vector<bool> _have_default_postprocessor_val = {false};
    std::vector<PostprocessorValue> _default_postprocessor_val = {0};
    bool _set_by_add_param = false;
    std::set<std::string> _reserved_values;
    std::string _deprecation_message;
    std::string _input_location;
    std::string _param_fullpath;
    std::string _raw_val;
    bool _controllable = false;
    std::set<ExecFlagType> _controllable_flags;
    bool _ignore = false;
  };
 
  Metadata & at(const std::string & param)
  {
    if (_params.count(param) == 0)
      mooseError("param '", param, "' not present in InputParams");
    return _params[param];
  }
  const Metadata & at(const std::string & param) const
  {
    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);
 
  void reserveDefaultPostprocessorValueStorage(const std::string & name, unsigned int size);
 
  void setVectorOfPostprocessors(const std::string & pp_name, bool b)
  {
    _params[pp_name]._vector_of_postprocessors = b;
  }
 
  std::string _block_location;
 
  std::string _block_fullpath;
 
  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;
 
  // These are the only objects allowed to _create_ InputParameters
  friend InputParameters emptyInputParameters();
  friend class InputParameterWarehouse;
  friend class Parser;
};
 
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, bool quiet_mode)
{
  checkParamName(name);
  checkConsistentType<T>(name);
 
  if (!this->have_parameter<T>(name))
    _values[name] = new Parameter<T>;
 
  set_attributes(name, false);
 
  if (quiet_mode)
    _params[name]._set_by_add_param = true;
 
  setHelper<T>(name);
 
  return cast_ptr<Parameter<T> *>(_values[name])->set();
}
 
template <typename T, typename UP_T>
void
InputParameters::rangeCheck(const std::string & full_name,
                            const std::string & short_name,
                            InputParameters::Parameter<std::vector<T>> * param,
                            std::ostream & oss)
{
  mooseAssert(param, "Parameter is NULL");
 
  if (!isParamValid(short_name) || _params[short_name]._range_function.empty())
    return;
 
  FunctionParserBase<UP_T> fp;
  std::vector<std::string> vars;
  if (fp.ParseAndDeduceVariables(_params[short_name]._range_function, vars) != -1) // -1 for success
  {
    oss << "Error parsing expression: " << _params[short_name]._range_function << '\n';
    return;
  }
 
  // Fparser parameter buffer
  std::vector<UP_T> parbuf(vars.size());
 
  // parameter vector
  const std::vector<T> & value = param->set();
 
  // 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)
        {
          oss << "Range checking empty vector: " << _params[short_name]._range_function << '\n';
          return;
        }
 
        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 + "_")
        {
          oss << "Error parsing expression: " << _params[short_name]._range_function << '\n';
          return;
        }
        std::istringstream iss(vars[j]);
        iss.seekg(short_name.size() + 1);
 
        size_t index;
        if (iss >> index && iss.eof())
        {
          if (index >= value.size())
          {
            oss << "Error parsing expression: " << _params[short_name]._range_function
                << "\nOut of range variable " << vars[j] << '\n';
            return;
          }
          parbuf[j] = value[index];
        }
        else
        {
          oss << "Error parsing expression: " << _params[short_name]._range_function
              << "\nInvalid variable " << vars[j] << '\n';
          return;
        }
      }
    }
 
    // 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())
    {
      oss << "Error evaluating expression: " << _params[short_name]._range_function << '\n';
      return;
    }
 
    if (!result)
    {
      oss << "Range check failed for parameter " << full_name
          << "\n\tExpression: " << _params[short_name]._range_function << "\n";
      if (need_to_iterate)
        oss << "\t Component: " << i << '\n';
    }
 
  } while (need_to_iterate && ++i < value.size());
}
 
template <typename T, typename UP_T>
void
InputParameters::rangeCheck(const std::string & full_name,
                            const std::string & short_name,
                            InputParameters::Parameter<T> * param,
                            std::ostream & oss)
{
  mooseAssert(param, "Parameter is NULL");
 
  if (!isParamValid(short_name) || _params[short_name]._range_function.empty())
    return;
 
  // Parse the expression
  FunctionParserBase<UP_T> fp;
  if (fp.Parse(_params[short_name]._range_function, short_name) != -1) // -1 for success
  {
    oss << "Error parsing expression: " << _params[short_name]._range_function << '\n';
    return;
  }
 
  // 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->set());
  UP_T result = fp.Eval(&value[0]);
  fp.setEpsilon(tmp_eps);
 
  if (fp.EvalError())
  {
    oss << "Error evaluating expression: " << _params[short_name]._range_function
        << "\nPerhaps you used the wrong variable name?\n";
    return;
  }
 
  if (!result)
    oss << "Range check failed for parameter " << full_name
        << "\n\tExpression: " << _params[short_name]._range_function << "\n\tValue: " << value[0]
        << '\n';
}
 
template <typename T>
T
InputParameters::getCheckedPointerParam(const std::string & name,
                                        const std::string & error_string) const
{
  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 == NULL)
    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);
  _params[name]._required = true;
  _params[name]._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);
  _params[name]._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 */
  _params[name]._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);
  _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::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::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;
  _params[name]._is_private = true;
  _params[name]._set_by_add_param = true;
}
 
template <typename T>
void
InputParameters::addRequiredCommandLineParam(const std::string & name,
                                             const std::string & syntax,
                                             const std::string & doc_string)
{
  addRequiredParam<T>(name, doc_string);
  MooseUtils::tokenize(syntax, _params[name]._cli_flag_names, 1, " \t\n\v\f\r");
}
 
template <typename T>
void
InputParameters::addCommandLineParam(const std::string & name,
                                     const std::string & syntax,
                                     const std::string & doc_string)
{
  addParam<T>(name, doc_string);
  MooseUtils::tokenize(syntax, _params[name]._cli_flag_names, 1, " \t\n\v\f\r");
}
 
template <typename T>
void
InputParameters::addCommandLineParam(const std::string & name,
                                     const std::string & syntax,
                                     const T & value,
                                     const std::string & doc_string)
{
  addParam<T>(name, value, doc_string);
  MooseUtils::tokenize(syntax, _params[name]._cli_flag_names, 1, " \t\n\v\f\r");
}
 
template <typename T>
void
InputParameters::checkConsistentType(const std::string & name) const
{
  // Do we have a paremeter with the same name but a different type?
  InputParameters::const_iterator it = _values.find(name);
  if (it != _values.end() && dynamic_cast<const Parameter<T> *>(it->second) == NULL)
    mooseError("Attempting to set parameter \"",
               name,
               "\" with type (",
               demangle(typeid(T).name()),
               ")\nbut the parameter already exists as type (",
               it->second->type(),
               ")");
}
 
template <typename T>
void
InputParameters::suppressParameter(const std::string & name)
{
  if (!this->have_parameter<T>(name))
    mooseError("Unable to suppress nonexistent parameter: ", name);
 
  _params[name]._required = false;
  _params[name]._is_private = true;
}
 
template <typename T>
void
InputParameters::ignoreParameter(const std::string & name)
{
  suppressParameter<T>(name);
  _params[name]._ignore = true;
}
 
template <typename T>
void
InputParameters::makeParamRequired(const std::string & name)
{
  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)
{
  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;
  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;
  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::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::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::setHelper<std::vector<PostprocessorName>>(const std::string & name);
 
template <typename T>
const T &
InputParameters::getParamHelper(const std::string & name, const InputParameters & pars, const T *)
{
  if (!pars.isParamValid(name))
    mooseError("The parameter \"", name, "\" is being retrieved before being set.\n");
 
  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,
                                                             const MooseEnum *);
 
template <>
const MultiMooseEnum & InputParameters::getParamHelper<MultiMooseEnum>(const std::string & name,
                                                                       const InputParameters & pars,
                                                                       const MultiMooseEnum *);
 
template <typename T>
const std::vector<T> &
InputParameters::getParamHelper(const std::string & name,
                                const InputParameters & pars,
                                const std::vector<T> *)
{
  return pars.get<std::vector<T>>(name);
}
 
InputParameters emptyInputParameters();
 
template <class T>
InputParameters
validParams()
{
  // If users forgot to make their (old) validParams, they screwed up and
  // should get an error - so it is okay for us to try to call the new
  // validParams static function - which will error if they didn't implement
  // the new function.  We can't have the old static assert that use to be
  // here because then the sfinae for toggling between old and new-style
  // templating will always see this function and call it even if an object
  // has *only* the new style validParams.
  return T::validParams();
}