Moose::Builder Class Reference

Parses MOOSE input using HIT/WASP. More...

#include <Builder.h>

Inheritance diagram for Moose::Builder:

Public Types
enum	SyntaxFormatterType { INPUT_FILE, YAML }

Public Member Functions
	Builder (MooseApp &app, ActionWarehouse &action_wh, std::shared_ptr< Parser > parser)
virtual	~Builder ()
std::string	getPrimaryFileName (bool stripLeadingPath=true) const
	Return the primary (first) filename that was parsed. More...
void	build ()
	Parse an input file (or text string if provided) 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 libMesh::Parallel::Communicator &comm, bool warn_unused, bool err_unused)
std::vector< std::string >	listValidParams (std::string &section_name)
hit::Node *	root ()

Static Public Member Functions
static InputParameters	validParams ()
	Parameters that are processed directly by the Parser and are valid anywhere in the input. More...

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 KeyType , typename MappedType >
void	setMapParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::map< KeyType, MappedType >> *param, bool in_global, GlobalParamsAction *global_block)
	Template method for setting any map type parameter read from the input file or command line. 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	setTripleIndexParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< std::vector< std::vector< T >>>> *param, bool in_global, GlobalParamsAction *global_block)
	Template method for setting any triple 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<typename T >
void	setVectorVectorComponentParameter (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 vector of 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< RealEigenVector > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< RealEigenMatrix > *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< 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< 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< MultiMooseEnum >> *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	setDoubleIndexParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< std::vector< Point >>> *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< RealEigenVector > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setScalarParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< RealEigenMatrix > *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	setScalarParameter (const std::string &full_name, const std::string &, InputParameters::Parameter< ReporterName > *param, bool, GlobalParamsAction *)
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< MultiMooseEnum >> *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	setVectorParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< 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< VariableName >> *param, bool, GlobalParamsAction *)
	Specialization for coupling vectors. More...
template<>
void	setVectorParameter (const std::string &full_name, const std::string &, InputParameters::Parameter< std::vector< ReporterName >> *param, bool, GlobalParamsAction *)
template<>
void	setVectorParameter (const std::string &full_name, const std::string &, InputParameters::Parameter< std::vector< CLIArgString >> *param, bool, GlobalParamsAction *)
template<>
void	setDoubleIndexParameter (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< std::vector< Point >>> *param, bool in_global, GlobalParamsAction *global_block)

Protected Attributes
std::unique_ptr< hit::Node >	_cli_root = nullptr
hit::Node *	_root
	The root node from the Parser; in the future, we should probably clone this so that we don't muck with the root node in the Parser. More...
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...
const std::shared_ptr< Parser >	_parser
	The front parser. More...
std::unique_ptr< SyntaxTree >	_syntax_formatter
	Object for holding the syntax parse tree. 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...
std::unordered_set< std::string >	_deprec_param_tracker
	Tracks whether a deprecated param has had its warning message printed already. More...

Private Member Functions
void	walkRaw (std::string fullpath, std::string nodepath, hit::Node *n)

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

Detailed Description

Parses MOOSE input using HIT/WASP.

Definition at line 56 of file Builder.h.

Member Enumeration Documentation

SyntaxFormatterType

enum Moose::Builder::SyntaxFormatterType

Enumerator
INPUT_FILE
YAML

Definition at line 59 of file Builder.h.

  {
    INPUT_FILE,
    YAML
  };

Constructor & Destructor Documentation

Builder()

Moose::Builder::Builder	(	MooseApp &	app,
		ActionWarehouse &	action_wh,
		std::shared_ptr< Parser >	parser
	)

Definition at line 122 of file Builder.C.

  : ConsoleStreamInterface(app),
    _app(app),
    _factory(app.getFactory()),
    _action_wh(action_wh),
    _action_factory(app.getActionFactory()),
    _syntax(_action_wh.syntax()),
    _parser(parser),
    _syntax_formatter(nullptr),
    _sections_read(false),
    _current_params(nullptr),
    _current_error_stream(nullptr)
{
  mooseAssert(_parser, "Parser is not set");
}

~Builder()

Moose::Builder::~Builder ( )

virtual

Definition at line 138 of file Builder.C.

{}

Member Function Documentation

build()

void Moose::Builder::build

(

)

Parse an input file (or text string if provided) consisting of hit syntax and setup objects in the MOOSE derived application.

Definition at line 328 of file Builder.C.

Referenced by MooseApp::setupOptions().

{
  // add in command line arguments
  const auto cli_input = _app.commandLine()->buildHitParams();
  try
  {
    _cli_root.reset(hit::parse("CLI_ARGS", cli_input));
    hit::explode(_cli_root.get());
    hit::merge(_cli_root.get(), root());
  }
  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;
  UnitsConversionEvaler units_ev;
  hit::BraceExpander exw;
  exw.registerEvaler("raw", raw);
  exw.registerEvaler("env", env);
  exw.registerEvaler("fparse", fparse_ev);
  exw.registerEvaler("replace", repl);
  exw.registerEvaler("units", units_ev);
  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;
  BadActiveWalker bw;
  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";

  // Print parse errors related to brace expansion early
  if (_errmsg.size() > 0)
    mooseError(_errmsg);

  // 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);
}

buildFullTree()

