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, Parser &parser)
virtual	~Builder ()
std::string	getPrimaryFileName (bool stripLeadingPath=true) const
	Return the primary (first) filename that was parsed.
void	build ()
	Parse an input file (or text string if provided) consisting of hit syntax and setup objects in the MOOSE derived application.
void	extractParams (const hit::Node *const section_node, InputParameters &p)
	Attempt to extract values from input starting with the section in input in section_node based on the contents of the passed InputParameters p.
void	extractParams (const std::string &prefix, InputParameters &p)
	Attempt to extract values from input starting with the section in input defined by the fullpath prefix based on the contents of the passed InputParameters p.
void	initSyntaxFormatter (SyntaxFormatterType type, bool dump_mode)
	Creates a syntax formatter for printing.
void	buildFullTree (const std::string &search_string)
	Use MOOSE Factories to construct a full parse tree for documentation or echoing input.
void	buildJsonSyntaxTree (JsonSyntaxTree &tree) const
	Use MOOSE Factories to construct a parameter tree for documentation or echoing input.
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)

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

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

Private Member Functions
bool	isGlobal (const hit::Node &node) const
const hit::Node *	queryGlobalParamsNode () const
	Get the [GlobalParams] section node if it exists.
void	walkRaw (std::string fullpath, std::string nodepath, hit::Node *n)

Private Attributes
MooseApp &	_app
	The MooseApp this Parser is part of.
Factory &	_factory
	The Factory associated with that MooseApp.
ActionWarehouse &	_action_wh
	Action warehouse that will be filled by actions.
ActionFactory &	_action_factory
	The Factory that builds actions.
Syntax &	_syntax
	Reference to an object that defines input file syntax.
Parser &	_parser
	The front parser.
hit::Node &	_root
	The root node from the Parser.
std::unique_ptr< SyntaxTree >	_syntax_formatter
	Object for holding the syntax parse tree.
std::set< std::string >	_extracted_vars
	The set of all variables extracted from the input file.
std::vector< std::string >	_secs_need_first
	The sections that we need to execute first (read during the final walk)
std::vector< hit::ErrorMessage >	_errors
	The errors accumulated during the walk.
std::map< std::string, std::string >	_deprecated_params
	Deprecation warnings (object type/param name) -> (message)
std::optional< const hit::Node * >	_global_params_node
	The hit Node for the [GlobalParams] block, if any If set (could be null), it means we have searched for it.

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,
		Parser &	parser
	)

Definition at line 105 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),
    _root(_parser.getRoot()),
    _syntax_formatter(nullptr)
{
}

~Builder()

Moose::Builder::~Builder ( )

virtual

Definition at line 118 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 300 of file Builder.C.

{
  // Pull in extracted variables from the parser (fparse stuff)
  _extracted_vars = _parser.getExtractedVars();
 
  // There are a few order dependent actions that have to be built first in
  // order for the parser and application to function properly
  const auto need_action_syntax_first = [this](const auto & action_name)
  {
    const auto syntax = _syntax.getSyntaxByAction(action_name);
    mooseAssert(syntax.size(), "Empty syntax");
    std::copy(syntax.begin(), syntax.end(), std::back_inserter(_secs_need_first));
  };
 
  // SetupDebugAction: This action can contain an option for monitoring the
  // parser progress. It must be parsed first to capture all of the parsing
  // output progress.
  need_action_syntax_first("SetupDebugAction");
 
  // 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.
  need_action_syntax_first("GlobalParamsAction");
 
  // 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.
  need_action_syntax_first("DynamicObjectRegistrationAction");
 
  // Walk all the sections extracting paramters from each into InputParameters objects
  for (const auto & sec : _secs_need_first)
    if (auto n = _root.find(sec))
      walkRaw(n->parent()->fullpath(), n->path(), n);
 
  // Walk for the remainder
  _root.walk(this, hit::NodeType::Section);
 
  // Warn for all deprecated parameters together
  if (_deprecated_params.size())
  {
    std::vector<std::string> messages;
    for (const auto & key_message_pair : _deprecated_params)
      messages.push_back(key_message_pair.second);
    const auto message = MooseUtils::stringJoin(messages, "\n\n");
 
    moose::internal::mooseDeprecatedStream(Moose::out, false, true, false, message + "\n\n");
  }
 
  if (_errors.size())
    _parser.parseError(_errors);
}

Referenced by MooseApp::setupOptions().

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 577 of file Builder.C.

