ActionWarehouse Class Reference

Storage for action instances. More...

#include <ActionWarehouse.h>

Inheritance diagram for ActionWarehouse:

Public Member Functions
	ActionWarehouse (MooseApp &app, Syntax &syntax, ActionFactory &factory)
	~ActionWarehouse ()
void	build ()
	Builds all auto-buildable tasks. More...
void	clear ()
	This method deletes all of the Actions in the warehouse. More...
bool	empty () const
	returns a Boolean indicating whether the warehouse is empty or not. More...
void	addActionBlock (std::shared_ptr< Action > blk)
	This method add an Action instance to the warehouse. More...
void	checkUnsatisfiedActions () const
	This method checks the actions stored in the warehouse against the list of required registered actions to see if all of them have been satisfied. More...
void	printActionDependencySets () const
	This method is used only during debugging when show_actions is set to true. More...
void	printInputFile (std::ostream &out)
	This method uses the Actions in the warehouse to reproduce the input file. More...
const std::vector< std::shared_ptr< Action > > &	allActionBlocks () const
	Returns a reference to all of the actions. More...
const std::list< Action * > &	getActionListByName (const std::string &task) const
	Retrieve a constant list of Action pointers associated with the passed in task. More...
template<class T >
const T &	getAction (const std::string &name)
	Retrieve an action with its name and the desired type. More...
template<class T >
std::vector< const T * >	getActions ()
	Retrieve all actions in a specific type ordered by their names. More...
template<class T >
const T *	getActionByTask (const std::string &task)
	Retrieve the action on a specific task with its type. More...
void	setFinalTask (const std::string &task)
bool	hasActions (const std::string &task) const
	Check if Actions associated with passed in task exist. More...
void	executeAllActions ()
	This method loops over all actions in the warehouse and executes them. More...
void	executeActionsWithAction (const std::string &name)
	This method executes only the actions in the warehouse that satisfy the task passed in. More...
void	showActions (bool state=true)
	This method sets a Boolean which is used to show debugging information during various warehouse operations during the problem setup phase. More...
void	showParser (bool state=true)
Syntax &	syntax ()
std::shared_ptr< MooseMesh > &	mesh ()
std::shared_ptr< MooseMesh > &	displacedMesh ()
std::shared_ptr< FEProblemBase > &	problemBase ()
std::shared_ptr< FEProblem >	problem ()
MooseApp &	mooseApp ()
const std::string &	getCurrentTaskName () const
std::string	getCurrentActionName () const
ActionIterator	actionBlocksWithActionBegin (const std::string &task)
	Iterators to the Actions in the warehouse. More...
ActionIterator	actionBlocksWithActionEnd (const std::string &task)

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

Protected Member Functions
void	buildBuildableActions (const std::string &task)
	This method auto-builds all Actions that needs to be built and adds them to ActionWarehouse. More...

Protected Attributes
std::vector< std::shared_ptr< Action > >	_all_ptrs
MooseApp &	_app
	The MooseApp this Warehouse is associated with. More...
Syntax &	_syntax
	Reference to a "syntax" of actions. More...
ActionFactory &	_action_factory
	The Factory that builds Actions. More...
std::map< std::string, std::list< Action * > >	_action_blocks
	Pointers to the actual parsed input file blocks. More...
std::map< std::string, std::vector< Action * > >	_requested_action_blocks
	Action blocks that have been requested. More...
std::vector< std::string >	_ordered_names
	The container that holds the sorted action names from the DependencyResolver. More...
std::set< std::string >	_unsatisfied_dependencies
	Use to store the current list of unsatisfied dependencies. More...
bool	_generator_valid
	Flag to indicate whether or not there is an active iterator on this class. More...
bool	_show_actions
bool	_show_parser
std::string	_current_task
std::shared_ptr< MooseMesh >	_mesh
	Mesh class. More...
std::shared_ptr< MooseMesh >	_displaced_mesh
	Possible mesh for displaced problem. More...
std::shared_ptr< FEProblemBase >	_problem
	Problem class. More...

Private Attributes
std::string	_final_task
	Last task to run before (optional) early termination - blank means no early termination. More...
ActionIterator	_act_iter

Detailed Description

Storage for action instances.

Definition at line 35 of file ActionWarehouse.h.

Constructor & Destructor Documentation

ActionWarehouse()