void Moose::Builder::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 640 of file Builder.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 (const auto & [moose_obj_name, obj] : _factory.registeredObjects())
      {
        auto moose_obj_params = obj->buildParameters();
        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_name) !=
                 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
        )
        {
          std::string name;
          size_t pos = 0;
          bool is_action_params = 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_name;
            else
            {
              name = act_name.substr(0, pos - 1) + "/<type>/" + moose_obj_name;
              is_action_params = true;
            }
          }
          else
          {
            name = act_name + "/<type>/" + moose_obj_name;
          }

          moose_obj_params.set<std::string>("type") = moose_obj_name;

          _syntax_formatter->insertNode(name, moose_obj_name, 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 Moose::Builder::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 480 of file Builder.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);

  // Build a list of all the actions appearing in the syntax
  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));
  }

  // Add all the actions to the JSON tree, except for ActionComponents (below)
  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 syntax = act_names.first;
    InputParameters action_obj_params = _action_factory.getValidParams(action);
    bool params_added = root.addParameters("",
                                           syntax,
                                           false,
                                           action,
                                           true,
                                           &action_obj_params,
                                           _syntax.getLineInfo(syntax, action, ""),
                                           "");

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

    if (action_obj_params.have_parameter<bool>("isObjectAction") &&
        action_obj_params.get<bool>("isObjectAction"))
    {
      for (auto & [moose_obj_name, obj] : _factory.registeredObjects())
      {
        auto moose_obj_params = obj->buildParameters();
        // 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_name) !=
                 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
        )
        {
          std::string name;
          size_t pos = 0;
          bool is_action_params = false;
          bool is_type = false;
          if (syntax[syntax.size() - 1] == '*')
          {
            pos = syntax.size();

            if (!action_obj_params.collapseSyntaxNesting())
              name = syntax.substr(0, pos - 1) + moose_obj_name;
            else
            {
              name = syntax.substr(0, pos - 1) + "/<type>/" + moose_obj_name;
              is_action_params = true;
            }
          }
          else
          {
            name = syntax + "/<type>/" + moose_obj_name;
            is_type = true;
          }
          moose_obj_params.set<std::string>("type") = moose_obj_name;

          auto lineinfo = _factory.getLineInfo(moose_obj_name);
          std::string classname = _factory.associatedClassName(moose_obj_name);
          root.addParameters(syntax,
                             name,
                             is_type,
                             moose_obj_name,
                             is_action_params,
                             &moose_obj_params,
                             lineinfo,
                             classname);
        }
      }

      // Same thing for ActionComponents, which, while they are not MooseObjects, should behave
      // similarly syntax-wise
      if (syntax != "ActionComponents/*")
        continue;

      auto iters = _action_factory.getActionsByTask("list_component");

      for (auto it = iters.first; it != iters.second; ++it)
      {
        // Get the name and parameters
        const auto component_name = it->second;
        auto component_params = _action_factory.getValidParams(component_name);

        // We currently do not have build-type restrictions on this action that adds
        // action-components

        // See if the current Moose Object syntax belongs under this Action's block
        if (action_obj_params.mooseObjectSyntaxVisibility() // and the Action says it's visible
        )
        {
          // The logic for Components is a little simpler here for now because syntax like
          // Executioner/TimeIntegrator/type= do not exist for components
          std::string name;
          if (syntax[syntax.size() - 1] == '*')
          {
            size_t pos = syntax.size();
            name = syntax.substr(0, pos - 1) + component_name;
          }
          component_params.set<std::string>("type") = component_name;

          auto lineinfo = _action_factory.getLineInfo(component_name, "list_component");
          // We add the parameters as for an object, because we want to fit them to be
          // added to json["AddActionComponentAction"]["subblock_types"]
          root.addParameters(syntax,
                             /*syntax_path*/ name,
                             /*is_type*/ false,
                             "AddActionComponentAction",
                             /*is_action=*/false,
                             &component_params,
                             lineinfo,
                             component_name);
        }
      }
    }
  }
  root.addGlobal();
}

errorCheck()

void Moose::Builder::errorCheck	(	const libMesh::Parallel::Communicator &	comm,
		bool	warn_unused,
		bool	err_unused
	)

Definition at line 419 of file Builder.C.

Referenced by MeshOnlyAction::act(), and 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(_extracted_vars, *this);
  UnusedWalker uwcli(_extracted_vars, *this);

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

  auto cli = _app.commandLine();
  if (warn_unused)
  {
    for (const auto & arg : cli->unusedHitParams(comm))
      _warnmsg +=
          hit::errormsg("CLI_ARG", nullptr, "unused command line parameter '", arg, "'") + "\n";
    for (auto & msg : uwcli.errors)
      _warnmsg += msg + "\n";
    for (auto & msg : uw.errors)
      _warnmsg += msg + "\n";
  }
  else if (err_unused)
  {
    for (const auto & arg : cli->unusedHitParams(comm))
      _errmsg +=
          hit::errormsg("CLI_ARG", nullptr, "unused command line parameter '", 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 +
        "\n\nAppend --allow-unused (or -w) on the command line to ignore unused parameters.");
}

extractParams()

void Moose::Builder::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

Scalar 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

Definition at line 887 of file Builder.C.

