Parser Class Reference

Class for parsing input files. More...

#include <Parser.h>

Inheritance diagram for Parser:

Public Types
enum	SyntaxFormatterType { INPUT_FILE, YAML }

Public Member Functions
	Parser (MooseApp &app, ActionWarehouse &action_wh)
virtual	~Parser ()
std::string	getFileName (bool stripLeadingPath=true) const
	Return the filename that was parsed. More...
void	parse (const std::string &input_filename)
	Parse an input file consisting of hit syntax and setup objects in the MOOSE derived application. More...
void	extractParams (const std::string &prefix, InputParameters &p)
	This function attempts to extract values from the input file based on the contents of the passed parameters objects. More...
void	initSyntaxFormatter (SyntaxFormatterType type, bool dump_mode)
	Creates a syntax formatter for printing. More...
void	buildFullTree (const std::string &search_string)
	Use MOOSE Factories to construct a full parse tree for documentation or echoing input. More...
void	buildJsonSyntaxTree (JsonSyntaxTree &tree) const
	Use MOOSE Factories to construct a parameter tree for documentation or echoing input. More...
void	walk (const std::string &fullpath, const std::string &nodepath, hit::Node *n)
void	errorCheck (const Parallel::Communicator &comm, bool warn_unused, bool err_unused)
std::vector< std::string >	listValidParams (std::string &section_name)

Public Attributes
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects. More...

Protected Member Functions
template<typename T , typename Base >
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< T > *param, bool in_global, GlobalParamsAction *global_block)
	Helper functions for setting parameters of arbitrary types - bodies are in the .C file since they are called only from this Object. More...
template<typename T , typename UP_T , typename Base >
void	setScalarValueTypeParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< T > *param, bool in_global, GlobalParamsAction *global_block)
template<typename T , typename Base >
void	setVectorParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< T >> *param, bool in_global, GlobalParamsAction *global_block)
	Template method for setting any vector type parameter read from the input file or command line. More...
template<typename T >
void	setFilePathParam (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< T > *param, InputParameters &params, bool in_global, GlobalParamsAction *global_block)
	Sets an input parameter representing a file path using input file data. More...
template<typename T >
void	setVectorFilePathParam (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< T >> *param, InputParameters &params, bool in_global, GlobalParamsAction *global_block)
	Sets an input parameter representing a vector of file paths using input file data. More...
template<typename T >
void	setDoubleIndexParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< std::vector< T >>> *param, bool in_global, GlobalParamsAction *global_block)
	Template method for setting any double indexed type parameter read from the input file or command line. More...
template<typename T >
void	setScalarComponentParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< T > *param, bool in_global, GlobalParamsAction *global_block)
	Template method for setting any multivalue "scalar" type parameter read from the input file or command line. More...
template<typename T >
void	setVectorComponentParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< T >> *param, bool in_global, GlobalParamsAction *global_block)
	Template method for setting several multivalue "scalar" type parameter read from the input file or command line. More...
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< RealVectorValue > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< Point > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< PostprocessorName > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< MooseEnum > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< MultiMooseEnum > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< ExecFlagEnum > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< RealTensorValue > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setVectorParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< RealVectorValue >> *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setVectorParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< Point >> *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setVectorParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< MooseEnum >> *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setVectorParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< VariableName >> *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< RealVectorValue > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< Point > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< MooseEnum > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< MultiMooseEnum > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< ExecFlagEnum > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< RealTensorValue > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< PostprocessorName > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setVectorParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< RealVectorValue >> *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setVectorParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< Point >> *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setVectorParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< MooseEnum >> *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setVectorParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< VariableName >> *param, bool, GlobalParamsAction *)
	Specialization for coupling vectors. More...

Protected Attributes
std::unique_ptr< hit::Node >	_cli_root = nullptr
std::unique_ptr< hit::Node >	_root = nullptr
std::vector< std::string >	_secs_need_first
MooseApp &	_app
	The MooseApp this Parser is part of. More...
Factory &	_factory
	The Factory associated with that MooseApp. More...
ActionWarehouse &	_action_wh
	Action warehouse that will be filled by actions. More...
ActionFactory &	_action_factory
	The Factory that builds actions. More...
Syntax &	_syntax
	Reference to an object that defines input file syntax. More...
std::unique_ptr< SyntaxTree >	_syntax_formatter
	Object for holding the syntax parse tree. More...
std::string	_input_filename
	The input file name that is used for parameter extraction. More...
std::set< std::string >	_extracted_vars
	The set of all variables extracted from the input file. More...
bool	_sections_read
	Boolean to indicate whether parsing has started (sections have been extracted) More...
InputParameters *	_current_params
	The current parameter object for which parameters are being extracted. More...
std::ostringstream *	_current_error_stream
	The current stream object used for capturing errors during extraction. More...

Private Member Functions
std::string	hitCLIFilter (std::string appname, const std::vector< std::string > &argv)
void	walkRaw (std::string fullpath, std::string nodepath, hit::Node *n)

Private Attributes
std::string	_errmsg
std::string	_warnmsg

Detailed Description

Class for parsing input files.

This class utilizes the GetPot library for actually tokenizing and parsing files. It is not currently designed for extensibility. If you wish to build your own parser, please contact the MOOSE team for guidance.

Definition at line 96 of file Parser.h.

Member Enumeration Documentation

SyntaxFormatterType

enum Parser::SyntaxFormatterType

Enumerator
INPUT_FILE
YAML

Definition at line 99 of file Parser.h.

  {
    INPUT_FILE,
    YAML
  };

Constructor & Destructor Documentation

Parser()

Parser::Parser	(	MooseApp &	app,
		ActionWarehouse &	action_wh
	)

Definition at line 51 of file Parser.C.

  : ConsoleStreamInterface(app),
    _app(app),
    _factory(app.getFactory()),
    _action_wh(action_wh),
    _action_factory(app.getActionFactory()),
    _syntax(_action_wh.syntax()),
    _syntax_formatter(nullptr),
    _sections_read(false),
    _current_params(nullptr),
    _current_error_stream(nullptr)
{
}

~Parser()

Parser::~Parser ( )

virtual

Definition at line 65 of file Parser.C.

{}

Member Function Documentation

buildFullTree()

void Parser::buildFullTree

(

const std::string &

search_string

)

Use MOOSE Factories to construct a full parse tree for documentation or echoing input.

If the task is nullptr that means we need to figure out which task goes with this syntax for the purpose of building the Moose Object part of the tree. We will figure this out by asking the ActionFactory for the registration info.

We need to see if this action is inherited from MooseObjectAction. If it is, then we will loop over all the Objects in MOOSE's Factory object to print them out if they have associated bases matching the current task.

Now that we know that this is a MooseObjectAction we need to see if it has been restricted in any way by the user.

Definition at line 767 of file Parser.C.

Referenced by MooseApp::setupOptions().