ActionWarehouse::ActionWarehouse	(	MooseApp &	app,
		Syntax &	syntax,
		ActionFactory &	factory
	)

Definition at line 25 of file ActionWarehouse.C.

  : ConsoleStreamInterface(app),
    _app(app),
    _syntax(syntax),
    _action_factory(factory),
    _generator_valid(false),
    _show_actions(false),
    _show_parser(false)
{
}

~ActionWarehouse()

ActionWarehouse::~ActionWarehouse

(

)

Definition at line 36 of file ActionWarehouse.C.

{}

Member Function Documentation

actionBlocksWithActionBegin()

ActionIterator ActionWarehouse::actionBlocksWithActionBegin

(

const std::string &

task

)

Iterators to the Actions in the warehouse.

Iterators should always be used when executing Actions to capture dynamically added Actions (meta-Actions). Meta-Actions are allowed to create and add additional Actions to the warehouse on the fly. Those Actions will fire as long as their associated task hasn't already passed (i.e. matches or is later).

Definition at line 170 of file ActionWarehouse.C.

Referenced by SetupDampersAction::act(), executeActionsWithAction(), Parser::extractParams(), and CommonOutputAction::hasConsole().

{
  return _action_blocks[task].begin();
}

actionBlocksWithActionEnd()

ActionIterator ActionWarehouse::actionBlocksWithActionEnd

(

const std::string &

task

)

Definition at line 176 of file ActionWarehouse.C.

Referenced by SetupDampersAction::act(), executeActionsWithAction(), Parser::extractParams(), and CommonOutputAction::hasConsole().

{
  return _action_blocks[task].end();
}

addActionBlock()

void ActionWarehouse::addActionBlock

(

std::shared_ptr< Action >

blk

)

This method add an Action instance to the warehouse.

Note: This routine uses the XTerm colors directly which is not advised for general purpose output coloring. Most users should prefer using Problem::colorText() which respects the "color_output" option for terminals that do not support coloring. Since this routine is intended for debugging only and runs before several objects exist in the system, we are just using the constants directly.

We need to see if the current Action satisfies multiple tasks. There are a few cases to consider:

1. The current Action is registered with multiple syntax blocks. In this case we can only use the current instance to satisfy the specific task listed for this syntax block. We can detect this case by inspecting whether it has a "specific task name" set in the Action instance.
2. This action does not have a valid "registered identifier" set in the Action instance. This means that this Action was not built by the Parser. It was most likely created through a Meta-Action (See Case 3 for exception). In this case, the ActionFactory itself would have already set the task it found from the build info used to construct the Action so we'd arbitrarily satisify a single task in this case.
3. The current Action is registered with only a single syntax block. In this case we can simply re-use the current instance to act and satisfy all registered tasks. This is the normal case where we have a Parser-built Action that does not have a specific task name to satisfy. We will use the Action "type" to retrieve the list of tasks that this Action may satisfy.

Definition at line 73 of file ActionWarehouse.C.

Referenced by buildBuildableActions(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), MooseApp::createMinimalApp(), and Parser::walkRaw().