Referenced by SetupMeshAction::act(), and 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)
  {
    if (p.shouldIgnore(it.first))
      continue;

    bool found = false;
    bool in_global = false;

    for (const auto & param_name : p.paramAliases(it.first))
    {
      std::string orig_name = prefix + "/" + param_name;
      std::string full_name = orig_name;

      // Mark parameters appearing in the input file or command line
      auto node = root()->find(full_name);
      if (node && node->type() == hit::NodeType::Field)
      {
        p.setHitNode(param_name, *node, {});
        p.set_attributes(param_name, false);
        // Check if we have already printed the deprecated param message.
        // If we haven't, add it to the tracker, and print it.
        if (!_deprec_param_tracker.count(param_name))
          if (p.attemptPrintDeprecated(param_name))
            _deprec_param_tracker.insert(param_name);
        _extracted_vars.insert(
            full_name); // Keep track of all variables extracted from the input file
        found = true;
      }
      // Wait! Check the GlobalParams section
      else if (global_params_block)
      {
        full_name = global_params_block_name + "/" + param_name;
        node = root()->find(full_name);
        if (node)
        {
          p.setHitNode(param_name, *node, {});
          p.set_attributes(param_name, false);
          _extracted_vars.insert(
              full_name); // Keep track of all variables extracted from the input file
          found = true;
          in_global = true;
        }
      }
      if (found)
      {
        if (p.isPrivate(param_name) && !in_global)
          mooseError("The parameter '",
                     full_name,
                     "' is a private parameter and should not be used in an input file.");
        // avoid setting the parameter
        else if (p.isPrivate(param_name) && in_global)
          continue;

        auto & short_name = param_name;
        libMesh::Parameters::Value * par = MooseUtils::get(it.second);

#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 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 setmap(key_type, mapped_type)                                                              \
  else if (par->type() == demangle(typeid(std::map<key_type, mapped_type>).name()))                \
      setMapParameter(                                                                             \
          full_name,                                                                               \
          short_name,                                                                              \
          dynamic_cast<InputParameters::Parameter<std::map<key_type, mapped_type>> *>(par),        \
          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)
#define setvectorvectorvector(ptype)                                                               \
  else if (par->type() == demangle(typeid(std::vector<std::vector<std::vector<ptype>>>).name()))   \
      setTripleIndexParameter<ptype>(                                                              \
          full_name,                                                                               \
          short_name,                                                                              \
          dynamic_cast<                                                                            \
              InputParameters::Parameter<std::vector<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);
        setscalar(FileName, string);
        setscalar(MeshFileName, string);
        setscalar(MatrixFileName, string);
        setscalar(FileNameNoExtension, string);
        setscalar(RelativeFileName, string);
        setscalar(DataFileName, string);
        setscalar(ComponentName, string);
        setscalar(PhysicsName, string);
        setscalar(OutFileBase, string);
        setscalar(VariableName, string);
        setscalar(NonlinearVariableName, string);
        setscalar(LinearVariableName, string);
        setscalar(SolverVariableName, string);
        setscalar(AuxVariableName, string);
        setscalar(FunctionName, string);
        setscalar(ConvergenceName, string);
        setscalar(MeshDivisionName, string);
        setscalar(UserObjectName, string);
        setscalar(VectorPostprocessorName, string);
        setscalar(IndicatorName, string);
        setscalar(MarkerName, string);
        setscalar(MultiAppName, string);
        setscalar(OutputName, string);
        setscalar(MaterialPropertyName, string);
        setscalar(MooseFunctorName, string);
        setscalar(MaterialName, string);
        setscalar(DistributionName, string);
        setscalar(PositionsName, string);
        setscalar(SamplerName, string);
        setscalar(TagName, string);
        setscalar(TimesName, string);
        setscalar(MeshGeneratorName, string);
        setscalar(ExtraElementIDName, string);
        setscalar(PostprocessorName, PostprocessorName);
        setscalar(ExecutorName, string);
        setscalar(NonlinearSystemName, string);
        setscalar(LinearSystemName, string);
        setscalar(SolverSystemName, string);
        setscalar(CLIArgString, string);
#ifdef MFEM_ENABLED
        setscalar(MFEMScalarCoefficientName, string);
        setscalar(MFEMVectorCoefficientName, string);
        setscalar(MFEMMatrixCoefficientName, string);
#endif

        // Moose Compound Scalars
        setscalar(RealVectorValue, RealVectorValue);
        setscalar(Point, Point);
        setscalar(RealEigenVector, RealEigenVector);
        setscalar(RealEigenMatrix, RealEigenMatrix);
        setscalar(MooseEnum, MooseEnum);
        setscalar(MultiMooseEnum, MultiMooseEnum);
        setscalar(RealTensorValue, RealTensorValue);
        setscalar(ExecFlagEnum, ExecFlagEnum);
        setscalar(ReporterName, string);
        setscalar(ReporterValueName, string);
        setscalar(ParsedFunctionExpression, string);

        // vector types
        setvector(bool, bool);
        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, RealVectorValue);
        setvector(Point, Point);
        setvector(MooseEnum, MooseEnum);
        setvector(MultiMooseEnum, MultiMooseEnum);

        setvector(string, string);
        setvector(FileName, string);
        setvector(FileNameNoExtension, string);
        setvector(RelativeFileName, string);
        setvector(DataFileName, string);
        setvector(MeshFileName, string);
        setvector(MatrixFileName, string);
        setvector(SubdomainName, string);
        setvector(BoundaryName, string);
        setvector(NonlinearVariableName, string);
        setvector(LinearVariableName, string);
        setvector(SolverVariableName, string);
        setvector(AuxVariableName, string);
        setvector(FunctionName, string);
        setvector(ConvergenceName, string);
        setvector(MeshDivisionName, string);
        setvector(UserObjectName, string);
        setvector(IndicatorName, string);
        setvector(MarkerName, string);
        setvector(MultiAppName, string);
        setvector(PostprocessorName, PostprocessorName);
        setvector(VectorPostprocessorName, string);
        setvector(OutputName, string);
        setvector(MaterialPropertyName, string);
        setvector(MooseFunctorName, string);
        setvector(MaterialName, string);
        setvector(DistributionName, string);
        setvector(SamplerName, string);
        setvector(TagName, string);
        setvector(VariableName, VariableName);
        setvector(MeshGeneratorName, string);
        setvector(ExtraElementIDName, string);
        setvector(ReporterName, string);
        setvector(CLIArgString, string);
        setvector(ComponentName, string);
        setvector(PhysicsName, string);
        setvector(PositionsName, string);
        setvector(TimesName, string);
        setvector(ReporterValueName, string);
        setvector(ExecutorName, string);
        setvector(NonlinearSystemName, string);
        setvector(LinearSystemName, string);
        setvector(SolverSystemName, string);
#ifdef MFEM_ENABLED
        setvector(MFEMScalarCoefficientName, string);
        setvector(MFEMVectorCoefficientName, string);
        setvector(MFEMMatrixCoefficientName, string);
#endif

        // map types
        setmap(string, unsigned int);
        setmap(string, Real);
        setmap(string, string);
        setmap(unsigned int, unsigned int);
        setmap(unsigned long, unsigned int);
        setmap(unsigned long long, unsigned int);

        // 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(Point);
        setvectorvector(string);
        setvectorvector(FileName);
        setvectorvector(FileNameNoExtension);
        setvectorvector(DataFileName);
        setvectorvector(MeshFileName);
        setvectorvector(MatrixFileName);
        setvectorvector(SubdomainName);
        setvectorvector(BoundaryName);
        setvectorvector(VariableName);
        setvectorvector(NonlinearVariableName);
        setvectorvector(LinearVariableName);
        setvectorvector(SolverVariableName);
        setvectorvector(AuxVariableName);
        setvectorvector(FunctionName);
        setvectorvector(ConvergenceName);
        setvectorvector(UserObjectName);
        setvectorvector(IndicatorName);
        setvectorvector(MarkerName);
        setvectorvector(MultiAppName);
        setvectorvector(PostprocessorName);
        setvectorvector(VectorPostprocessorName);
        setvectorvector(MarkerName);
        setvectorvector(OutputName);
        setvectorvector(MaterialPropertyName);
        setvectorvector(MooseFunctorName);
        setvectorvector(MaterialName);
        setvectorvector(DistributionName);
        setvectorvector(SamplerName);
        setvectorvector(TagName);
#ifdef MFEM_ENABLED
        setvectorvector(MFEMScalarCoefficientName);
        setvectorvector(MFEMVectorCoefficientName);
        setvectorvector(MFEMMatrixCoefficientName);
#endif

        // Triple indexed types
        setvectorvectorvector(Real);
        setvectorvectorvector(int);
        setvectorvectorvector(long);
        setvectorvectorvector(unsigned int);
        setvectorvectorvector(unsigned long long);

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

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

#undef setscalarValueType
#undef setscalar
#undef setvector
#undef setvectorvectorvector
#undef setvectorvector
#undef setmap
        break;
      }
    }

    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> *>(MooseUtils::get(it.second));
      if (scalar_p)
      {
        std::string input_file_name = getPrimaryFileName();
        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);
      }
    }
  }

  // All of the parameters for this object have been extracted.  See if there are any errors
  if (!error_stream.str().empty())
    mooseError(_errmsg + 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;
    }
  }
}