{
  std::vector<std::pair<std::string, Syntax::ActionInfo>> all_names;

  for (const auto & iter : _syntax.getAssociatedActions())
  {
    Syntax::ActionInfo act_info = iter.second;
    if (act_info._task == "")
      act_info._task = _action_factory.getTaskName(act_info._action);

    all_names.push_back(std::pair<std::string, Syntax::ActionInfo>(iter.first, act_info));
  }

  for (const auto & act_names : all_names)
  {
    InputParameters action_obj_params = _action_factory.getValidParams(act_names.second._action);
    _syntax_formatter->insertNode(
        act_names.first, act_names.second._action, true, &action_obj_params);

    const std::string & task = act_names.second._task;
    std::string act_name = act_names.first;

    if (action_obj_params.have_parameter<bool>("isObjectAction") &&
        action_obj_params.get<bool>("isObjectAction"))
    {
      for (registeredMooseObjectIterator moose_obj = _factory.registeredObjectsBegin();
           moose_obj != _factory.registeredObjectsEnd();
           ++moose_obj)
      {
        InputParameters moose_obj_params = (moose_obj->second)();
        const std::vector<std::string> & buildable_types = action_obj_params.getBuildableTypes();

        // See if the current Moose Object syntax belongs under this Action's block
        if ((buildable_types.empty() || // Not restricted
             std::find(buildable_types.begin(), buildable_types.end(), moose_obj->first) !=
                 buildable_types.end()) &&                                 // Restricted but found
            moose_obj_params.have_parameter<std::string>("_moose_base") && // Has a registered base
            _syntax.verifyMooseObjectTask(moose_obj_params.get<std::string>("_moose_base"),
                                          task) &&             // and that base is associated
            action_obj_params.mooseObjectSyntaxVisibility() && // and the Action says it's visible
            moose_obj->first.find("<JACOBIAN>") ==
                std::string::npos) // And it is not a Jacobian templated AD object
        {
          std::string name;
          size_t pos = 0;
          bool is_action_params = false;
          if (act_name[act_name.size() - 1] == '*')
          {
            pos = act_name.size();

            // Remove <RESIDUAL> append for AD objects
            std::string obj_name = moose_obj->first;
            removeSubstring(obj_name, "<RESIDUAL>");

            if (!action_obj_params.collapseSyntaxNesting())
              name = act_name.substr(0, pos - 1) + obj_name;
            else
            {
              name = act_name.substr(0, pos - 1) + "/<type>/" + moose_obj->first;
              is_action_params = true;
            }
          }
          else
          {
            name = act_name + "/<type>/" + moose_obj->first;
          }

          moose_obj_params.set<std::string>("type") = moose_obj->first;

          _syntax_formatter->insertNode(
              name, moose_obj->first, is_action_params, &moose_obj_params);
        }
      }
    }
  }

  // Do not change to _console, we need this printed to the stdout in all cases
  Moose::out << _syntax_formatter->print(search_string) << std::flush;
}

buildJsonSyntaxTree()

void Parser::buildJsonSyntaxTree

(

JsonSyntaxTree &

tree

)

const

Use MOOSE Factories to construct a parameter tree for documentation or echoing input.

If the task is nullptr that means we need to figure out which task goes with this syntax for the purpose of building the Moose Object part of the tree. We will figure this out by asking the ActionFactory for the registration info.

We need to see if this action is inherited from MooseObjectAction. If it is, then we will loop over all the Objects in MOOSE's Factory object to print them out if they have associated bases matching the current task.

Definition at line 649 of file Parser.C.

Referenced by MooseApp::setupOptions().

{
  std::vector<std::pair<std::string, Syntax::ActionInfo>> all_names;

  for (const auto & iter : _syntax.getAssociatedTypes())
    root.addSyntaxType(iter.first, iter.second);

  for (const auto & iter : _syntax.getAssociatedActions())
  {
    Syntax::ActionInfo act_info = iter.second;
    if (act_info._task == "")
      act_info._task = _action_factory.getTaskName(act_info._action);

    all_names.push_back(std::make_pair(iter.first, act_info));
  }

  for (const auto & act_names : all_names)
  {
    const auto & act_info = act_names.second;
    const std::string & action = act_info._action;
    const std::string & task = act_info._task;
    const std::string act_name = act_names.first;
    InputParameters action_obj_params = _action_factory.getValidParams(action);
    bool params_added = root.addParameters("",
                                           act_name,
                                           false,
                                           action,
                                           true,
                                           &action_obj_params,
                                           _syntax.getLineInfo(act_name, action, ""),
                                           "");

    if (params_added)
    {
      auto tasks = _action_factory.getTasksByAction(action);
      for (auto & t : tasks)
      {
        auto info = _action_factory.getLineInfo(action, t);
        root.addActionTask(act_name, action, t, info);
      }
    }

    if (action_obj_params.have_parameter<bool>("isObjectAction") &&
        action_obj_params.get<bool>("isObjectAction"))
    {
      for (registeredMooseObjectIterator moose_obj = _factory.registeredObjectsBegin();
           moose_obj != _factory.registeredObjectsEnd();
           ++moose_obj)
      {
        InputParameters moose_obj_params = (moose_obj->second)();
        // Now that we know that this is a MooseObjectAction we need to see if it has been
        // restricted
        // in any way by the user.
        const std::vector<std::string> & buildable_types = action_obj_params.getBuildableTypes();

        // See if the current Moose Object syntax belongs under this Action's block
        if ((buildable_types.empty() || // Not restricted
             std::find(buildable_types.begin(), buildable_types.end(), moose_obj->first) !=
                 buildable_types.end()) &&                                 // Restricted but found
            moose_obj_params.have_parameter<std::string>("_moose_base") && // Has a registered base
            _syntax.verifyMooseObjectTask(moose_obj_params.get<std::string>("_moose_base"),
                                          task) &&             // and that base is associated
            action_obj_params.mooseObjectSyntaxVisibility() && // and the Action says it's visible
            moose_obj->first.find("<JACOBIAN>") ==
                std::string::npos) // And it is not a Jacobian templated AD object
        {
          std::string name;
          size_t pos = 0;
          bool is_action_params = false;
          bool is_type = false;
          if (act_name[act_name.size() - 1] == '*')
          {
            pos = act_name.size();

            if (!action_obj_params.collapseSyntaxNesting())
              name = act_name.substr(0, pos - 1) + moose_obj->first;
            else
            {
              name = act_name.substr(0, pos - 1) + "/<type>/" + moose_obj->first;
              is_action_params = true;
            }
          }
          else
          {
            name = act_name + "/<type>/" + moose_obj->first;
            is_type = true;
          }

          moose_obj_params.set<std::string>("type") = moose_obj->first;

          auto lineinfo = _factory.getLineInfo(moose_obj->first);
          std::string classname = _factory.associatedClassName(moose_obj->first);
          root.addParameters(act_name,
                             name,
                             is_type,
                             moose_obj->first,
                             is_action_params,
                             &moose_obj_params,
                             lineinfo,
                             classname);
        }
      }
    }
  }
  root.addGlobal();
}

errorCheck()

void Parser::errorCheck	(	const Parallel::Communicator &	comm,
		bool	warn_unused,
		bool	err_unused
	)

Definition at line 582 of file Parser.C.

Referenced by MooseApp::errorCheck().

{
  // this if guard is important in case the simulation was not configured via parsed input text -
  // e.g.  configured programatically.
  if (!_root || !_cli_root)
    return;

  UnusedWalker uw(_input_filename, _extracted_vars, *this);
  UnusedWalker uwcli("CLI_ARG", _extracted_vars, *this);

  _root->walk(&uw);
  _cli_root->walk(&uwcli);

  auto cli = _app.commandLine();
  if (warn_unused)
  {
    for (auto arg : cli->unused(comm))
      _warnmsg += hit::errormsg("CLI_ARG",
                                nullptr,
                                "unused command line parameter '",
                                cli->getArguments()[arg],
                                "'") +
                  "\n";
    for (auto & msg : uwcli.errors)
      _warnmsg += msg + "\n";
    for (auto & msg : uw.errors)
      _warnmsg += msg + "\n";
  }
  else if (err_unused)
  {
    for (auto arg : cli->unused(comm))
      _errmsg += hit::errormsg("CLI_ARG",
                               nullptr,
                               "unused command line parameter '",
                               cli->getArguments()[arg],
                               "'") +
                 "\n";
    for (auto & msg : uwcli.errors)
      _errmsg += msg + "\n";
    for (auto & msg : uw.errors)
      _errmsg += msg + "\n";
  }

  if (_warnmsg.size() > 0)
    mooseUnused(_warnmsg);
  if (_errmsg.size() > 0)
    mooseError(_errmsg);
}