{
  std::string registered_identifier =
      action->parameters().get<std::string>("registered_identifier");
  std::set<std::string> tasks;

  if (_show_parser)
    Moose::err << COLOR_DEFAULT << "Parsing Syntax:        " << COLOR_GREEN << action->name()
               << '\n'
               << COLOR_DEFAULT << "Building Action:       " << COLOR_DEFAULT << action->type()
               << '\n'
               << COLOR_DEFAULT << "Registered Identifier: " << COLOR_GREEN << registered_identifier
               << '\n'
               << COLOR_DEFAULT << "Specific Task:         " << COLOR_CYAN
               << action->specificTaskName() << '\n';

  if (action->specificTaskName() != "") // Case 1
    tasks.insert(action->specificTaskName());
  else if (registered_identifier == "" &&
           _syntax.getSyntaxByAction(action->type()).size() > 1) // Case 2
  {
    std::set<std::string> local_tasks = action->getAllTasks();
    mooseAssert(local_tasks.size() == 1, "More than one task inside of the " << action->name());
    tasks.insert(*local_tasks.begin());
  }
  else // Case 3
    tasks = _action_factory.getTasksByAction(action->type());

  // TODO: Now we need to weed out the double registrations!
  for (const auto & task : tasks)
  {
    // Some error checking
    if (!_syntax.hasTask(task))
      mooseError("A(n) ", task, " is not a registered task");

    // Make sure that the ObjectAction task and Action task are consistent
    // otherwise that means that is action was built by the wrong type
    std::shared_ptr<MooseObjectAction> moa = std::dynamic_pointer_cast<MooseObjectAction>(action);
    if (moa.get())
    {
      const InputParameters & mparams = moa->getObjectParams();

      if (mparams.have_parameter<std::string>("_moose_base"))
      {
        const std::string & base = mparams.get<std::string>("_moose_base");

        if (!_syntax.verifyMooseObjectTask(base, task))
          mooseError("Task ", task, " is not registered to build ", base, " derived objects");
      }
      else
        mooseError("Unable to locate registered base parameter for ", moa->getMooseObjectType());
    }

    // Add the current task to current action
    action->appendTask(task);

    if (_show_parser)
      Moose::err << COLOR_YELLOW << "Adding Action:         " << COLOR_DEFAULT << action->type()
                 << " (" << COLOR_YELLOW << task << COLOR_DEFAULT << ")\n";

    // Add it to the warehouse
    _action_blocks[task].push_back(action.get());
  }
  _all_ptrs.push_back(action);

  if (_show_parser)
    Moose::err << std::endl;
}

allActionBlocks()

const std::vector< std::shared_ptr< Action > > & ActionWarehouse::allActionBlocks

(

)

const

Returns a reference to all of the actions.

Definition at line 182 of file ActionWarehouse.C.

Referenced by AddRelationshipManager::act().

{
  return _all_ptrs;
}

build()

void ActionWarehouse::build

(

)

Builds all auto-buildable tasks.

This method is typically called after the Parser has created Actions based on an input file.

Definition at line 47 of file ActionWarehouse.C.

Referenced by MooseApp::createMinimalApp(), and MooseApp::setupOptions().

{
  _ordered_names = _syntax.getSortedTask();
  for (const auto & name : _ordered_names)
    buildBuildableActions(name);
}

buildBuildableActions()

void ActionWarehouse::buildBuildableActions ( const std::string &  task )

protected

This method auto-builds all Actions that needs to be built and adds them to ActionWarehouse.

An Action needs to be built if it is associated with a task that is marked as required and all of it's parameters are valid (are not required or have default values supplied).

Parameters

task	The name of the task to find and build Actions for.

Definition at line 204 of file ActionWarehouse.C.

Referenced by build().

{
  if (_syntax.shouldAutoBuild(task) && _action_blocks[task].empty())
  {
    bool ret_value = false;
    auto it_pair = _action_factory.getActionsByTask(task);
    for (const auto & action_pair : as_range(it_pair))
    {
      InputParameters params = _action_factory.getValidParams(action_pair.second);
      params.set<ActionWarehouse *>("awh") = this;

      if (params.areAllRequiredParamsValid())
      {
        params.set<std::string>("registered_identifier") = "(AutoBuilt)";
        addActionBlock(_action_factory.create(action_pair.second, "", params));
        ret_value = true;
      }
    }

    if (!ret_value)
      _unsatisfied_dependencies.insert(task);
  }
}

checkUnsatisfiedActions()

void ActionWarehouse::checkUnsatisfiedActions

(

)

const

This method checks the actions stored in the warehouse against the list of required registered actions to see if all of them have been satisfied.

It should be called before running a MOOSE problem

Definition at line 229 of file ActionWarehouse.C.

Referenced by CheckIntegrityAction::act().

{
  std::stringstream oss;
  bool empty = true;

  for (const auto & udep : _unsatisfied_dependencies)
  {
    if (_action_blocks.find(udep) == _action_blocks.end())
    {
      if (empty)
        empty = false;
      else
        oss << " ";
      oss << udep;
    }
  }

  if (!empty)
    mooseError(
        std::string(
            "The following unsatisfied actions where found while setting up the MOOSE problem:\n") +
        oss.str() + "\n");
}

clear()

void ActionWarehouse::clear

(

)

This method deletes all of the Actions in the warehouse.

Definition at line 55 of file ActionWarehouse.C.

Referenced by MooseApp::~MooseApp().