getPrimaryFileName()

std::string Moose::Builder::getPrimaryFileName

(

bool

stripLeadingPath = true

)

const

Return the primary (first) filename that was parsed.

Definition at line 199 of file Builder.C.

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

{
  const auto path = _parser->getLastInputFilePath();
  return (strip_leading_path ? path.filename() : std::filesystem::absolute(path)).string();
}

initSyntaxFormatter()

void Moose::Builder::initSyntaxFormatter	(	SyntaxFormatterType	type,
		bool	dump_mode
	)

Creates a syntax formatter for printing.

Definition at line 463 of file Builder.C.

Referenced by MooseApp::setupOptions().

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

listValidParams()

std::vector< std::string > Moose::Builder::listValidParams

(

std::string &

section_name

)

Definition at line 162 of file Builder.C.

Referenced by Moose::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;
}

root()

hit::Node * Moose::Builder::root

(

)

Returns

The root node in the parser

Definition at line 321 of file Builder.C.

Referenced by build(), buildJsonSyntaxTree(), errorCheck(), extractParams(), setDoubleIndexParameter(), setMapParameter(), setScalarComponentParameter(), setScalarParameter(), setTripleIndexParameter(), setVectorComponentParameter(), setVectorParameter(), setVectorVectorComponentParameter(), and walkRaw().

{
  mooseAssert(_parser, "Parser is not set");
  return _parser->root();
}

setDoubleIndexParameter() [1/3]

template<typename T >

void Moose::Builder::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 1569 of file Builder.C.