extractParams()

void Parser::extractParams	(	const std::string &	prefix,
		InputParameters &	p
	)

This function attempts to extract values from the input file based on the contents of the passed parameters objects.

It handles a number of various types with dynamic casting including vector types

Special case handling if the parameter wasn't found in the input file or the cli object the logic in this branch will execute

Scalar types

Definition at line 957 of file Parser.C.

Referenced by walkRaw().

{
  std::ostringstream error_stream;
  static const std::string global_params_task = "set_global_params";
  static const std::string global_params_block_name =
      _syntax.getSyntaxByAction("GlobalParamsAction").front();

  ActionIterator act_iter = _action_wh.actionBlocksWithActionBegin(global_params_task);
  GlobalParamsAction * global_params_block = nullptr;

  // We are grabbing only the first
  if (act_iter != _action_wh.actionBlocksWithActionEnd(global_params_task))
    global_params_block = dynamic_cast<GlobalParamsAction *>(*act_iter);

  // Set a pointer to the current InputParameters object being parsed so that it can be referred
  // to
  // in the extraction routines
  _current_params = &p;
  _current_error_stream = &error_stream;
  for (const auto & it : p)
  {
    bool found = false;
    bool in_global = false;
    std::string orig_name = prefix + "/" + it.first;
    std::string full_name = orig_name;

    // Mark parameters appearing in the input file or command line
    if (_root->find(full_name) && _root->find(full_name)->type() == hit::NodeType::Field)
    {
      p.set_attributes(it.first, false);
      _extracted_vars.insert(
          full_name); // Keep track of all variables extracted from the input file
      found = true;
      p.inputLocation(it.first) =
          _input_filename + ":" + std::to_string(_root->find(full_name)->line());
      p.paramFullpath(it.first) = full_name;
    }
    // Wait! Check the GlobalParams section
    else if (global_params_block)
    {
      full_name = global_params_block_name + "/" + it.first;
      if (_root->find(full_name))
      {
        p.set_attributes(it.first, false);
        _extracted_vars.insert(
            full_name); // Keep track of all variables extracted from the input file
        found = true;
        in_global = true;
        p.inputLocation(it.first) =
            _input_filename + ":" + std::to_string(_root->find(full_name)->line());
        p.paramFullpath(it.first) = full_name;
      }
    }

    if (!found)
    {
      // In the case where we have OutFileName but it wasn't actually found in the input filename,
      // we will populate it with the actual parsed filename which is available here in the
      // parser.

      InputParameters::Parameter<OutFileBase> * scalar_p =
          dynamic_cast<InputParameters::Parameter<OutFileBase> *>(it.second);
      if (scalar_p)
      {
        std::string input_file_name = getFileName();
        mooseAssert(input_file_name != "", "Input Filename is nullptr");
        size_t pos = input_file_name.find_last_of('.');
        mooseAssert(pos != std::string::npos, "Unable to determine suffix of input file name");
        scalar_p->set() = input_file_name.substr(0, pos) + "_out";
        p.set_attributes(it.first, false);
      }
    }
    else
    {
      if (p.isPrivate(it.first))
        mooseError("The parameter '",
                   full_name,
                   "' is a private parameter and should not be used in an input file.");

      auto par = it.second;
      auto short_name = it.first;

#define setscalarvaltype(ptype, base, range)                                                       \
  else if (par->type() == demangle(typeid(ptype).name()))                                          \
      setScalarValueTypeParameter<ptype, range, base>(                                             \
          full_name,                                                                               \
          short_name,                                                                              \
          dynamic_cast<InputParameters::Parameter<ptype> *>(par),                                  \
          in_global,                                                                               \
          global_params_block)
#define setscalar(ptype, base)                                                                     \
  else if (par->type() == demangle(typeid(ptype).name()))                                          \
      setScalarParameter<ptype, base>(full_name,                                                   \
                                      short_name,                                                  \
                                      dynamic_cast<InputParameters::Parameter<ptype> *>(par),      \
                                      in_global,                                                   \
                                      global_params_block)
#define setfpath(ptype)                                                                            \
  else if (par->type() == demangle(typeid(ptype).name()))                                          \
      setFilePathParam<ptype>(full_name,                                                           \
                              short_name,                                                          \
                              dynamic_cast<InputParameters::Parameter<ptype> *>(par),              \
                              p,                                                                   \
                              in_global,                                                           \
                              global_params_block)
#define setvector(ptype, base)                                                                     \
  else if (par->type() == demangle(typeid(std::vector<ptype>).name()))                             \
      setVectorParameter<ptype, base>(                                                             \
          full_name,                                                                               \
          short_name,                                                                              \
          dynamic_cast<InputParameters::Parameter<std::vector<ptype>> *>(par),                     \
          in_global,                                                                               \
          global_params_block)
#define setvectorfpath(ptype)                                                                      \
  else if (par->type() == demangle(typeid(std::vector<ptype>).name()))                             \
      setVectorFilePathParam<ptype>(                                                               \
          full_name,                                                                               \
          short_name,                                                                              \
          dynamic_cast<InputParameters::Parameter<std::vector<ptype>> *>(par),                     \
          p,                                                                                       \
          in_global,                                                                               \
          global_params_block)
#define setvectorvector(ptype)                                                                     \
  else if (par->type() == demangle(typeid(std::vector<std::vector<ptype>>).name()))                \
      setDoubleIndexParameter<ptype>(                                                              \
          full_name,                                                                               \
          short_name,                                                                              \
          dynamic_cast<InputParameters::Parameter<std::vector<std::vector<ptype>>> *>(par),        \
          in_global,                                                                               \
          global_params_block)

      // built-ins
      // NOTE: Similar dynamic casting is done in InputParameters.C, please update appropriately
      if (false)
        ;
      setscalarvaltype(Real, double, Real);
      setscalarvaltype(int, int, long);
      setscalarvaltype(unsigned short, unsigned int, long);
      setscalarvaltype(long, int, long);
      setscalarvaltype(unsigned int, unsigned int, long);
      setscalarvaltype(unsigned long, unsigned int, long);
      setscalarvaltype(long int, int64_t, long);
      setscalarvaltype(unsigned long long, unsigned int, long);

      setscalar(bool, bool);
      setscalar(SubdomainID, int);
      setscalar(BoundaryID, int);

      // string and string-subclass types
      setscalar(string, string);
      setscalar(SubdomainName, string);
      setscalar(BoundaryName, string);
      setfpath(FileName);
      setfpath(MeshFileName);
      setfpath(FileNameNoExtension);
      setscalar(OutFileBase, string);
      setscalar(VariableName, string);
      setscalar(NonlinearVariableName, string);
      setscalar(AuxVariableName, string);
      setscalar(FunctionName, string);
      setscalar(UserObjectName, string);
      setscalar(VectorPostprocessorName, string);
      setscalar(IndicatorName, string);
      setscalar(MarkerName, string);
      setscalar(MultiAppName, string);
      setscalar(OutputName, string);
      setscalar(MaterialPropertyName, string);
      setscalar(MaterialName, string);
      setscalar(DistributionName, string);
      setscalar(SamplerName, string);
      setscalar(TagName, string);
      setscalar(MeshGeneratorName, string);

      setscalar(PostprocessorName, PostprocessorName);

      // Moose Compound Scalars
      setscalar(RealVectorValue, RealVectorValue);
      setscalar(Point, Point);
      setscalar(MooseEnum, MooseEnum);
      setscalar(MultiMooseEnum, MultiMooseEnum);
      setscalar(RealTensorValue, RealTensorValue);
      setscalar(ExecFlagEnum, ExecFlagEnum);

      // vector types
      setvector(Real, double);
      setvector(int, int);
      setvector(long, int);
      setvector(unsigned int, int);

// We need to be able to parse 8-byte unsigned types when
// libmesh is configured --with-dof-id-bytes=8.  Officially,
// libmesh uses uint64_t in that scenario, which is usually
// equivalent to 'unsigned long long'.  Note that 'long long'
// has been around since C99 so most C++ compilers support it,
// but presumably uint64_t is the "most standard" way to get a
// 64-bit unsigned type, so we'll stick with that here.
#if LIBMESH_DOF_ID_BYTES == 8
      setvector(uint64_t, int);
#endif

      setvector(SubdomainID, int);
      setvector(BoundaryID, int);
      setvector(RealVectorValue, double);
      setvector(Point, Point);
      setvector(MooseEnum, MooseEnum);

      setvector(string, string);
      setvectorfpath(FileName);
      setvectorfpath(FileNameNoExtension);
      setvectorfpath(MeshFileName);
      setvector(SubdomainName, string);
      setvector(BoundaryName, string);
      setvector(NonlinearVariableName, string);
      setvector(AuxVariableName, string);
      setvector(FunctionName, string);
      setvector(UserObjectName, string);
      setvector(IndicatorName, string);
      setvector(MarkerName, string);
      setvector(MultiAppName, string);
      setvector(PostprocessorName, string);
      setvector(VectorPostprocessorName, string);
      setvector(OutputName, string);
      setvector(MaterialPropertyName, string);
      setvector(MaterialName, string);
      setvector(DistributionName, string);
      setvector(SamplerName, string);
      setvector(TagName, string);
      setvector(VariableName, VariableName);
      setvector(MeshGeneratorName, string);

      // Double indexed types
      setvectorvector(Real);
      setvectorvector(int);
      setvectorvector(long);
      setvectorvector(unsigned int);
      setvectorvector(unsigned long long);

// See vector type explanation
#if LIBMESH_DOF_ID_BYTES == 8
      setvectorvector(uint64_t);
#endif

      setvectorvector(SubdomainID);
      setvectorvector(BoundaryID);
      setvectorvector(string);
      setvectorvector(FileName);
      setvectorvector(FileNameNoExtension);
      setvectorvector(MeshFileName);
      setvectorvector(SubdomainName);
      setvectorvector(BoundaryName);
      setvectorvector(VariableName);
      setvectorvector(NonlinearVariableName);
      setvectorvector(AuxVariableName);
      setvectorvector(FunctionName);
      setvectorvector(UserObjectName);
      setvectorvector(IndicatorName);
      setvectorvector(MarkerName);
      setvectorvector(MultiAppName);
      setvectorvector(PostprocessorName);
      setvectorvector(VectorPostprocessorName);
      setvectorvector(MarkerName);
      setvectorvector(OutputName);
      setvectorvector(MaterialPropertyName);
      setvectorvector(MaterialName);
      setvectorvector(DistributionName);
      setvectorvector(SamplerName);
      else
      {
        mooseError("unsupported type '", par->type(), "' for input parameter '", full_name, "'");
      }

#undef setscalarValueType
#undef setscalar
#undef setvector
#undef setvectorvector
    }
  }

  // All of the parameters for this object have been extracted.  See if there are any errors
  if (!error_stream.str().empty())
    mooseError(error_stream.str());

  // Here we will see if there are any auto build vectors that need to be created
  std::map<std::string, std::pair<std::string, std::string>> auto_build_vectors =
      p.getAutoBuildVectors();
  for (const auto & it : auto_build_vectors)
  {
    // We'll autogenerate values iff the requested vector is not valid but both the base and
    // number
    // are valid
    const std::string & base_name = it.second.first;
    const std::string & num_repeat = it.second.second;

    if (!p.isParamValid(it.first) && p.isParamValid(base_name) && p.isParamValid(num_repeat))
    {
      unsigned int vec_size = p.get<unsigned int>(num_repeat);
      const std::string & name = p.get<std::string>(base_name);

      std::vector<VariableName> variable_names(vec_size);
      for (unsigned int i = 0; i < vec_size; ++i)
      {
        std::ostringstream oss;
        oss << name << i;
        variable_names[i] = oss.str();
      }

      // Finally set the autogenerated vector into the InputParameters object
      p.set<std::vector<VariableName>>(it.first) = variable_names;
    }
  }
}