{
  for (auto & ptr : _all_ptrs)
    ptr.reset();

  _action_blocks.clear();
  _generator_valid = false;

  // Due to the way ActionWarehouse is cleaned up (see MooseApp's
  // destructor) we must guarantee that ActionWarehouse::clear()
  // releases all the resources which have to be released _before_ the
  // _comm object owned by the MooseApp is destroyed.
  _problem.reset();
  _displaced_mesh.reset();
  _mesh.reset();
}

displacedMesh()

std::shared_ptr<MooseMesh>& ActionWarehouse::displacedMesh ( )

inline

Definition at line 216 of file ActionWarehouse.h.

Referenced by MooseApp::executeMeshGenerators(), and MooseApp::executeMeshModifiers().

{ return _displaced_mesh; }

empty()

bool ActionWarehouse::empty ( ) const

inline

returns a Boolean indicating whether the warehouse is empty or not.

Definition at line 55 of file ActionWarehouse.h.

Referenced by checkUnsatisfiedActions().

{ return _action_blocks.empty(); }

executeActionsWithAction()

void ActionWarehouse::executeActionsWithAction

(

const std::string &

name

)

This method executes only the actions in the warehouse that satisfy the task passed in.

Definition at line 345 of file ActionWarehouse.C.

Referenced by executeAllActions().

{
  // Set the current task name
  _current_task = task;

  for (_act_iter = actionBlocksWithActionBegin(task); _act_iter != actionBlocksWithActionEnd(task);
       ++_act_iter)
  {
    if (_show_actions)
      _console << "[DBG][ACT] "
               << "TASK (" << COLOR_YELLOW << std::setw(24) << task << COLOR_DEFAULT << ") "
               << "TYPE (" << COLOR_YELLOW << std::setw(32) << (*_act_iter)->type() << COLOR_DEFAULT
               << ") "
               << "NAME (" << COLOR_YELLOW << std::setw(16) << (*_act_iter)->name() << COLOR_DEFAULT
               << ")" << std::endl;

    (*_act_iter)->timedAct();
  }
}

executeAllActions()

void ActionWarehouse::executeAllActions

(

)

This method loops over all actions in the warehouse and executes them.

Meta-actions may add new actions to the warehouse on the fly and they will still be executed in order

Definition at line 326 of file ActionWarehouse.C.

Referenced by MooseApp::runInputFile().

{
  if (_show_actions)
  {
    _console << "[DBG][ACT] Action Dependency Sets:\n";
    printActionDependencySets();

    _console << "\n[DBG][ACT] Executing actions:" << std::endl;
  }

  for (const auto & task : _ordered_names)
  {
    executeActionsWithAction(task);
    if (_final_task != "" && task == _final_task)
      break;
  }
}

getAction()

template<class T >

const T& ActionWarehouse::getAction ( const std::string &  name )

inline

Retrieve an action with its name and the desired type.

Parameters

name	The action name.

Definition at line 110 of file ActionWarehouse.h.

  {
    T * p = NULL;
    for (auto i = beginIndex(_all_ptrs); i < _all_ptrs.size(); ++i)
    {
      auto act = _all_ptrs[i].get();
      if (act->name() == name)
      {
        p = dynamic_cast<T *>(act);
        if (p)
          break;
      }
    }
    if (!p)
      mooseError("Action with name being ", name, " does not exist");
    return *p;
  }

getActionByTask()

template<class T >

const T* ActionWarehouse::getActionByTask ( const std::string &  task )

inline

Retrieve the action on a specific task with its type.

Error will be thrown if more than one actions are found.

Parameters

task	The task name.

Returns

The action pointer. Null means that such an action does not exist.

Definition at line 158 of file ActionWarehouse.h.

Referenced by CreateProblemDefaultAction::act().

  {
    const auto it = _action_blocks.find(task);
    if (it == _action_blocks.end())
      return nullptr;

    T * p = nullptr;
    for (const auto & action : it->second)
    {
      T * tp = dynamic_cast<T *>(action);
      if (tp)
      {
        if (p)
          mooseError("More than one actions have been detected in getActionByTask");
        else
          p = tp;
      }
    }
    return p;
  }

getActionListByName()

const std::list< Action * > & ActionWarehouse::getActionListByName

(

const std::string &

task

)

const

Retrieve a constant list of Action pointers associated with the passed in task.

Definition at line 188 of file ActionWarehouse.C.