{
  auto & value = param->set();

  // Get the full string assigned to the variable full_name
  const auto value_string = MooseUtils::trim(root()->param<std::string>(full_name));

  // split vector at delim ;
  // NOTE: the substrings are _not_ of type T yet
  // The zero length here is intentional, as we want something like:
  // "abc; 123;" -> ["abc", "123", ""]
  std::vector<std::string> outer_string_vectors;
  // With split, we will get a single entry if the string value is empty. However,
  // that should represent an empty vector<vector>. Therefore, only split if we have values.
  if (!value_string.empty())
    outer_string_vectors = MooseUtils::split(value_string, ";");

  const auto outer_vector_size = outer_string_vectors.size();
  value.resize(outer_vector_size);

  for (const auto j : index_range(outer_string_vectors))
    if (!MooseUtils::tokenizeAndConvert<T>(outer_string_vectors[j], value[j]))
    {
      _errmsg +=
          hit::errormsg(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(outer_vector_size);
    for (const auto j : make_range(outer_vector_size))
    {
      global_block->setDoubleIndexParam<T>(short_name)[j].resize(value[j].size());
      for (const auto i : index_range(value[j]))
        global_block->setDoubleIndexParam<T>(short_name)[j][i] = value[j][i];
    }
  }
}

setDoubleIndexParameter() [2/3]

template<>

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

protected

setDoubleIndexParameter() [3/3]

template<>

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

protected

Definition at line 2361 of file Builder.C.

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

setMapParameter()

template<typename KeyType , typename MappedType >

void Moose::Builder::setMapParameter ( const std::string &  full_name, const std::string &  short_name, InputParameters::Parameter< std::map< KeyType, MappedType >> *  param, bool  in_global, GlobalParamsAction *  global_block  )

protected

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

Definition at line 1468 of file Builder.C.

{
  std::map<KeyType, MappedType> the_map;
  if (root()->find(full_name))
  {
    try
    {
      const auto & string_vec = root()->param<std::vector<std::string>>(full_name);
      auto it = string_vec.begin();
      while (it != string_vec.end())
      {
        const auto & string_key = *it;
        ++it;
        if (it == string_vec.end())
        {
          _errmsg +=
              hit::errormsg(root()->find(full_name),
                            "odd number of entries in string vector for map parameter: ",
                            full_name,
                            ". There must be "
                            "an even number or else you will end up with a key without a value!") +
              "\n";
          return;
        }
        const auto & string_value = *it;
        ++it;

        std::pair<KeyType, MappedType> pr;
        // key
        try
        {
          pr.first = MooseUtils::convert<KeyType>(string_key, true);
        }
        catch (std::invalid_argument & /*e*/)
        {
          _errmsg += hit::errormsg(root()->find(full_name),
                                   "invalid ",
                                   demangle(typeid(KeyType).name()),
                                   " syntax for map parameter ",
                                   full_name,
                                   " key: ",
                                   string_key) +
                     "\n";
          return;
        }
        // value
        try
        {
          pr.second = MooseUtils::convert<MappedType>(string_value, true);
        }
        catch (std::invalid_argument & /*e*/)
        {
          _errmsg += hit::errormsg(root()->find(full_name),
                                   "invalid ",
                                   demangle(typeid(MappedType).name()),
                                   " syntax for map parameter ",
                                   full_name,
                                   " value: ",
                                   string_value) +
                     "\n";
          return;
        }

        auto insert_pr = the_map.insert(std::move(pr));
        if (!insert_pr.second)
        {
          _errmsg += hit::errormsg(root()->find(full_name),
                                   "Duplicate map entry for map parameter: ",
                                   full_name,
                                   ". The key ",
                                   string_key,
                                   " appears multiple times.") +
                     "\n";
          return;
        }
      }
    }
    catch (hit::Error & err)
    {
      _errmsg += hit::errormsg(root()->find(full_name), err.what()) + "\n";
      return;
    }
  }

  param->set() = the_map;

  if (in_global)
  {
    global_block->remove(short_name);
    auto & global_map = global_block->setParam<std::map<KeyType, MappedType>>(short_name);
    for (const auto & pair : the_map)
      global_map.insert(pair);
  }
}

setScalarComponentParameter()

template<typename T >

void Moose::Builder::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 1692 of file Builder.C.

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

  if (vec.size() != LIBMESH_DIM)
  {
    _errmsg += hit::errormsg(root()->find(full_name),
                             "wrong number of values in scalar component parameter ",
                             full_name,
                             ": ",
                             short_name,
                             " was given ",
                             vec.size(),
                             " components but should have ",
                             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/20]

template<typename T , typename Base >

void Moose::Builder::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 1356 of file Builder.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(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(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/20]

template<>

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

protected

setScalarParameter() [3/20]

template<>

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

protected

setScalarParameter() [4/20]

template<>

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

protected

setScalarParameter() [5/20]

template<>

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

protected

setScalarParameter() [6/20]

template<>

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

protected

setScalarParameter() [7/20]

template<>

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

protected

setScalarParameter() [8/20]

template<>

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

protected

setScalarParameter() [9/20]

template<>

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

protected

setScalarParameter() [10/20]

template<>

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

protected

setScalarParameter() [11/20]

template<>

void Moose::Builder::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 1860 of file Builder.C.

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

setScalarParameter() [12/20]

template<>

void Moose::Builder::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 1872 of file Builder.C.

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

setScalarParameter() [13/20]

template<>

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

protected

Definition at line 1883 of file Builder.C.

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

  RealEigenVector value(vec.size());
  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<RealEigenVector>(short_name) = value;
  }
}

setScalarParameter() [14/20]

template<>

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

protected

Definition at line 1915 of file Builder.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, ";");

  std::vector<std::vector<Real>> values(first_tokenized_vector.size());

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

  RealEigenMatrix value(values.size(), values[0].size());
  for (unsigned int i = 0; i < values.size(); ++i)
    for (unsigned int j = 0; j < values[i].size(); ++j)
      value(i, j) = values[i][j];

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

setScalarParameter() [15/20]

template<>

void Moose::Builder::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 1963 of file Builder.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() [16/20]

template<>

void Moose::Builder::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 1983 of file Builder.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() [17/20]

template<>

void Moose::Builder::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 2009 of file Builder.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() [18/20]

template<>

void Moose::Builder::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 2034 of file Builder.C.