getFileName()

std::string Parser::getFileName

(

bool

stripLeadingPath = true

)

const

Return the filename that was parsed.

Definition at line 290 of file Parser.C.

Referenced by MeshOnlyAction::act(), extractParams(), MooseApp::getFileName(), and walkRaw().

{
  if (!stripLeadingPath)
    return _input_filename;

  std::string filename;
  size_t pos = _input_filename.find_last_of('/');
  if (pos != std::string::npos)
    filename = _input_filename.substr(pos + 1);
  else
    filename = _input_filename;

  return filename;
}

hitCLIFilter()

std::string Parser::hitCLIFilter ( std::string  appname, const std::vector< std::string > &  argv  )

private

Definition at line 393 of file Parser.C.

Referenced by parse().

{
  std::string hit_text;
  bool afterDoubleDash = false;
  for (std::size_t i = 1; i < argv.size(); i++)
  {
    std::string arg(argv[i]);

    // all args after a "--" are hit parameters
    if (arg == "--")
    {
      afterDoubleDash = true;
      continue;
    } // otherwise try to guess if a hit params have started by looking for "=" and "/"
    else if (arg.find("=", 0) != std::string::npos)
      afterDoubleDash = true;

    // skip arguments with no equals sign
    if (arg.find("=", 0) == std::string::npos)
      continue;
    // skip cli flags (i.e. start with dash)
    else if (arg.find("-", 0) == 0)
      continue;
    // skip over args that don't look like or are before hit parameters
    else if (!afterDoubleDash)
      continue;
    else if (appname == "main")
    {
      auto pos = arg.find(":", 0);
      if (pos == 0) // trim leading colon
        arg = arg.substr(pos + 1, arg.size() - pos - 1);
      else if (pos != std::string::npos && pos < arg.find("=", 0)) // param is for non-main subapp
        continue;
    }
    else if (appname != "main") // app we are loading is a multiapp subapp
    {
      std::string name;
      std::string num;
      pcrecpp::RE("(.*?)"  // Match the multiapp name
                  "(\\d+)" // math the multiapp number
                  )
          .FullMatch(appname, &name, &num);
      auto pos = arg.find(":", 0);
      if (pos == 0)
        ; // cli param is ":" prefixed meaning global for all main+subapps
      else if (pos == std::string::npos) // param is for main app - skip
        continue;
      else if (arg.substr(0, pos) != appname &&
               arg.substr(0, pos) != name) // param is for different multiapp - skip
      {
        _app.commandLine()->markHitParam(i);
        continue;
      }
      arg = arg.substr(pos + 1, arg.size() - pos - 1); // trim off subapp name prefix
    }

    try
    {
      hit::check("CLI_ARG", arg);
      hit_text += " " + arg;
      // handle case where bash ate quotes around an empty string after the "="
      if (arg.find("=", 0) == arg.size() - 1)
        hit_text += "''";
      _app.commandLine()->markHitParamUsed(i);
    }
    catch (hit::ParseError & err)
    {
      // bash might have eaten quotes around a hit string value or vector
      // so try quoting after the "=" and reparse
      auto quoted = arg;
      auto pos = quoted.find("=", 0);
      if (pos != std::string::npos)
        quoted = arg.substr(0, pos + 1) + "'" + arg.substr(pos + 1, quoted.size() - pos) + "'";
      try
      {
        hit::check("CLI_ARG", quoted);
        hit_text += " " + quoted;
        _app.commandLine()->markHitParamUsed(i);
      }
      catch (hit::ParseError & err)
      {
        mooseError("invalid hit in arg '", arg, "': ", err.what());
      }
    }
  }
  return hit_text;
}