Referenced by MaterialOutputAction::act(), CheckOutputAction::checkVariableOutput(), Console::Console(), MooseApp::getCheckpointDirectories(), and OutputWarehouse::getOutputNames().

{
  const auto it = _action_blocks.find(task);
  if (it == _action_blocks.end())
    mooseError("The task ", task, " does not exist.");

  return it->second;
}

getActions()

template<class T >

std::vector<const T *> ActionWarehouse::getActions ( )

inline

Retrieve all actions in a specific type ordered by their names.

Definition at line 132 of file ActionWarehouse.h.

  {
    // we need to create the map first to ensure that all actions in the map are unique
    // and the actions are sorted by their names
    std::map<std::string, const T *> actions;
    for (auto i = beginIndex(_all_ptrs); i < _all_ptrs.size(); ++i)
    {
      auto act = _all_ptrs[i].get();
      T * p = dynamic_cast<T *>(act);
      if (p)
        actions.insert(std::pair<std::string, const T *>(act->name(), p));
    }
    // construct the vector from the map entries
    std::vector<const T *> action_vector;
    for (auto & pair : actions)
      action_vector.push_back(pair.second);
    return action_vector;
  }

getCurrentActionName()

std::string ActionWarehouse::getCurrentActionName

(

)

const

Definition at line 416 of file ActionWarehouse.C.

Referenced by DumpObjectsProblem::dumpObjectHelper(), and DumpObjectsProblem::dumpVariableHelper().

{
  return (*_act_iter)->parameters().blockFullpath();
}

getCurrentTaskName()

const std::string& ActionWarehouse::getCurrentTaskName ( ) const

inline

Definition at line 221 of file ActionWarehouse.h.

{ return _current_task; }

hasActions()

bool ActionWarehouse::hasActions

(

const std::string &

task

)

const

Check if Actions associated with passed in task exist.

Definition at line 198 of file ActionWarehouse.C.

Referenced by MaterialOutputAction::act(), CheckOutputAction::checkVariableOutput(), and OutputWarehouse::getOutputNames().

{
  return _action_blocks.find(task) != _action_blocks.end();
}

mesh()

std::shared_ptr<MooseMesh>& ActionWarehouse::mesh ( )

inline

Definition at line 215 of file ActionWarehouse.h.

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), and MooseApp::executeMeshModifiers().

{ return _mesh; }

mooseApp()

MooseApp& ActionWarehouse::mooseApp ( )

inline

Definition at line 220 of file ActionWarehouse.h.

Referenced by ExodusFormatter::printInputFile().

{ return _app; }

printActionDependencySets()

void ActionWarehouse::printActionDependencySets

(

)

const

This method is used only during debugging when show_actions is set to true.

It prints all of the actions sets in the correct dependency resolved order with all of the Action objects inside.

Note: This routine uses the XTerm colors directly which is not advised for general purpose output coloring. Most users should prefer using Problem::colorText() which respects the "color_output" option for terminals that do not support coloring. Since this routine is intended for debugging only and runs before several objects exist in the system, we are just using the constants directly.

Definition at line 254 of file ActionWarehouse.C.

Referenced by executeAllActions().

{
  std::ostringstream oss;

  const auto & ordered_names = _syntax.getSortedTaskSet();
  for (const auto & task_vector : ordered_names)
  {
    oss << "[DBG][ACT] (" << COLOR_YELLOW;
    std::copy(
        task_vector.begin(), task_vector.end(), infix_ostream_iterator<std::string>(oss, ", "));
    oss << COLOR_DEFAULT << ")\n";

    std::set<std::string> task_set(task_vector.begin(), task_vector.end());
    for (const auto & task : task_set)
    {
      if (_action_blocks.find(task) == _action_blocks.end())
        continue;

      for (const auto & act : _action_blocks.at(task))
      {
        // The Syntax of the Action if it exists
        if (act->name() != "")
          oss << "[DBG][ACT]\t" << COLOR_GREEN << act->name() << COLOR_DEFAULT << '\n';

        // The task sets
        oss << "[DBG][ACT]\t" << act->type();
        const std::set<std::string> tasks = act->getAllTasks();
        if (tasks.size() > 1)
        {
          oss << " (";
          // Break the current Action's tasks into 2 sets, those intersecting with current set and
          // then the difference.
          std::set<std::string> intersection, difference;
          std::set_intersection(tasks.begin(),
                                tasks.end(),
                                task_set.begin(),
                                task_set.end(),
                                std::inserter(intersection, intersection.end()));
          std::set_difference(tasks.begin(),
                              tasks.end(),
                              intersection.begin(),
                              intersection.end(),
                              std::inserter(difference, difference.end()));

          oss << COLOR_CYAN;
          std::copy(intersection.begin(),
                    intersection.end(),
                    infix_ostream_iterator<std::string>(oss, ", "));
          oss << COLOR_MAGENTA << (difference.empty() ? "" : ", ");
          std::copy(
              difference.begin(), difference.end(), infix_ostream_iterator<std::string>(oss, ", "));
          oss << COLOR_DEFAULT << ")";
        }
        oss << '\n';
      }
    }
  }

  if (_show_actions)
    _console << oss.str() << std::endl;
}