{
  auto vec = root()->param<std::vector<double>>(full_name);
  if (vec.size() != LIBMESH_DIM * LIBMESH_DIM)
  {
    _errmsg += hit::errormsg(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() [19/20]

template<>

void Moose::Builder::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 2071 of file Builder.C.

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

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

setScalarParameter() [20/20]

template<>

void Moose::Builder::setScalarParameter ( const std::string &  full_name, const std::string &  , InputParameters::Parameter< ReporterName > *  param, bool  , GlobalParamsAction *    )

protected

Definition at line 2090 of file Builder.C.

{
  std::vector<std::string> names =
      MooseUtils::rsplit(root()->param<std::string>(full_name), "/", 2);
  if (names.size() != 2)
    _errmsg += hit::errormsg(root()->find(full_name),
                             "The supplied name ReporterName '",
                             full_name,
                             "' must contain the '/' delimiter.");
  else
    param->set() = ReporterName(names[0], names[1]);
}

setScalarValueTypeParameter()

template<typename T , typename UP_T , typename Base >

void Moose::Builder::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 1416 of file Builder.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);
}

setTripleIndexParameter()

template<typename T >

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

protected

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

Definition at line 1616 of file Builder.C.

{
  // Get the full string assigned to the variable full_name
  const std::string buffer_raw = root()->param<std::string>(full_name);
  // In case the parameter is empty
  if (buffer_raw.find_first_not_of(' ', 0) == std::string::npos)
    return;

  // Add a space between neighboring delim's, before the first delim if nothing is ahead of it, and
  // after the last delim if nothing is behind it.
  std::string buffer;
  buffer.push_back(buffer_raw[0]);
  if (buffer[0] == '|' || buffer[0] == ';')
    buffer = ' ' + buffer;
  for (std::string::size_type i = 1; i < buffer_raw.size(); i++)
  {
    if ((buffer_raw[i - 1] == '|' || buffer_raw[i - 1] == ';') &&
        (buffer_raw[i] == '|' || buffer_raw[i] == ';'))
      buffer.push_back(' ');
    buffer.push_back(buffer_raw[i]);
  }
  if (buffer.back() == '|' || buffer.back() == ';')
    buffer.push_back(' ');

  // split vector at delim | to get a series of 2D subvectors
  std::vector<std::string> first_tokenized_vector;
  std::vector<std::vector<std::string>> second_tokenized_vector;
  MooseUtils::tokenize(buffer, first_tokenized_vector, 1, "|");
  param->set().resize(first_tokenized_vector.size());
  second_tokenized_vector.resize(first_tokenized_vector.size());
  for (unsigned j = 0; j < first_tokenized_vector.size(); ++j)
  {
    // Identify empty subvector first
    if (first_tokenized_vector[j].find_first_not_of(' ', 0) == std::string::npos)
    {
      param->set()[j].resize(0);
      continue;
    }
    // split each 2D subvector at delim ; to get 1D sub-subvectors
    // NOTE: the 1D sub-subvectors are _not_ of type T yet
    MooseUtils::tokenize(first_tokenized_vector[j], second_tokenized_vector[j], 1, ";");
    param->set()[j].resize(second_tokenized_vector[j].size());
    for (unsigned k = 0; k < second_tokenized_vector[j].size(); ++k)
      if (!MooseUtils::tokenizeAndConvert<T>(second_tokenized_vector[j][k], param->set()[j][k]))
      {
        _errmsg +=
            hit::errormsg(root()->find(full_name), "invalid format for parameter ", full_name) +
            "\n";
        return;
      }
  }

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

setVectorComponentParameter()

template<typename T >

void Moose::Builder::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 1738 of file Builder.C.

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

  if (vec.size() % LIBMESH_DIM)
  {
    _errmsg += hit::errormsg(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];
  }
}

setVectorParameter() [1/15]

template<typename T , typename Base >

void Moose::Builder::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 1433 of file Builder.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(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/15]

template<>

void Moose::Builder::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/15]

template<>

void Moose::Builder::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/15]

template<>

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

protected

setVectorParameter() [5/15]

template<>

void Moose::Builder::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() [6/15]

template<>

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

protected

setVectorParameter() [7/15]

template<>

void Moose::Builder::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() [8/15]

template<>

void Moose::Builder::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 2110 of file Builder.C.

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

setVectorParameter() [9/15]

template<>

void Moose::Builder::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 2122 of file Builder.C.

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

setVectorParameter() [10/15]

template<>

void Moose::Builder::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 2133 of file Builder.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() [11/15]

template<>

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

protected

Definition at line 2170 of file Builder.C.

{
  const std::vector<MultiMooseEnum> & enum_values = param->get();

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

  std::vector<std::string> first_tokenized_vector = MooseUtils::split(buffer, ";");
  for (const auto & i : first_tokenized_vector)
    if (MooseUtils::trim(i) == "")
      mooseError("In " + full_name + ", one entry in the vector is empty.  This is not allowed.");

  param->set().resize(first_tokenized_vector.size(), enum_values[0]);

  std::vector<std::vector<std::string>> vecvec(first_tokenized_vector.size());
  for (const auto i : index_range(vecvec))
  {
    MooseUtils::tokenize<std::string>(first_tokenized_vector[i], vecvec[i], 1, " ");
    param->set()[i] = vecvec[i];
  }

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

setVectorParameter() [12/15]

template<>

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

protected

Definition at line 2207 of file Builder.C.

{
  std::vector<std::string> pps_names = root()->param<std::vector<std::string>>(full_name);
  unsigned int n = pps_names.size();
  param->set().resize(n);

  for (unsigned int j = 0; j < n; ++j)
    param->set()[j] = pps_names[j];

  if (in_global)
  {
    global_block->remove(short_name);
    global_block->setVectorParam<PostprocessorName>(short_name).resize(n, "");
    for (unsigned int j = 0; j < n; ++j)
      global_block->setVectorParam<PostprocessorName>(short_name)[j] = pps_names[j];
  }
}

setVectorParameter() [13/15]

template<>

void Moose::Builder::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 2236 of file Builder.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(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];
  }
}

setVectorParameter() [14/15]

template<>

void Moose::Builder::setVectorParameter ( const std::string &  full_name, const std::string &  , InputParameters::Parameter< std::vector< ReporterName >> *  param, bool  , GlobalParamsAction *    )

protected

Definition at line 2290 of file Builder.C.