initSyntaxFormatter()

void Parser::initSyntaxFormatter	(	SyntaxFormatterType	type,
		bool	dump_mode
	)

Creates a syntax formatter for printing.

Definition at line 632 of file Parser.C.

Referenced by MooseApp::setupOptions().

{
  switch (type)
  {
    case INPUT_FILE:
      _syntax_formatter = libmesh_make_unique<InputFileFormatter>(dump_mode);
      break;
    case YAML:
      _syntax_formatter = libmesh_make_unique<YAMLFormatter>(dump_mode);
      break;
    default:
      mooseError("Unrecognized Syntax Formatter requested");
      break;
  }
}

listValidParams()

std::vector< std::string > Parser::listValidParams

(

std::string &

section_name

)

Definition at line 162 of file Parser.C.

Referenced by UnusedWalker::walk().

{
  bool dummy;
  std::string registered_identifier = _syntax.isAssociated(section_name, &dummy);
  auto iters = _syntax.getActions(registered_identifier);

  std::vector<std::string> paramlist;
  for (auto it = iters.first; it != iters.second; ++it)
  {
    auto params = _action_factory.getValidParams(it->second._action);
    for (const auto & it : params)
      paramlist.push_back(it.first);
  }
  return paramlist;
}

parse()

void Parser::parse

(

const std::string &

input_filename

)

Parse an input file consisting of hit syntax and setup objects in the MOOSE derived application.

Definition at line 482 of file Parser.C.

Referenced by MooseApp::setupOptions().

{
  // Save the filename
  char abspath[PATH_MAX + 1];
  realpath(input_filename.c_str(), abspath);
  _input_filename = std::string(abspath);

  // vector for initializing active blocks
  std::vector<std::string> all = {"__all__"};

  MooseUtils::checkFileReadable(_input_filename, true);

  std::ifstream f(_input_filename);
  std::string input((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());

  try
  {
    _root.reset(hit::parse(_input_filename, input));
    auto cli_input = hitCLIFilter(_app.name(), _app.commandLine()->getArguments());

    _cli_root.reset(hit::parse("CLI_ARGS", cli_input));
    hit::explode(_cli_root.get());
    hit::explode(_root.get());
    hit::merge(_cli_root.get(), _root.get());
  }
  catch (hit::ParseError & err)
  {
    mooseError(err.what());
  }

  // expand ${bla} parameter values and mark/include variables used in expansions as "used".  This
  // MUST occur before parameter extraction - otherwise parameters will get wrong values.
  hit::RawEvaler raw;
  hit::EnvEvaler env;
  hit::ReplaceEvaler repl;
  FuncParseEvaler fparse_ev;
  hit::BraceExpander exw(_input_filename);
  exw.registerEvaler("raw", raw);
  exw.registerEvaler("env", env);
  exw.registerEvaler("fparse", fparse_ev);
  exw.registerEvaler("replace", repl);
  _root->walk(&exw);
  for (auto & var : exw.used)
    _extracted_vars.insert(var);
  for (auto & msg : exw.errors)
    _errmsg += msg + "\n";

  // do as much error checking as early as possible so that errors are more useful instead
  // of surprising and disconnected from what caused them.
  DupParamWalker dw(_input_filename);
  BadActiveWalker bw(_input_filename);
  _root->walk(&dw, hit::NodeType::Field);
  _root->walk(&bw, hit::NodeType::Section);
  for (auto & msg : dw.errors)
    _errmsg += msg + "\n";
  for (auto & msg : bw.errors)
    _errmsg += msg + "\n";

  // There are a few order dependent actions that have to be built first in
  // order for the parser and application to function properly:
  //
  // SetupDebugAction: This action can contain an option for monitoring the parser progress. It must
  //                   be parsed first to capture all of the parsing output.
  //
  // GlobalParamsAction: This action is checked during the parameter extraction routines of all
  //                     subsequent blocks. It must be parsed early since it must exist during
  //                     subsequent parameter extraction.
  //
  // DynamicObjectRegistration: This action must be built before any MooseObjectActions are built.
  //                            This is because we retrieve valid parameters from the Factory
  //                            during parse time. Objects must be registered before
  //                            validParameters can be retrieved.
  auto syntax = _syntax.getSyntaxByAction("SetupDebugAction");
  std::copy(syntax.begin(), syntax.end(), std::back_inserter(_secs_need_first));

  syntax = _syntax.getSyntaxByAction("GlobalParamsAction");
  std::copy(syntax.begin(), syntax.end(), std::back_inserter(_secs_need_first));

  syntax = _syntax.getSyntaxByAction("DynamicObjectRegistrationAction");
  std::copy(syntax.begin(), syntax.end(), std::back_inserter(_secs_need_first));

  // walk all the sections extracting paramters from each into InputParameters objects
  for (auto & sec : _secs_need_first)
  {
    auto n = _root->find(sec);
    if (n)
      walkRaw(n->parent()->fullpath(), n->path(), n);
  }
  _root->walk(this, hit::NodeType::Section);

  if (_errmsg.size() > 0)
    mooseError(_errmsg);
}

setDoubleIndexParameter()

template<typename T >

void Parser::setDoubleIndexParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< std::vector< T >>> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Template method for setting any double indexed type parameter read from the input file or command line.

Definition at line 1472 of file Parser.C.

{
  // Get the full string assigned to the variable full_name
  std::string buffer = _root->param<std::string>(full_name);

  // split vector at delim ;
  // NOTE: the substrings are _not_ of type T yet
  std::vector<std::string> first_tokenized_vector;
  MooseUtils::tokenize(buffer, first_tokenized_vector, 1, ";");
  param->set().resize(first_tokenized_vector.size());

  for (unsigned j = 0; j < first_tokenized_vector.size(); ++j)
    if (!MooseUtils::tokenizeAndConvert<T>(first_tokenized_vector[j], param->set()[j]))
    {
      _errmsg +=
          hit::errormsg(
              _input_filename, _root->find(full_name), "invalid format for parameter ", full_name) +
          "\n";
      return;
    }

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setDoubleIndexParam<T>(short_name).resize(first_tokenized_vector.size());
    for (unsigned j = 0; j < first_tokenized_vector.size(); ++j)
    {
      global_block->setDoubleIndexParam<T>(short_name)[j].resize(param->get()[j].size());
      for (unsigned int i = 0; i < param->get()[j].size(); ++i)
        global_block->setDoubleIndexParam<T>(short_name)[j][i] = param->get()[j][i];
    }
  }
}

setFilePathParam()

template<typename T >