printInputFile()

void ActionWarehouse::printInputFile

(

std::ostream &

out

)

This method uses the Actions in the warehouse to reproduce the input file.

This method is useful for debugging as it can assist in finding difficult to track parsing or input file problems.

Parameters

out	A writable ostream object where the output will be sent.

Definition at line 366 of file ActionWarehouse.C.

Referenced by Console::outputInput(), and ExodusFormatter::printInputFile().

{
  InputFileFormatter tree(false);

  std::map<std::string, std::vector<Action *>>::iterator iter;

  std::vector<Action *> ordered_actions;
  for (const auto & block : _action_blocks)
    for (const auto & act : block.second)
      ordered_actions.push_back(act);

  for (const auto & act : ordered_actions)
  {
    std::string name;
    if (act->parameters().blockFullpath() != "")
      name = act->parameters().blockFullpath();
    else
      name = act->name();
    const std::set<std::string> & tasks = act->getAllTasks();
    mooseAssert(!tasks.empty(), "Task list is empty");

    bool is_parent;
    if (_syntax.isAssociated(name, &is_parent) != "")
    {
      InputParameters params = act->parameters();

      // TODO: Do we need to insert more nodes for each task?
      tree.insertNode(name, *tasks.begin(), true, &params);

      MooseObjectAction * moose_object_action = dynamic_cast<MooseObjectAction *>(act);
      if (moose_object_action)
      {
        InputParameters obj_params = moose_object_action->getObjectParams();
        tree.insertNode(name, *tasks.begin(), false, &obj_params);
      }
    }
  }

  out << tree.print("");
}

problem()

std::shared_ptr< FEProblem > ActionWarehouse::problem

(

)

Definition at line 408 of file ActionWarehouse.C.

{
  mooseDeprecated(
      "ActionWarehouse::problem() is deprecated, please use ActionWarehouse::problemBase() \n");
  return std::dynamic_pointer_cast<FEProblem>(_problem);
}

problemBase()

std::shared_ptr<FEProblemBase>& ActionWarehouse::problemBase ( )

inline

Definition at line 218 of file ActionWarehouse.h.

Referenced by Factory::create(), and MooseApp::setRestart().

{ return _problem; }

setFinalTask()

void ActionWarehouse::setFinalTask

(

const std::string &

task

)

Definition at line 39 of file ActionWarehouse.C.

Referenced by MooseApp::setupOptions().

{
  if (!_syntax.hasTask(task))
    mooseError("cannot use unregistered task '", task, "' as final task");
  _final_task = task;
}

showActions()

void ActionWarehouse::showActions ( bool  state = true )

inline

This method sets a Boolean which is used to show debugging information during various warehouse operations during the problem setup phase.

Parameters

state

Flag indicating whether to show action information.

Definition at line 203 of file ActionWarehouse.h.

Referenced by SetupDebugAction::SetupDebugAction().

{ _show_actions = state; }

showParser()

void ActionWarehouse::showParser ( bool  state = true )

inline

Definition at line 205 of file ActionWarehouse.h.

Referenced by SetupDebugAction::SetupDebugAction().

{ _show_parser = state; }

syntax()

Syntax& ActionWarehouse::syntax ( )

inline

Definition at line 208 of file ActionWarehouse.h.

Referenced by DynamicObjectRegistrationAction::DynamicObjectRegistrationAction().

{ return _syntax; }

Member Data Documentation

_act_iter