{
  auto rnames = root()->param<std::vector<std::string>>(full_name);
  param->set().resize(rnames.size());

  for (unsigned int i = 0; i < rnames.size(); ++i)
  {
    std::vector<std::string> names = MooseUtils::rsplit(rnames[i], "/", 2);
    if (names.size() != 2)
      _errmsg += hit::errormsg(root()->find(full_name),
                               "The supplied name ReporterName '",
                               rnames[i],
                               "' must contain the '/' delimiter.");
    else
      param->set()[i] = ReporterName(names[0], names[1]);
  }
}

setVectorParameter() [15/15]

template<>

void Moose::Builder::setVectorParameter ( const std::string &  full_name, const std::string &  , InputParameters::Parameter< std::vector< CLIArgString >> *  param, bool  , GlobalParamsAction *    )

protected

Definition at line 2315 of file Builder.C.

{
  // Parsed as a vector of string, the vectors parameters are being cut
  auto rnames = root()->param<std::vector<std::string>>(full_name);
  param->set().resize(rnames.size()); // slightly oversized if vectors have been split

  // Skip empty parameter
  if (rnames.empty())
    return;

  // Re-assemble vector parameters
  unsigned int i_param = 0;
  bool vector_param_detected = false;
  for (unsigned int i = 0; i < rnames.size(); ++i)
  {
    // Look for a quote, both types
    std::vector<std::string> double_split =
        MooseUtils::rsplit(rnames[i], "\"", std::numeric_limits<std::size_t>::max());
    std::vector<std::string> single_split =
        MooseUtils::rsplit(rnames[i], "\'", std::numeric_limits<std::size_t>::max());
    if (double_split.size() + single_split.size() >= 3)
      // Either entering or exiting a vector parameter (>3 is entering another vector)
      // Even and >2 number of quotes means both finished and started another vector parameter
      if ((double_split.size() + single_split.size()) % 2 == 1)
        vector_param_detected = !vector_param_detected;

    // We're building a vector parameters, just append the text, rebuild the spaces
    if (vector_param_detected)
      param->set()[i_param] += rnames[i] + ' ';
    else
    {
      param->set()[i_param] += rnames[i];
      i_param++;
    }
  }
  // Use actual size after re-forming vector parameters
  param->set().resize(i_param);
}

setVectorVectorComponentParameter()

template<typename T >

void Moose::Builder::setVectorVectorComponentParameter ( 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 vector of several multivalue "scalar" type parameter read from the input file or command line.

Examples include vectors of several "Point"s and "RealVectorValue"s such as (a three-element vector; each element is several "Point"s): points_values = '0 0 0 0 0 1; 0 1 0; 1 0 0 1 1 0 1 1 1'

Definition at line 1790 of file Builder.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());

  // get a vector<vector<double>> first
  std::vector<std::vector<double>> vecvec(first_tokenized_vector.size());
  for (unsigned j = 0; j < vecvec.size(); ++j)
    if (!MooseUtils::tokenizeAndConvert<double>(first_tokenized_vector[j], vecvec[j]))
    {
      _errmsg +=
          hit::errormsg(root()->find(full_name), "invalid format for parameter ", full_name) + "\n";
      return;
    }

  for (const auto & vec : vecvec)
    if (vec.size() % LIBMESH_DIM)
    {
      _errmsg +=
          hit::errormsg(root()->find(full_name),
                        "wrong number of values in double-indexed vector component parameter ",
                        full_name,
                        ": size of subcomponent ",
                        vec.size(),
                        " is not a multiple of ",
                        LIBMESH_DIM) +
          "\n";
      return;
    }

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

  param->set() = values;

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

validParams()

InputParameters Moose::Builder::validParams ( )

static

Parameters that are processed directly by the Parser and are valid anywhere in the input.

Add the "active" and "inactive" parameters so that all blocks in the input file can selectively create lists of active/inactive sub-blocks.

Definition at line 141 of file Builder.C.

Referenced by JsonSyntaxTree::addGlobal(), MooseServer::getAllValidParameters(), and Action::validParams().

{
  InputParameters params = emptyInputParameters();

  params.addParam<std::vector<std::string>>(
      "active",
      std::vector<std::string>({"__all__"}),
      "If specified only the blocks named will be visited and made active");
  params.addParam<std::vector<std::string>>(
      "inactive",
      std::vector<std::string>(),
      "If specified blocks matching these identifiers will be skipped.");

  return params;
}

walk()

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

Definition at line 311 of file Builder.C.

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

walkRaw()

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

private

Definition at line 206 of file Builder.C.

Referenced by build(), and walk().