{
  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.hasBase() &&  // Has a registered base
            _syntax.verifyMooseObjectTask(moose_obj_params.getBase(),
                                          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;
}

Referenced by MooseApp::setupOptions().

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 417 of file Builder.C.

{
  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.hasBase() &&  // Has a registered base
            _syntax.verifyMooseObjectTask(moose_obj_params.getBase(),
                                          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();
}

Referenced by MooseApp::setupOptions().

errorCheck()

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

Definition at line 358 of file Builder.C.

{
  // Nothing to do here
  if (!warn_unused && !err_unused)
    return;
 
  std::vector<hit::ErrorMessage> messages;
 
  if (_parser.queryCommandLineRoot())
  {
    UnusedWalker uw(_extracted_vars, *this);
    _parser.getCommandLineRoot().walk(&uw);
    Parser::appendErrorMessages(messages, uw.errors);
  }
 
  {
    UnusedWalker uw(_extracted_vars, *this);
    _root.walk(&uw);
    Parser::appendErrorMessages(messages, uw.errors);
  }
 
  for (const auto & arg : _app.commandLine()->unusedHitParams(comm))
    messages.emplace_back("unused command line parameter '" + arg + "'");
 
  if (messages.size())
  {
    const auto message = _parser.joinErrorMessages(messages);
    if (warn_unused)
      mooseUnused(message);
    if (err_unused)
    {
      if (_parser.getThrowOnError())
        _parser.parseError(messages);
      else
        mooseError(
            message +
            "\n\nAppend --allow-unused (or -w) on the command line to ignore unused parameters.");
    }
  }
}

Referenced by MeshOnlyAction::act(), and MooseApp::errorCheck().

extractParams() [1/2]

void Moose::Builder::extractParams	(	const hit::Node *const	section_node,
		InputParameters &	p
	)

Attempt to extract values from input starting with the section in input in section_node based on the contents of the passed InputParameters p.

If section_node is not provided, only the global parameters will be checked

Definition at line 664 of file Builder.C.

{
  if (section_node)
    mooseAssert(section_node->type() == hit::NodeType::Section, "Node type should be a section");
 
  for (const auto & [name, par_unique_ptr] : p)
  {
    if (p.shouldIgnore(name))
      continue;
 
    // Find where this parameter is set. A parameter can be provided using its
    // blessed name or, for a renamed/deprecated parameter, one of its aliased names (see
    // paramAliases). We scan all of the aliases in both the given section and [GlobalParams]
    // so that (1) a value set locally always takes precedence over one set in [GlobalParams],
    // even when the two are set using different aliases, and (2) providing more than one alias
    // within the same scope, e.g. both a deprecated parameter and its replacement, is flagged
    // as a conflict rather than being silently resolved to one of them (see #32350).
    const hit::Node * local_node = nullptr;
    std::string local_name;
    const hit::Node * global_node = nullptr;
    std::string global_name;
 
    // Records a same-scope conflict between two aliases that refer to the same parameter
    const std::string & blessed_name = name;
    auto add_conflict_error = [this, &blessed_name](const std::string & first,
                                                    const std::string & second,
                                                    const auto * node)
    {
      _errors.emplace_back("The parameter '" + blessed_name +
                               "' was provided more than once using the aliased names '" + first +
                               "' and '" + second +
                               "', which refer to the same parameter. Please provide it only once, "
                               "using the name '" +
                               blessed_name + "'.",
                           node);
    };
 
    for (const auto & param_name : p.paramAliases(name))
    {
      // Check for the parameter under the given section, if a section node was provided
      if (section_node)
        if (const auto section_param_node = section_node->find(param_name);
            section_param_node && section_param_node->type() == hit::NodeType::Field &&
            section_param_node->parent() == section_node)
        {
          if (local_node)
            add_conflict_error(local_name, param_name, section_param_node);
          else
          {
            local_node = section_param_node;
            local_name = param_name;
          }
        }
 
      // Check for the parameter in [GlobalParams]
      if (queryGlobalParamsNode())
        if (const auto g_node = queryGlobalParamsNode()->find(param_name);
            g_node && g_node->type() == hit::NodeType::Field &&
            g_node->parent() == queryGlobalParamsNode())
        {
          mooseAssert(isGlobal(*g_node), "Could not detect global-ness");
          if (global_node)
            add_conflict_error(global_name, param_name, g_node);
          else
          {
            global_node = g_node;
            global_name = param_name;
          }
        }
    }
 
    // A value set locally takes precedence over one set in [GlobalParams]
    const hit::Node * const param_node = local_node ? local_node : global_node;
    const std::string & param_name = local_node ? local_name : global_name;
 
    // Found it
    if (param_node)
    {
      const auto fullpath = param_node->fullpath();
      p.setHitNode(param_name, *param_node, {});
      p.set_attributes(param_name, false);
      _extracted_vars.insert(fullpath);
 
      const auto global = isGlobal(*param_node);
 
      // Check for deprecated parameters if the parameter is not a global param
      if (!global)
        if (const auto deprecated_message = p.queryDeprecatedParamMessage(param_name))
        {
          std::string key = "";
          if (const auto object_type_ptr = p.queryObjectType())
            key += *object_type_ptr + "_";
          key += param_name;
          _deprecated_params.emplace(key, *deprecated_message);
        }
 
      // Private parameter, don't set
      if (p.isPrivate(param_name))
      {
        // Error if it isn't global, just once
        if (!global && std::find_if(_errors.begin(),
                                    _errors.end(),
                                    [&param_node](const auto & err)
                                    { return err.node == param_node; }) == _errors.end())
          _errors.emplace_back("parameter '" + fullpath + "' is private and cannot be set",
                               param_node);
      }
      else
      {
        // Set the value, capturing errors
        const auto param_field = dynamic_cast<const hit::Field *>(param_node);
        mooseAssert(param_field, "Is not a field");
        bool set_param = false;
        try
        {
          ParameterRegistry::get().set(*par_unique_ptr, *param_field);
          set_param = true;
        }
        catch (hit::Error & e)
        {
          _errors.emplace_back(e.message, param_node);
        }
        catch (std::exception & e)
        {
          _errors.emplace_back(e.what(), param_node);
        }
 
        // Only perform the extra checks if the value was successfully set
        if (set_param)
        {
          // Special setup for vector<VariableName>
          if (auto cast_par = dynamic_cast<InputParameters::Parameter<std::vector<VariableName>> *>(
                  par_unique_ptr.get()))
            if (const auto error = p.setupVariableNames(cast_par->set(), *param_node, {}))
              _errors.emplace_back(*error, param_node);
 
          // Possibly perform a range check if this parameter has one
          if (p.isRangeChecked(param_node->path()))
            if (const auto error = p.parameterRangeCheck(
                    *par_unique_ptr, param_node->fullpath(), param_node->path(), true))
              _errors.emplace_back(error->second, param_node);
        }
      }
    }
    // Special casing when the parameter was not found
    else
    {
      // 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.
      if (auto out_par_ptr =
              dynamic_cast<InputParameters::Parameter<OutFileBase> *>(par_unique_ptr.get()))
      {
        const auto input_file_name = getPrimaryFileName();
        mooseAssert(input_file_name.size(), "Input Filename is empty");
        const auto pos = input_file_name.find_last_of('.');
        mooseAssert(pos != std::string::npos, "Unable to determine suffix of input file name");
        out_par_ptr->set() = input_file_name.substr(0, pos) + "_out";
        p.set_attributes(name, false);
      }
    }
  }
 
  // See if there are any auto build vectors that need to be created
  for (const auto & [param_name, base_name_num_repeat_pair] : p.getAutoBuildVectors())
  {
    const auto & [base_name, num_repeat] = base_name_num_repeat_pair;
    // We'll autogenerate values iff the requested vector is not valid but both the base and
    // number are valid
    if (!p.isParamValid(param_name) && p.isParamValid(base_name) && p.isParamValid(num_repeat))
    {
      const auto 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 (const auto i : index_range(variable_names))
      {
        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>>(param_name) = variable_names;
    }
  }
}

Referenced by CreateProblemDefaultAction::act(), SetupMeshAction::act(), extractParams(), and walkRaw().

extractParams() [2/2]

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

Attempt to extract values from input starting with the section in input defined by the fullpath prefix based on the contents of the passed InputParameters p.

Definition at line 853 of file Builder.C.

{
  const auto node = _root.find(prefix);
  extractParams((node && node->type() == hit::NodeType::Section) ? node : nullptr, p);
}

getPrimaryFileName()

std::string Moose::Builder::getPrimaryFileName

(

bool

stripLeadingPath = true

)

const

Return the primary (first) filename that was parsed.

Definition at line 179 of file Builder.C.

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

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

initSyntaxFormatter()

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

Creates a syntax formatter for printing.

Definition at line 400 of file Builder.C.

{
  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;
  }
}

Referenced by MooseApp::setupOptions().

isGlobal()

bool Moose::Builder::isGlobal ( const hit::Node &  node ) const

private

Returns

Whether or not the given node node exists within the [GlobalParams] block

Definition at line 860 of file Builder.C.

{
  const auto global_params_node = queryGlobalParamsNode();
  return global_params_node && node.parent() == global_params_node;
}

Referenced by extractParams().

listValidParams()

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

(

std::string &

section_name

)

Definition at line 142 of file Builder.C.

{
  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;
}

Referenced by Moose::UnusedWalker::walk().

queryGlobalParamsNode()

const hit::Node * Moose::Builder::queryGlobalParamsNode ( ) const

private

Get the [GlobalParams] section node if it exists.

We need to separate this so that we can call extractParams() before calling build()

Definition at line 867 of file Builder.C.

{
  if (!_global_params_node)
  {
    const auto syntax = _syntax.getSyntaxByAction("GlobalParamsAction");
    mooseAssert(syntax.size() == 1, "Unexpected GlobalParamsAction syntax size");
    _global_params_node = _root.find(syntax.front());
  }
  return *_global_params_node;
}

Referenced by extractParams(), and isGlobal().

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 121 of file Builder.C.

{
  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;
}

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

walk()

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

Definition at line 289 of file Builder.C.

{
  // skip sections that were manually processed first.
  if (std::find(_secs_need_first.begin(), _secs_need_first.end(), nodepath) !=
      _secs_need_first.end())
    return;
 
  walkRaw(fullpath, nodepath, n);
}

walkRaw()

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

private

Definition at line 186 of file Builder.C.

{
  InputParameters active_list_params = Action::validParams();
  InputParameters params = EmptyAction::validParams();
 
  const std::string section_name = n->fullpath();
  const 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(*n))
    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)
  {
    _errors.emplace_back(
        "section '[" + curr_identifier +
            "]' does not have an associated Action; you likely misspelled the Action/section name "
            "or 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(n, 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(n, 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(n, 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);
  }
}

Referenced by build(), and walk().

Member Data Documentation

_action_factory

ActionFactory& Moose::Builder::_action_factory

private

The Factory that builds actions.

Definition at line 139 of file Builder.h.

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

_action_wh

ActionWarehouse& Moose::Builder::_action_wh

private

Action warehouse that will be filled by actions.

Definition at line 137 of file Builder.h.

Referenced by walkRaw().

_app

MooseApp& Moose::Builder::_app

private

The MooseApp this Parser is part of.

Definition at line 133 of file Builder.h.

Referenced by 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(), MaterialOutputAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), FEProblemBase::adaptMesh(), Adaptivity::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonConformingFaces(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), CoarsenSurfaceMeshAlongSidesetGenerator::coarsenAlongSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeLinearSystemTags(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), TimeStepper::constrainStep(), IterationAdaptiveDT::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), MessageFromInput::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), SidesetAroundSubdomainUpdater::finalize(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), CoarsenBlockGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), Console::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), PerfGraphOutput::output(), ReporterDebugOutput::output(), SolutionInvalidityOutput::output(), VariableResidualNormsDebugOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), WebServerControl::outputMessage(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), PicardSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::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(), LinearSystem::solve(), NonlinearSystem::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), EigenProblem::solve(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), MFEMTransient::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_deprecated_params