void Parser::setFilePathParam ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< T > *  param, InputParameters &  params, bool  in_global, GlobalParamsAction *  global_block  )

protected

Sets an input parameter representing a file path using input file data.

The file path is modified to be relative to the directory this application's input file is in.

Definition at line 1357 of file Parser.C.

{
  std::string prefix;
  std::string postfix = _root->param<std::string>(full_name);
  size_t pos = _input_filename.find_last_of('/');
  if (pos != std::string::npos && postfix[0] != '/' && !postfix.empty())
    prefix = _input_filename.substr(0, pos + 1);

  params.rawParamVal(short_name) = postfix;
  param->set() = prefix + postfix;

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setScalarParam<T>(short_name) = param->get();
  }
}

setScalarComponentParameter()

template<typename T >

void Parser::setScalarComponentParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< T > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Template method for setting any multivalue "scalar" type parameter read from the input file or command line.

Examples include "Point" and "RealVectorValue".

Definition at line 1512 of file Parser.C.

{
  std::vector<double> vec;
  try
  {
    vec = _root->param<std::vector<double>>(full_name);
  }
  catch (hit::Error & err)
  {
    _errmsg += hit::errormsg(_input_filename, _root->find(full_name), err.what()) + "\n";
    return;
  }

  if (vec.size() != LIBMESH_DIM)
  {
    _errmsg += hit::errormsg(_input_filename,
                             _root->find(full_name),
                             "wrong number of values in scalar component parameter ",
                             full_name,
                             ": size ",
                             vec.size(),
                             " is not a multiple of ",
                             LIBMESH_DIM) +
               "\n";
    return;
  }

  T value;
  for (unsigned int i = 0; i < vec.size(); ++i)
    value(i) = Real(vec[i]);

  param->set() = value;
  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setScalarParam<T>(short_name) = value;
  }
}

setScalarParameter() [1/15]

template<typename T , typename Base >

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< T > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Helper functions for setting parameters of arbitrary types - bodies are in the .C file since they are called only from this Object.

Template method for setting any scalar type parameter read from the input file or command line

Definition at line 1294 of file Parser.C.

{

  try
  {
    param->set() = _root->param<Base>(full_name);
  }
  catch (hit::Error & err)
  {
    auto strval = _root->param<std::string>(full_name);

    // handle the case where the user put a number inside quotes
    auto & t = typeid(T);
    if (t == typeid(int) || t == typeid(unsigned int) || t == typeid(SubdomainID) ||
        t == typeid(BoundaryID) || t == typeid(double))
    {
      try
      {
        param->set() = MooseUtils::convert<T>(strval, true);
      }
      catch (std::invalid_argument & /*e*/)
      {
        const std::string format_type = (t == typeid(double)) ? "float" : "integer";
        _errmsg += hit::errormsg(_input_filename,
                                 _root->find(full_name),
                                 "invalid ",
                                 format_type,
                                 " syntax for parameter: ",
                                 full_name,
                                 "=",
                                 strval) +
                   "\n";
      }
    }
    else if (t == typeid(bool))
    {
      bool isbool = toBool(strval, param->set());
      if (!isbool)
        _errmsg += hit::errormsg(_input_filename,
                                 _root->find(full_name),
                                 "invalid boolean syntax for parameter: ",
                                 full_name,
                                 "=",
                                 strval) +
                   "\n";
    }
    else
      throw;
  }

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setScalarParam<T>(short_name) = param->get();
  }
}