{
  InputParameters active_list_params = Action::validParams();
  InputParameters params = EmptyAction::validParams();

  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()))
    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);

  // Make sure at least one action is associated with the current identifier
  if (const auto [begin, end] = _syntax.getActions(registered_identifier); begin == end)
  {
    _errmsg += hit::errormsg(n,
                             "section '[",
                             curr_identifier,
                             "]' does not have an associated \"Action\".\n Common causes:\n"
                             "- you misspelled the Action/section name\n"
                             "- the app you are running does not support this Action/syntax") +
               "\n";
    return;
  }

  // The DynamicObjecRegistrationAction changes the action multimap and would invalidate the
  // iterators returned by _syntax.getActions, that's why we have to loop in this awkward way.
  std::set<const Syntax::ActionInfo *> processed_actions;
  while (true)
  {
    // search for an unprocessed action
    auto [begin, end] = _syntax.getActions(registered_identifier);
    auto it = begin;
    for (; it != end && processed_actions.count(&it->second); ++it)
      ;

    // no more unprocessed actions
    if (it == end)
      break;

    // mark action as processed
    processed_actions.insert(&it->second);

    if (is_parent)
      continue;
    if (_syntax.isDeprecatedSyntax(registered_identifier))
      mooseDeprecated(
          hit::errormsg(n, _syntax.deprecatedActionSyntaxMessage(registered_identifier)));

    params = _action_factory.getValidParams(it->second._action);
    params.set<ActionWarehouse *>("awh") = &_action_wh;
    params.setHitNode(*n, {});

    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;

    if (!(params.have_parameter<bool>("isObjectAction") && params.get<bool>("isObjectAction")))
      params.set<std::vector<std::string>>("control_tags")
          .push_back(MooseUtils::baseName(curr_identifier));

    // Create the Action
    std::shared_ptr<Action> action_obj =
        _action_factory.create(it->second._action, 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)
      {
        auto & object_params = object_action->getObjectParams();
        object_params.setHitNode(*n, {});
        extractParams(curr_identifier, object_params);
        object_params.set<std::vector<std::string>>("control_tags")
            .push_back(MooseUtils::baseName(curr_identifier));
      }
      // extract the Component params if necessary
      std::shared_ptr<AddActionComponentAction> component_action =
          std::dynamic_pointer_cast<AddActionComponentAction>(action_obj);
      if (component_action)
      {
        auto & component_params = component_action->getComponentParams();
        component_params.setHitNode(*n, {});
        extractParams(curr_identifier, component_params);
        component_params.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& Moose::Builder::_action_factory

protected

The Factory that builds actions.

Definition at line 230 of file Builder.h.

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

_action_wh

ActionWarehouse& Moose::Builder::_action_wh

protected

Action warehouse that will be filled by actions.

Definition at line 228 of file Builder.h.

Referenced by extractParams(), and walkRaw().

_app

MooseApp& Moose::Builder::_app

protected

The MooseApp this Parser is part of.

Definition at line 224 of file Builder.h.

Referenced by build(), and errorCheck().

_cli_root

std::unique_ptr<hit::Node> Moose::Builder::_cli_root = nullptr

protected

Definition at line 217 of file Builder.h.

Referenced by build(), and errorCheck().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MeshOnlyAction::act(), SetupDebugAction::act(), MaterialOutputAction::act(), Adaptivity::adaptMesh(), FEProblemBase::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkRelativeConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), LinearSystem::computeLinearSystemTags(), FEProblemBase::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MFEMSteady::execute(), MessageFromInput::execute(), SteadyBase::execute(), Eigenvalue::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), CoarsenBlockGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseBaseErrorInterface::mooseDeprecated(), MooseBaseErrorInterface::mooseInfo(), MooseBaseErrorInterface::mooseWarning(), MooseBaseErrorInterface::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), ReporterDebugOutput::output(), PerfGraphOutput::output(), SolutionInvalidityOutput::output(), MaterialPropertyDebugOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), PicardSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), FEProblemSolve::solve(), FixedPointSolve::solve(), EigenProblem::solve(), NonlinearSystem::solve(), LinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), LStableDirk4::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), FixedPointSolve::solveStep(), PerfGraphLivePrint::start(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), TerminateChainControl::terminate(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_current_error_stream

std::ostringstream* Moose::Builder::_current_error_stream

protected

The current stream object used for capturing errors during extraction.

Definition at line 249 of file Builder.h.

Referenced by extractParams(), and setScalarValueTypeParameter().

_current_params

InputParameters* Moose::Builder::_current_params

protected

The current parameter object for which parameters are being extracted.

Definition at line 246 of file Builder.h.

Referenced by extractParams(), and setScalarValueTypeParameter().

_deprec_param_tracker

std::unordered_set<std::string> Moose::Builder::_deprec_param_tracker

protected

Tracks whether a deprecated param has had its warning message printed already.

Definition at line 252 of file Builder.h.

Referenced by extractParams().

_errmsg

std::string Moose::Builder::_errmsg

private

Definition at line 255 of file Builder.h.

Referenced by build(), errorCheck(), extractParams(), setDoubleIndexParameter(), setMapParameter(), setScalarComponentParameter(), setScalarParameter(), setTripleIndexParameter(), setVectorComponentParameter(), setVectorParameter(), setVectorVectorComponentParameter(), and walkRaw().

_extracted_vars

std::set<std::string> Moose::Builder::_extracted_vars

protected

The set of all variables extracted from the input file.

Definition at line 240 of file Builder.h.

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

_factory

Factory& Moose::Builder::_factory

protected

The Factory associated with that MooseApp.

Definition at line 226 of file Builder.h.

Referenced by buildFullTree(), and buildJsonSyntaxTree().

_parser

const std::shared_ptr<Parser> Moose::Builder::_parser

protected

The front parser.

Definition at line 234 of file Builder.h.

Referenced by Builder(), getPrimaryFileName(), and root().

_root

hit::Node* Moose::Builder::_root

protected

The root node from the Parser; in the future, we should probably clone this so that we don't muck with the root node in the Parser.

Definition at line 220 of file Builder.h.

_secs_need_first

std::vector<std::string> Moose::Builder::_secs_need_first

protected

Definition at line 221 of file Builder.h.

Referenced by build(), and walk().

_sections_read

bool Moose::Builder::_sections_read

protected

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

Definition at line 243 of file Builder.h.

_syntax

Syntax& Moose::Builder::_syntax

protected

Reference to an object that defines input file syntax.

Definition at line 232 of file Builder.h.

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

_syntax_formatter

std::unique_ptr<SyntaxTree> Moose::Builder::_syntax_formatter

protected

Object for holding the syntax parse tree.

Definition at line 237 of file Builder.h.

Referenced by buildFullTree(), and initSyntaxFormatter().

_warnmsg

std::string Moose::Builder::_warnmsg

private

Definition at line 256 of file Builder.h.

Referenced by errorCheck().

---

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

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