ActionIterator ActionWarehouse::_act_iter

private

Definition at line 284 of file ActionWarehouse.h.

Referenced by executeActionsWithAction().

_action_blocks

std::map<std::string, std::list<Action *> > ActionWarehouse::_action_blocks

protected

Pointers to the actual parsed input file blocks.

Definition at line 244 of file ActionWarehouse.h.

Referenced by actionBlocksWithActionBegin(), actionBlocksWithActionEnd(), addActionBlock(), buildBuildableActions(), checkUnsatisfiedActions(), clear(), empty(), getActionByTask(), getActionListByName(), hasActions(), printActionDependencySets(), and printInputFile().

_action_factory

ActionFactory& ActionWarehouse::_action_factory

protected

The Factory that builds Actions.

Definition at line 242 of file ActionWarehouse.h.

Referenced by addActionBlock(), and buildBuildableActions().

_all_ptrs

std::vector<std::shared_ptr<Action> > ActionWarehouse::_all_ptrs

protected

Definition at line 235 of file ActionWarehouse.h.

Referenced by addActionBlock(), allActionBlocks(), clear(), getAction(), and getActions().

_app

MooseApp& ActionWarehouse::_app

protected

The MooseApp this Warehouse is associated with.

Definition at line 238 of file ActionWarehouse.h.

Referenced by mooseApp().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 32 of file ConsoleStreamInterface.h.

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

_current_task

std::string ActionWarehouse::_current_task

protected

Definition at line 265 of file ActionWarehouse.h.

Referenced by executeActionsWithAction(), and getCurrentTaskName().

_displaced_mesh

std::shared_ptr<MooseMesh> ActionWarehouse::_displaced_mesh

protected

Possible mesh for displaced problem.

Definition at line 275 of file ActionWarehouse.h.

Referenced by clear(), and displacedMesh().

_final_task

std::string ActionWarehouse::_final_task

private

Last task to run before (optional) early termination - blank means no early termination.

Definition at line 282 of file ActionWarehouse.h.

Referenced by executeAllActions(), and setFinalTask().

_generator_valid

bool ActionWarehouse::_generator_valid

protected

Flag to indicate whether or not there is an active iterator on this class.

There can only be a single active iterator because of the potential for meta Actions to add new Actions into the warehouse on the fly

Definition at line 257 of file ActionWarehouse.h.

Referenced by clear().

_mesh

std::shared_ptr<MooseMesh> ActionWarehouse::_mesh

protected

Mesh class.

Definition at line 272 of file ActionWarehouse.h.

Referenced by clear(), and mesh().

_ordered_names

std::vector<std::string> ActionWarehouse::_ordered_names

protected

The container that holds the sorted action names from the DependencyResolver.

Definition at line 248 of file ActionWarehouse.h.

Referenced by build(), and executeAllActions().

_problem

std::shared_ptr<FEProblemBase> ActionWarehouse::_problem

protected

Problem class.

Definition at line 278 of file ActionWarehouse.h.

Referenced by clear(), problem(), and problemBase().

_requested_action_blocks

std::map<std::string, std::vector<Action *> > ActionWarehouse::_requested_action_blocks

protected

Action blocks that have been requested.

Definition at line 246 of file ActionWarehouse.h.

_show_actions

bool ActionWarehouse::_show_actions

protected

Definition at line 260 of file ActionWarehouse.h.

Referenced by executeActionsWithAction(), executeAllActions(), printActionDependencySets(), and showActions().

_show_parser

bool ActionWarehouse::_show_parser

protected

Definition at line 261 of file ActionWarehouse.h.

Referenced by addActionBlock(), and showParser().

_syntax

Syntax& ActionWarehouse::_syntax

protected

Reference to a "syntax" of actions.

Definition at line 240 of file ActionWarehouse.h.

Referenced by addActionBlock(), build(), buildBuildableActions(), printActionDependencySets(), printInputFile(), setFinalTask(), and syntax().

_unsatisfied_dependencies

std::set<std::string> ActionWarehouse::_unsatisfied_dependencies

protected

Use to store the current list of unsatisfied dependencies.

Definition at line 250 of file ActionWarehouse.h.

Referenced by buildBuildableActions(), and checkUnsatisfiedActions().

---

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

• include/actions/ActionWarehouse.h
• src/actions/ActionWarehouse.C