setScalarParameter() [2/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< RealVectorValue > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setScalarParameter() [3/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< Point > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setScalarParameter() [4/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< PostprocessorName > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setScalarParameter() [5/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< MooseEnum > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setScalarParameter() [6/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< MultiMooseEnum > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setScalarParameter() [7/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< ExecFlagEnum > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setScalarParameter() [8/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< RealTensorValue > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setScalarParameter() [9/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< RealVectorValue > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Definition at line 1610 of file Parser.C.

{
  setScalarComponentParameter(full_name, short_name, param, in_global, global_block);
}

setScalarParameter() [10/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< Point > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Definition at line 1622 of file Parser.C.

{
  setScalarComponentParameter(full_name, short_name, param, in_global, global_block);
}

setScalarParameter() [11/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< MooseEnum > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Definition at line 1633 of file Parser.C.

{
  MooseEnum current_param = param->get();

  std::string value = _root->param<std::string>(full_name);

  param->set() = value;
  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setScalarParam<MooseEnum>(short_name) = current_param;
  }
}

setScalarParameter() [12/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< MultiMooseEnum > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Definition at line 1653 of file Parser.C.

{
  MultiMooseEnum current_param = param->get();

  auto vec = _root->param<std::vector<std::string>>(full_name);

  std::string raw_values;
  for (unsigned int i = 0; i < vec.size(); ++i)
    raw_values += ' ' + vec[i];

  param->set() = raw_values;

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setScalarParam<MultiMooseEnum>(short_name) = current_param;
  }
}

setScalarParameter() [13/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< ExecFlagEnum > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Definition at line 1679 of file Parser.C.

{
  ExecFlagEnum current_param = param->get();
  auto vec = _root->param<std::vector<std::string>>(full_name);

  std::string raw_values;
  for (unsigned int i = 0; i < vec.size(); ++i)
    raw_values += ' ' + vec[i];

  param->set() = raw_values;

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setScalarParam<ExecFlagEnum>(short_name) = current_param;
  }
}

setScalarParameter() [14/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< RealTensorValue > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Definition at line 1704 of file Parser.C.

{
  auto vec = _root->param<std::vector<double>>(full_name);
  if (vec.size() != LIBMESH_DIM * LIBMESH_DIM)
  {
    _errmsg += hit::errormsg(_input_filename,
                             _root->find(full_name),
                             "invalid RealTensorValue parameter ",
                             full_name,
                             ": size is ",
                             vec.size(),
                             " but should be ",
                             LIBMESH_DIM * LIBMESH_DIM) +
               "\n";
    return;
  }

  RealTensorValue value;
  for (int i = 0; i < LIBMESH_DIM; ++i)
    for (int j = 0; j < LIBMESH_DIM; ++j)
      value(i, j) = Real(vec[i * LIBMESH_DIM + j]);

  param->set() = value;
  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setScalarParam<RealTensorValue>(short_name) = value;
  }
}

setScalarParameter() [15/15]

template<>

void Parser::setScalarParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< PostprocessorName > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Definition at line 1742 of file Parser.C.

{
  PostprocessorName pps_name = _root->param<std::string>(full_name);
  param->set() = pps_name;

  Real real_value = -std::numeric_limits<Real>::max();
  std::istringstream ss(pps_name);

  if (ss >> real_value && ss.eof())
    _current_params->setDefaultPostprocessorValue(short_name, real_value);

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setScalarParam<PostprocessorName>(short_name) = pps_name;
  }
}

setScalarValueTypeParameter()

template<typename T , typename UP_T , typename Base >

void Parser::setScalarValueTypeParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< T > *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Definition at line 1382 of file Parser.C.

{
  setScalarParameter<T, Base>(full_name, short_name, param, in_global, global_block);

  // If this is a range checked param, we need to make sure that the value falls within the
  // requested range
  mooseAssert(_current_params, "Current params is nullptr");

  _current_params->rangeCheck<T, UP_T>(full_name, short_name, param, *_current_error_stream);
}

setVectorComponentParameter()

template<typename T >

void Parser::setVectorComponentParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< T >> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Template method for setting several multivalue "scalar" type parameter read from the input file or command line.

Examples include "Point" and "RealVectorValue".

Definition at line 1557 of file Parser.C.

{
  std::vector<double> vec;
  try
  {
    vec = _root->param<std::vector<double>>(full_name);
  }
  catch (hit::Error & err)
  {
    _errmsg += hit::errormsg(_input_filename, _root->find(full_name), err.what()) + "\n";
    return;
  }

  if (vec.size() % LIBMESH_DIM)
  {
    _errmsg += hit::errormsg(_input_filename,
                             _root->find(full_name),
                             "wrong number of values in vector component parameter ",
                             full_name,
                             ": size ",
                             vec.size(),
                             " is not a multiple of ",
                             LIBMESH_DIM) +
               "\n";
    return;
  }

  std::vector<T> values;
  for (unsigned int i = 0; i < vec.size() / LIBMESH_DIM; ++i)
  {
    T value;
    for (int j = 0; j < LIBMESH_DIM; ++j)
      value(j) = Real(vec[i * LIBMESH_DIM + j]);
    values.push_back(value);
  }

  param->set() = values;

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setVectorParam<T>(short_name).resize(vec.size(), values[0]);
    for (unsigned int i = 0; i < vec.size() / LIBMESH_DIM; ++i)
      global_block->setVectorParam<T>(short_name)[i] = values[0];
  }
}

setVectorFilePathParam()

template<typename T >

void Parser::setVectorFilePathParam ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< T >> *  param, InputParameters &  params, bool  in_global, GlobalParamsAction *  global_block  )

protected

Sets an input parameter representing a vector of file paths using input file data.

The file paths are modified to be relative to the directory this application's input file is in.

Definition at line 1434 of file Parser.C.

{
  std::vector<T> vec;
  std::vector<std::string> rawvec;
  if (_root->find(full_name))
  {
    auto tmp = _root->param<std::vector<std::string>>(full_name);
    params.rawParamVal(short_name) = _root->param<std::string>(full_name);
    for (auto val : tmp)
    {
      std::string prefix;
      std::string postfix = val;
      size_t pos = _input_filename.find_last_of('/');
      if (pos != std::string::npos && postfix[0] != '/')
        prefix = _input_filename.substr(0, pos + 1);
      rawvec.push_back(postfix);
      vec.push_back(prefix + postfix);
    }
  }

  param->set() = vec;

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setVectorParam<T>(short_name).resize(param->get().size());
    for (unsigned int i = 0; i < vec.size(); ++i)
      global_block->setVectorParam<T>(short_name)[i] = param->get()[i];
  }
}

setVectorParameter() [1/9]

template<typename T , typename Base >

void Parser::setVectorParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< T >> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Template method for setting any vector type parameter read from the input file or command line.

Definition at line 1399 of file Parser.C.

{
  std::vector<T> vec;
  if (_root->find(full_name))
  {
    try
    {
      auto tmp = _root->param<std::vector<Base>>(full_name);
      for (auto val : tmp)
        vec.push_back(val);
    }
    catch (hit::Error & err)
    {
      _errmsg += hit::errormsg(_input_filename, _root->find(full_name), err.what()) + "\n";
      return;
    }
  }

  param->set() = vec;

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setVectorParam<T>(short_name).resize(param->get().size());
    for (unsigned int i = 0; i < vec.size(); ++i)
      global_block->setVectorParam<T>(short_name)[i] = param->get()[i];
  }
}

setVectorParameter() [2/9]

template<>

void Parser::setVectorParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< RealVectorValue >> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setVectorParameter() [3/9]

template<>

void Parser::setVectorParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< Point >> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setVectorParameter() [4/9]

template<>

void Parser::setVectorParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< MooseEnum >> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setVectorParameter() [5/9]

template<>

void Parser::setVectorParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< VariableName >> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

setVectorParameter() [6/9]

template<>

void Parser::setVectorParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< RealVectorValue >> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Definition at line 1767 of file Parser.C.

{
  setVectorComponentParameter(full_name, short_name, param, in_global, global_block);
}

setVectorParameter() [7/9]

template<>

void Parser::setVectorParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< Point >> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

Definition at line 1779 of file Parser.C.

{
  setVectorComponentParameter(full_name, short_name, param, in_global, global_block);
}

setVectorParameter() [8/9]

template<>

void Parser::setVectorParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< MooseEnum >> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

With MOOSE Enums we need a default object so it should have been passed in the param pointer. We are only going to use the first item in the vector (values[0]) and ignore the rest.

Definition at line 1790 of file Parser.C.

{
  std::vector<MooseEnum> enum_values = param->get();
  std::vector<std::string> values(enum_values.size());
  for (unsigned int i = 0; i < values.size(); ++i)
    values[i] = static_cast<std::string>(enum_values[i]);

  std::vector<std::string> vec;
  if (_root->find(full_name))
  {
    vec = _root->param<std::vector<std::string>>(full_name);
    param->set().resize(vec.size(), enum_values[0]);
  }

  for (unsigned int i = 0; i < vec.size(); ++i)
    param->set()[i] = vec[i];

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setVectorParam<MooseEnum>(short_name).resize(vec.size(), enum_values[0]);
    for (unsigned int i = 0; i < vec.size(); ++i)
      global_block->setVectorParam<MooseEnum>(short_name)[i] = values[0];
  }
}

setVectorParameter() [9/9]

template<>

void Parser::setVectorParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::vector< VariableName >> *  param, bool  , GlobalParamsAction *    )

protected

Specialization for coupling vectors.

This routine handles default values and auto generated VariableValue vectors.

Definition at line 1831 of file Parser.C.

{
  auto vec = _root->param<std::vector<std::string>>(full_name);
  auto strval = _root->param<std::string>(full_name);
  std::vector<VariableName> var_names(vec.size());

  bool has_var_names = false;
  for (unsigned int i = 0; i < vec.size(); ++i)
  {
    VariableName var_name = vec[i];

    Real real_value;
    std::istringstream ss(var_name);

    // If we are able to convert this value into a Real, then set a default coupled value
    // NOTE: parameter must be either all default or no defaults
    if (ss >> real_value && ss.eof())
      _current_params->defaultCoupledValue(short_name, real_value, i);
    else
    {
      var_names[i] = var_name;
      has_var_names = true;
    }
  }

  if (has_var_names)
  {
    param->set().resize(vec.size());

    for (unsigned int i = 0; i < vec.size(); ++i)
      if (var_names[i] == "")
      {
        _errmsg +=
            hit::errormsg(
                _input_filename,
                _root->find(full_name),
                "invalid value for ",
                full_name,
                ":\n"
                "    MOOSE does not currently support a coupled vector where some parameters are ",
                "reals and others are variables") +
            "\n";
        return;
      }
      else
        param->set()[i] = var_names[i];
  }
}

walk()

void Parser::walk	(	const std::string &	fullpath,
		const std::string &	nodepath,
		hit::Node *	n
	)

Definition at line 383 of file Parser.C.

{
  // skip sections that were manually processed first.
  for (auto & sec : _secs_need_first)
    if (nodepath == sec)
      return;
  walkRaw(fullpath, nodepath, n);
}

walkRaw()

void Parser::walkRaw ( std::string  fullpath, std::string  nodepath, hit::Node *  n  )

private

Definition at line 306 of file Parser.C.

Referenced by parse(), and walk().

{
  InputParameters active_list_params = validParams<Action>();
  InputParameters params = validParams<EmptyAction>();

  std::string section_name = n->fullpath();
  std::string curr_identifier = n->fullpath();

  // Before we retrieve any actions or build any objects, make sure that the section they are in
  // is active
  if (!isSectionActive(curr_identifier, _root.get()))
    return;

  // Extract the block parameters before constructing the action
  // There may be more than one Action registered for a given section in which case we need to
  // build them all
  bool is_parent;
  std::string registered_identifier = _syntax.isAssociated(section_name, &is_parent);

  // We need to retrieve a list of Actions associated with the current identifier
  auto iters = _syntax.getActions(registered_identifier);
  if (iters.first == iters.second)
  {
    _errmsg += hit::errormsg(getFileName(),
                             n,
                             "section '",
                             curr_identifier,
                             "' does not have an associated \"Action\".\nDid you misspell it?") +
               "\n";
    return;
  }

  for (auto it = iters.first; it != iters.second; ++it)
  {
    if (is_parent)
      continue;
    if (_syntax.isDeprecatedSyntax(registered_identifier))
      mooseDeprecated(hit::errormsg(
          getFileName(), n, _syntax.deprecatedActionSyntaxMessage(registered_identifier)));

    params = _action_factory.getValidParams(it->second._action);

    params.set<ActionWarehouse *>("awh") = &_action_wh;

    extractParams(curr_identifier, params);

    // Add the parsed syntax to the parameters object for consumption by the Action
    params.set<std::string>("task") = it->second._task;
    params.set<std::string>("registered_identifier") = registered_identifier;
    params.blockLocation() = _input_filename + ":" + std::to_string(n->line());
    params.blockFullpath() = n->fullpath();

    // Create the Action
    std::shared_ptr<Action> action_obj =
        _action_factory.create(it->second._action, MooseUtils::shortName(curr_identifier), params);

    {
      // extract the MooseObject params if necessary
      std::shared_ptr<MooseObjectAction> object_action =
          std::dynamic_pointer_cast<MooseObjectAction>(action_obj);
      if (object_action)
      {
        object_action->getObjectParams().blockLocation() = params.blockLocation();
        object_action->getObjectParams().blockFullpath() = params.blockFullpath();
        extractParams(curr_identifier, object_action->getObjectParams());
        object_action->getObjectParams()
            .set<std::vector<std::string>>("control_tags")
            .push_back(MooseUtils::baseName(curr_identifier));
      }
    }

    // add it to the warehouse
    _action_wh.addActionBlock(action_obj);
  }
}

Member Data Documentation

_action_factory

ActionFactory& Parser::_action_factory

protected

The Factory that builds actions.

Definition at line 243 of file Parser.h.

Referenced by buildFullTree(), buildJsonSyntaxTree(), listValidParams(), and walkRaw().

_action_wh

ActionWarehouse& Parser::_action_wh

protected

Action warehouse that will be filled by actions.

Definition at line 241 of file Parser.h.

Referenced by extractParams(), and walkRaw().

_app

MooseApp& Parser::_app

protected

The MooseApp this Parser is part of.

Definition at line 237 of file Parser.h.

Referenced by errorCheck(), hitCLIFilter(), and parse().

_cli_root

std::unique_ptr<hit::Node> Parser::_cli_root = nullptr

protected

Definition at line 232 of file Parser.h.

Referenced by errorCheck(), and parse().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 32 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), SetupRecoverFileBaseAction::act(), Adaptivity::adaptMesh(), FEProblemBase::adaptMesh(), SimplePredictor::apply(), MultiApp::backup(), FEProblemBase::backupMultiApps(), FEProblemBase::checkProblemIntegrity(), IterationAdaptiveDT::computeAdaptiveDT(), Transient::computeConstrainedDT(), NonlinearSystemBase::computeDamping(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeResidualTags(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppCopyTransfer::execute(), Steady::execute(), MultiAppDTKUserObjectTransfer::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), FEProblemBase::FEProblemBase(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MultiApp::globalAppToLocal(), InversePowerMethod::init(), NonlinearEigen::init(), Steady::init(), FEProblemBase::initialAdaptMesh(), FEProblemBase::initialSetup(), EigenExecutionerBase::inversePowerIteration(), Transient::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseObject::mooseDeprecated(), MooseObject::mooseInfo(), MooseObject::mooseWarning(), PerfGraphOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), Console::outputPostprocessors(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), EigenExecutionerBase::printEigenvalue(), MaterialPropertyDebugOutput::printMaterialMap(), SolutionTimeAdaptiveDT::rejectStep(), DT2::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), SimplePredictor::shouldApply(), NonlinearSystem::solve(), PicardSolve::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), LStableDirk4::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), PicardSolve::solveStep(), DT2::step(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_current_error_stream

std::ostringstream* Parser::_current_error_stream

protected

The current stream object used for capturing errors during extraction.

Definition at line 263 of file Parser.h.

Referenced by extractParams(), and setScalarValueTypeParameter().

_current_params

InputParameters* Parser::_current_params

protected

The current parameter object for which parameters are being extracted.

Definition at line 260 of file Parser.h.

Referenced by extractParams(), and setScalarValueTypeParameter().

_errmsg

std::string Parser::_errmsg

private

Definition at line 266 of file Parser.h.

Referenced by errorCheck(), parse(), setDoubleIndexParameter(), setScalarComponentParameter(), setScalarParameter(), setVectorComponentParameter(), setVectorParameter(), and walkRaw().

_extracted_vars

std::set<std::string> Parser::_extracted_vars

protected

The set of all variables extracted from the input file.

Definition at line 254 of file Parser.h.

Referenced by errorCheck(), extractParams(), and parse().

_factory

Factory& Parser::_factory

protected

The Factory associated with that MooseApp.

Definition at line 239 of file Parser.h.

Referenced by buildFullTree(), and buildJsonSyntaxTree().

_input_filename

std::string Parser::_input_filename

protected

The input file name that is used for parameter extraction.

Definition at line 251 of file Parser.h.

Referenced by errorCheck(), extractParams(), getFileName(), parse(), setDoubleIndexParameter(), setFilePathParam(), setScalarComponentParameter(), setScalarParameter(), setVectorComponentParameter(), setVectorFilePathParam(), setVectorParameter(), and walkRaw().

_root

std::unique_ptr<hit::Node> Parser::_root = nullptr

protected

Definition at line 233 of file Parser.h.

Referenced by errorCheck(), extractParams(), parse(), setDoubleIndexParameter(), setFilePathParam(), setScalarComponentParameter(), setScalarParameter(), setVectorComponentParameter(), setVectorFilePathParam(), setVectorParameter(), and walkRaw().

_secs_need_first

std::vector<std::string> Parser::_secs_need_first

protected

Definition at line 234 of file Parser.h.

Referenced by parse(), and walk().

_sections_read

bool Parser::_sections_read

protected

Boolean to indicate whether parsing has started (sections have been extracted)

Definition at line 257 of file Parser.h.

_syntax

Syntax& Parser::_syntax

protected

Reference to an object that defines input file syntax.

Definition at line 245 of file Parser.h.

Referenced by buildFullTree(), buildJsonSyntaxTree(), extractParams(), listValidParams(), parse(), and walkRaw().

_syntax_formatter

std::unique_ptr<SyntaxTree> Parser::_syntax_formatter

protected

Object for holding the syntax parse tree.

Definition at line 248 of file Parser.h.

Referenced by buildFullTree(), and initSyntaxFormatter().

_warnmsg

std::string Parser::_warnmsg

private

Definition at line 267 of file Parser.h.

Referenced by errorCheck().

---

The documentation for this class was generated from the following files:

• include/parser/Parser.h
• src/parser/Parser.C