std::map<std::string, std::string> Moose::Builder::_deprecated_params

private

Deprecation warnings (object type/param name) -> (message)

Definition at line 160 of file Builder.h.

Referenced by build(), and extractParams().

_errors

std::vector<hit::ErrorMessage> Moose::Builder::_errors

private

The errors accumulated during the walk.

Definition at line 157 of file Builder.h.

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

_extracted_vars

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

private

The set of all variables extracted from the input file.

Definition at line 151 of file Builder.h.

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

_factory

Factory& Moose::Builder::_factory

private

The Factory associated with that MooseApp.

Definition at line 135 of file Builder.h.

Referenced by buildFullTree(), and buildJsonSyntaxTree().

_global_params_node

std::optional<const hit::Node *> Moose::Builder::_global_params_node

mutableprivate

The hit Node for the [GlobalParams] block, if any If set (could be null), it means we have searched for it.

Definition at line 164 of file Builder.h.

Referenced by queryGlobalParamsNode().

_parser

Parser& Moose::Builder::_parser

private

The front parser.

Definition at line 143 of file Builder.h.

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

_root

hit::Node& Moose::Builder::_root

private

The root node from the Parser.

Definition at line 145 of file Builder.h.

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

_secs_need_first

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

private

The sections that we need to execute first (read during the final walk)

Definition at line 154 of file Builder.h.

Referenced by build(), and walk().

_syntax

Syntax& Moose::Builder::_syntax

private

Reference to an object that defines input file syntax.

Definition at line 141 of file Builder.h.

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

_syntax_formatter

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

private

Object for holding the syntax parse tree.

Definition at line 148 of file Builder.h.

Referenced by buildFullTree(), and initSyntaxFormatter().

---

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

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