AddVariableAction Class Reference

Adds nonlinear variable. More...

#include <AddVariableAction.h>

Inheritance diagram for AddVariableAction:

Public Member Functions
	AddVariableAction (InputParameters params)
virtual void	act () override
	Method to add objects to the simulation or perform other setup tasks. More...
virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type) override
	Method to add a relationship manager for the objects being added to the system. More...
void	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
	Method to add a relationship manager for the objects being added to the system. More...
virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)
	Method to add a relationship manager for the objects being added to the system. More...
InputParameters &	getObjectParams ()
	Retreive the parameters of the object to be created by this action. More...
const InputParameters &	getObjectParams () const
	Constant version of retreiving the parameters of the object to be created by this action. More...
const std::string &	getMooseObjectType () const
	Return the object type to be created. More...
void	timedAct ()
	The method called externally that causes the action to act() More...
const std::string &	name () const
	The name of the action. More...
const std::string &	type () const
InputParameters &	parameters ()
const InputParameters &	parameters () const
const std::string &	specificTaskName () const
const std::set< std::string > &	getAllTasks () const
template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...
bool	isParamValid (const std::string &name) const
void	appendTask (const std::string &task)
template<typename... Args>
void	paramError (const std::string &param, Args... args)
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	paramWarning (const std::string &param, Args... args)
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	paramInfo (const std::string &param, Args... args)
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
std::string	getBaseName () const
	Deprecated name methods, use name() More...
std::string	getShortName () const
	DEPRECATED METHODS. More...
template<typename T >
const T &	getParamTempl (const std::string &name) const
	Retrieve a parameter for the object. More...

Static Public Member Functions
static InputParameters	validParams ()
	Class constructor. More...
static MooseEnum	getNonlinearVariableFamilies ()
	Get the possible variable families. More...
static MooseEnum	getNonlinearVariableOrders ()
	Get the possible variable orders. More...
static FEType	feType (const InputParameters &params)
	determine the FEType by examining family and order in the provided parameters More...
static std::string	determineType (const FEType &fe_type, unsigned int components)
	determine the variable type given an FEType and number of components More...

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

Static Public Attributes
static constexpr auto	FILE_SUFFIX = "_mesh"
	The suffix appended when writing the restartable data file. More...
static constexpr auto	SYSTEM = "MeshMetaData"
	The system name used when initializing the Restartable interface. More...
static constexpr auto	NAME = "<empty>"
	The data name used when initializing the Restartable interface for non-MeshGenerator objects. More...

Protected Member Functions
virtual void	init ()
	Initialize the action's member variables. More...
void	addVariable (const std::string &var_name)
	Adds a nonlinear variable to the system. More...
void	createInitialConditionAction ()
	Create the action to generate the InitialCondition object. More...
std::set< SubdomainID >	getSubdomainIDs ()
	Get the block ids from the input parameters. More...
void	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
	Method to add a relationship manager for the objects being added to the system. More...
template<typename T >
const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)
	Method for retrieving a property with the given type and name exists in the mesh meta-data store. More...
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level)
	Call to register a named section for timing. More...

Protected Attributes
FEType	_fe_type
	FEType for the variable being created. More...
bool	_scalar_var
	True if the variable being created is a scalar. More...
unsigned int	_components
	Number of components for an array variable. More...
std::function< void(FEProblemBase &, const std::string &, const std::string &, InputParameters &)>	_problem_add_var_method
std::string	_type
	The Object type that is being created. More...
InputParameters	_moose_object_pars
	The parameters for the object to be created. More...
InputParameters	_pars
	Input parameters for the action. More...
std::string	_registered_identifier
std::string	_name
	The name of the action. More...
std::string	_action_type
MooseApp &	_app
	The MOOSE application this is associated with. More...
Factory &	_factory
	The Factory associated with the MooseApp. More...
ActionFactory &	_action_factory
	Builds Actions. More...
std::string	_specific_task_name
	This member will only be populated if this Action instance is only designed to handle one task. More...
std::set< std::string >	_all_tasks
	A list of all the tasks that this Action will satisfy. More...
ActionWarehouse &	_awh
	Reference to ActionWarehouse where we store object build by actions. More...
const std::string &	_current_task
	The current action (even though we have seperate instances for each action) More...
std::shared_ptr< MooseMesh > &	_mesh
std::shared_ptr< MooseMesh > &	_displaced_mesh
std::shared_ptr< FEProblemBase > &	_problem
	Convenience reference to a problem this action works on. More...
PerfID	_act_timer
	Timers. More...
const InputParameters *	_pg_params
	Params. More...
PerfGraph &	_perf_graph
	The performance graph to add to. More...
std::string	_prefix
	A prefix to use for all sections. More...

Private Member Functions
void	addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type)
	Method for adding a single relationship manager. More...
RestartableDataValue &	registerMetaDataOnApp (const std::string &name, std::unique_ptr< RestartableDataValue > data)
	Helper function for actually registering the restartable data. More...

Private Attributes
MooseApp &	_meta_data_app
	Reference to the application. More...

Detailed Description

Adds nonlinear variable.

Definition at line 25 of file AddVariableAction.h.

Constructor & Destructor Documentation

AddVariableAction()

AddVariableAction::AddVariableAction

(

InputParameters

params

)

Definition at line 58 of file AddVariableAction.C.

  : MooseObjectAction(params),
    _fe_type(feType(params)),
    _scalar_var(_fe_type.family == SCALAR),
    _components(1)
{
}

Member Function Documentation

act()

void AddVariableAction::act ( )

overridevirtual

Method to add objects to the simulation or perform other setup tasks.

Implements Action.

Reimplemented in AddElementalFieldAction.

Definition at line 139 of file AddVariableAction.C.

{
  // If we've been called that means that current_task == "add_variable"
  init();
 
  // Get necessary data for creating a variable
  std::string var_name = name();
  addVariable(var_name);
 
  // Set the initial condition
  if (_moose_object_pars.isParamValid("initial_condition"))
    createInitialConditionAction();
}

addRelationshipManager()

void Action::addRelationshipManager ( Moose::RelationshipManagerType  input_rm_type, const InputParameters &  moose_object_pars, std::string  rm_name, Moose::RelationshipManagerType  rm_type, Moose::RelationshipManagerInputParameterCallback  rm_input_parameter_func, Moose::RMSystemType  sys_type  )

privateinherited

Method for adding a single relationship manager.

Parameters

input_rm_type	What relationship manager type we are currently adding
moose_object_pars	The parameters of the MooseObject that requested the RM
rm_name	The class type of the RM, e.g. ElementSideNeighborLayers
rm_type	The RelationshipManagerType, e.g. geometric, algebraic, coupling
rm_input_parameter_func	The RM callback function, typically a lambda defined in the requesting MooseObject's validParams function
sys_type	A RMSystemType that can be used to limit the systems and consequent dof_maps that the RM can be attached to

Definition at line 97 of file Action.C.

{
  // These need unique names
  static unsigned int unique_object_id = 0;
 
  auto new_name = moose_object_pars.get<std::string>("_moose_base") + '_' + name() + '_' + rm_name +
                  "_" + Moose::stringify(rm_type) + " " + std::to_string(unique_object_id);
 
  auto rm_params = _factory.getValidParams(rm_name);
  rm_params.set<Moose::RelationshipManagerType>("rm_type") = rm_type;
  rm_params.set<Moose::RMSystemType>("system_type") = sys_type;
 
  auto for_whom = name();
  if (sys_type == Moose::RMSystemType::NONLINEAR)
    for_whom += "_nl";
  else if (sys_type == Moose::RMSystemType::AUXILIARY)
    for_whom += "_aux";
  rm_params.set<std::string>("for_whom") = for_whom;
 
  // Figure out if we shouldn't be adding this one yet
  if (((rm_type & input_rm_type) != input_rm_type)
 
      || // Or are we adding Geometric but this one needs to be delayed
 
      (((input_rm_type & Moose::RelationshipManagerType::GEOMETRIC) ==
        Moose::RelationshipManagerType::GEOMETRIC) &&
       ((rm_type & Moose::RelationshipManagerType::GEOMETRIC) ==
        Moose::RelationshipManagerType::GEOMETRIC) &&
       !rm_params.template get<bool>("attach_geometric_early"))
 
      || // Or is this an Algebraic/Coupling and Geometric one that we already added earlier?
 
      (((input_rm_type != Moose::RelationshipManagerType::GEOMETRIC) &&
        (rm_type != Moose::RelationshipManagerType::GEOMETRIC) &&
        ((rm_type & Moose::RelationshipManagerType::GEOMETRIC) ==
         Moose::RelationshipManagerType::GEOMETRIC) &&
        rm_params.template get<bool>("attach_geometric_early"))))
    return;
 
  // If there is a callback for setting the RM parameters let's use it
  if (rm_input_parameter_func)
    rm_input_parameter_func(moose_object_pars, rm_params);
 
  // If we're doing geometric but we can't build it early - then let's not build it yet
  // (It will get built when we do algebraic)
  if ((input_rm_type & Moose::RelationshipManagerType::GEOMETRIC) ==
          Moose::RelationshipManagerType::GEOMETRIC &&
      !rm_params.get<bool>("attach_geometric_early"))
  {
    // We also need to tell the mesh not to delete remote elements yet
    // Note this will get reset in AddRelationshipManager::act() when attaching Algebraic
    _mesh->getMesh().allow_remote_element_removal(false);
 
    if (_problem->getDisplacedProblem())
      _problem->getDisplacedProblem()->mesh().getMesh().allow_remote_element_removal(false);
 
    // Keep looking for more RMs
    return;
  }
  // Ok the above block may have told the mesh not to allow remote element removal during the
  // initial MeshBase::prepare_for_use, which is called after attaching geometric ghosting
  // functors. If we did tell the mesh not to allow remote element removal **and** we're using a
  // DistributedMesh, then we need to tell the mesh to allow remote element removal and ensure
  // that the mesh will delete its remote elements after the EquationSystems init
  else if (input_rm_type != Moose::RelationshipManagerType::GEOMETRIC &&
           (rm_type & Moose::RelationshipManagerType::GEOMETRIC) ==
               Moose::RelationshipManagerType::GEOMETRIC &&
           !rm_params.get<bool>("attach_geometric_early") && _mesh->isDistributedMesh())
  {
    _mesh->needsRemoteElemDeletion(true);
    if (_displaced_mesh)
      _displaced_mesh->needsRemoteElemDeletion(true);
  }
 
  rm_params.set<MooseMesh *>("mesh") = _mesh.get();
 
  if (rm_params.areAllRequiredParamsValid())
  {
    auto rm_obj = _factory.create<RelationshipManager>(rm_name, new_name, rm_params);
 
    // Delete the resources created on behalf of the RM if it ends up not being added to the App.
    if (!_app.addRelationshipManager(rm_obj))
      _factory.releaseSharedObjects(*rm_obj);
    else // we added it
      unique_object_id++;
  }
  else
    mooseError("Missing required parameters for RelationshipManager " + rm_name + " for object " +
               name());
}

Referenced by Action::addRelationshipManagers().

addRelationshipManagers() [1/4]

void Action::addRelationshipManagers

inherited

Method to add a relationship manager for the objects being added to the system.

Relationship managers have to be added relatively early. In many cases before the Action::act() method is called.

Parameters

when_type

The parameter indicating the normal time for adding either Geometric or Algebraic RelationshipManagers. It may not always be possible to add your RelationshipManager as early as you'd like. In these cases, your DistributedMesh may consume more memory during the problem setup.

Definition at line 194 of file Action.C.

{}

addRelationshipManagers() [2/4]

void MooseObjectAction::addRelationshipManagers ( Moose::RelationshipManagerType  when_type )

overridevirtualinherited

Method to add a relationship manager for the objects being added to the system.

Relationship managers have to be added relatively early. In many cases before the Action::act() method is called.

Parameters

when_type

The parameter indicating the normal time for adding either Geometric or Algebraic RelationshipManagers. It may not always be possible to add your RelationshipManager as early as you'd like. In these cases, your DistributedMesh may consume more memory during the problem setup.

Reimplemented from Action.

Definition at line 46 of file MooseObjectAction.C.

{
  addRelationshipManagers(input_rm_type, _moose_object_pars);
}

addRelationshipManagers() [3/4]

void Action::addRelationshipManagers

inherited

Method to add a relationship manager for the objects being added to the system.

Relationship managers have to be added relatively early. In many cases before the Action::act() method is called.

Parameters

when_type	The parameter indicating the normal time for adding either Geometric or Algebraic RelationshipManagers. It may not always be possible to add your RelationshipManager as early as you'd like. In these cases, your DistributedMesh may consume more memory during the problem setup.
moose_object_pars	The MooseObject to inspect for RelationshipManagers to add

Definition at line 197 of file Action.C.

{
  typedef RelationshipManager RM;
 
  const auto & buildable_types = moose_object_pars.getBuildableRelationshipManagerTypes();
 
  for (const auto & buildable_type : buildable_types)
  {
    auto & rm_name = std::get<0>(buildable_type);
    auto & rm_type = std::get<1>(buildable_type);
    auto rm_input_parameter_func = std::get<2>(buildable_type);
 
    // If we have an algebraic ghosting functor, then we are going to duplicate the
    // RelationshipManager object. This makes bookkeeping for relationship manager coverage more
    // straightforward, i.e. when we are deciding whether to add an algebraic relationship manager,
    // we can easily check whether a given System/DofMap is already covered or not. If we have an
    // object that is strictly a coupling functor, we will not duplicate it and we will apply it
    // just to the NonlinearSystem(Base). Duplicating RMs for the DofMaps is also very important for
    // ensuring that a non-null CouplingMatrix (reflecting coupling in the nonlinear system) doesn't
    // get applied to the auxiliary system
 
    bool is_algebraic = RM::isAlgebraic(rm_type);
    bool is_coupleable = RM::isCoupling(rm_type);
 
    auto sys_type = (is_algebraic || is_coupleable) ? Moose::RMSystemType::NONLINEAR
                                                    : Moose::RMSystemType::NONE;
 
    addRelationshipManager(
        input_rm_type, moose_object_pars, rm_name, rm_type, rm_input_parameter_func, sys_type);
 
    if (is_algebraic)
    {
      auto duplicate_rm_type = Moose::RelationshipManagerType::ALGEBRAIC;
      sys_type = Moose::RMSystemType::AUXILIARY;
      addRelationshipManager(input_rm_type,
                             moose_object_pars,
                             rm_name,
                             duplicate_rm_type,
                             rm_input_parameter_func,
                             sys_type);
    }
  }
}

addRelationshipManagers() [4/4]

void Action::addRelationshipManagers ( Moose::RelationshipManagerType  when_type, const InputParameters &  moose_object_pars  )

protectedinherited

Method to add a relationship manager for the objects being added to the system.

Relationship managers have to be added relatively early. In many cases before the Action::act() method is called.

Parameters

when_type	The parameter indicating the normal time for adding either Geometric or Algebraic RelationshipManagers. It may not always be possible to add your RelationshipManager as early as you'd like. In these cases, your DistributedMesh may consume more memory during the problem setup.
moose_object_pars	The MooseObject to inspect for RelationshipManagers to add

Definition at line 197 of file Action.C.

{
  typedef RelationshipManager RM;
 
  const auto & buildable_types = moose_object_pars.getBuildableRelationshipManagerTypes();
 
  for (const auto & buildable_type : buildable_types)
  {
    auto & rm_name = std::get<0>(buildable_type);
    auto & rm_type = std::get<1>(buildable_type);
    auto rm_input_parameter_func = std::get<2>(buildable_type);
 
    // If we have an algebraic ghosting functor, then we are going to duplicate the
    // RelationshipManager object. This makes bookkeeping for relationship manager coverage more
    // straightforward, i.e. when we are deciding whether to add an algebraic relationship manager,
    // we can easily check whether a given System/DofMap is already covered or not. If we have an
    // object that is strictly a coupling functor, we will not duplicate it and we will apply it
    // just to the NonlinearSystem(Base). Duplicating RMs for the DofMaps is also very important for
    // ensuring that a non-null CouplingMatrix (reflecting coupling in the nonlinear system) doesn't
    // get applied to the auxiliary system
 
    bool is_algebraic = RM::isAlgebraic(rm_type);
    bool is_coupleable = RM::isCoupling(rm_type);
 
    auto sys_type = (is_algebraic || is_coupleable) ? Moose::RMSystemType::NONLINEAR
                                                    : Moose::RMSystemType::NONE;
 
    addRelationshipManager(
        input_rm_type, moose_object_pars, rm_name, rm_type, rm_input_parameter_func, sys_type);
 
    if (is_algebraic)
    {
      auto duplicate_rm_type = Moose::RelationshipManagerType::ALGEBRAIC;
      sys_type = Moose::RMSystemType::AUXILIARY;
      addRelationshipManager(input_rm_type,
                             moose_object_pars,
                             rm_name,
                             duplicate_rm_type,
                             rm_input_parameter_func,
                             sys_type);
    }
  }
}

Referenced by CouplingFunctorCheckAction::act().

addVariable()

void AddVariableAction::addVariable ( const std::string &  var_name )

protected

Adds a nonlinear variable to the system.

Parameters

var_name

The name of the variable.

Definition at line 221 of file AddVariableAction.C.

{
  // Compare sizes of scaling_factor and components for Array Variables
  const auto & scale_factor = _moose_object_pars.isParamValid("scaling")
                                  ? _moose_object_pars.get<std::vector<Real>>("scaling")
                                  : std::vector<Real>(_components, 1);
  if (scale_factor.size() != _components)
    mooseError("Size of 'scaling' is not consistent");
 
  _problem_add_var_method(*_problem, _type, _name, _moose_object_pars);
 
  if (_moose_object_pars.get<bool>("eigen"))
  {
    MooseEigenSystem & esys(static_cast<MooseEigenSystem &>(_problem->getNonlinearSystemBase()));
    esys.markEigenVariable(var_name);
  }
}

Referenced by AddElementalFieldAction::act(), and act().

appendTask()

void Action::appendTask ( const std::string &  task )

inlineinherited

Definition at line 146 of file Action.h.

{ _all_tasks.insert(task); }

createInitialConditionAction()

void AddVariableAction::createInitialConditionAction ( )

protected

Create the action to generate the InitialCondition object.

If the user supplies a value for 'initial_condition' in the input file this method will create the proper InitialCondition object.

Definition at line 154 of file AddVariableAction.C.

{
  // Variable name
  std::string var_name = name();
 
  // Create the object name
  std::string long_name("");
  long_name += var_name;
  long_name += "_moose";
 
  // Set the parameters for the action
  InputParameters action_params = _action_factory.getValidParams("AddOutputAction");
  action_params.set<ActionWarehouse *>("awh") = &_awh;
 
  if (_scalar_var)
    action_params.set<std::string>("type") = "ScalarConstantIC";
  else if (_components == 1)
    action_params.set<std::string>("type") = "ConstantIC";
  else
    action_params.set<std::string>("type") = "ArrayConstantIC";
 
  // Create the action
  std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
      _action_factory.create("AddInitialConditionAction", long_name, action_params));
 
  // Set the required parameters for the object to be created
  action->getObjectParams().set<VariableName>("variable") = var_name;
  auto value = _moose_object_pars.get<std::vector<Real>>("initial_condition");
  if (value.size() != _components)
    mooseError("Size of 'initial_condition' is not consistent");
  if (_components > 1)
  {
    RealEigenVector v(_components);
    for (unsigned int i = 0; i < _components; ++i)
      v(i) = value[i];
    action->getObjectParams().set<RealEigenVector>("value") = v;
  }
  else
    action->getObjectParams().set<Real>("value") = value[0];
 
  // Store the action in the ActionWarehouse
  _awh.addActionBlock(action);
}

Referenced by act().

determineType()

std::string AddVariableAction::determineType ( const FEType &  fe_type, unsigned int  components  )

static

determine the variable type given an FEType and number of components

Definition at line 199 of file AddVariableAction.C.

{
  if (components > 1)
  {
    if (fe_type.family == LAGRANGE_VEC || fe_type.family == NEDELEC_ONE ||
        fe_type.family == MONOMIAL_VEC)
      mooseError("Vector finite element families do not currently have ArrayVariable support");
    else
      return "ArrayMooseVariable";
  }
  else if (fe_type == FEType(0, MONOMIAL))
    return "MooseVariableConstMonomial";
  else if (fe_type.family == SCALAR)
    return "MooseVariableScalar";
  else if (fe_type.family == LAGRANGE_VEC || fe_type.family == NEDELEC_ONE ||
           fe_type.family == MONOMIAL_VEC)
    return "VectorMooseVariable";
  else
    return "MooseVariable";
}

Referenced by init().

feType()

FEType AddVariableAction::feType ( const InputParameters &  params )

static

determine the FEType by examining family and order in the provided parameters

Definition at line 81 of file AddVariableAction.C.

{
  return {Utility::string_to_enum<Order>(params.get<MooseEnum>("order")),
          Utility::string_to_enum<FEFamily>(params.get<MooseEnum>("family"))};
}

getAllTasks()

const std::set<std::string>& Action::getAllTasks ( ) const

inlineinherited

Definition at line 122 of file Action.h.

{ return _all_tasks; }

Referenced by AddKernelAction::act().

getBaseName()

std::string Action::getBaseName ( ) const

inherited

Deprecated name methods, use name()

Definition at line 251 of file Action.C.

{
  mooseDeprecated("getBaseName() is deprecated.");
  return MooseUtils::baseName(_name);
}

getCheckedPointerParam()

template<typename T >

T Action::getCheckedPointerParam ( const std::string &  name, const std::string &  error_string = ""  ) const

inlineinherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 139 of file Action.h.

  {
    return parameters().getCheckedPointerParam<T>(name, error_string);
  }

getMeshProperty()

template<typename T >

const T & MeshMetaDataInterface::getMeshProperty ( const std::string &  data_name, const std::string &  prefix  )

protectedinherited

Method for retrieving a property with the given type and name exists in the mesh meta-data store.

This method will throw an error if the property does not exist.

Definition at line 72 of file MeshMetaDataInterface.h.

{
  std::string full_name = std::string(SYSTEM) + "/" + prefix + "/" + data_name;
  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, nullptr);
 
  // Here we will create the RestartableData even though we may not use this instance.
  // If it's already in use, the App will return a reference to the existing instance and we'll
  // return that one instead. We might refactor this to have the app create the RestartableData
  // at a later date.
  auto & restartable_data_ref =
      static_cast<RestartableData<T> &>(registerMetaDataOnApp(full_name, std::move(data_ptr)));
 
  return restartable_data_ref.get();
}

getMooseObjectType()

const std::string& MooseObjectAction::getMooseObjectType ( ) const

inlineinherited

Return the object type to be created.

Definition at line 44 of file MooseObjectAction.h.

{ return _type; }

Referenced by CommonOutputAction::hasConsole().

getNonlinearVariableFamilies()

MooseEnum AddVariableAction::getNonlinearVariableFamilies ( )

static

Get the possible variable families.

Returns

MooseEnum with the possible variable families (e.g., LAGRANGE)

Definition at line 67 of file AddVariableAction.C.

{
  return MooseEnum("LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN "
                   "L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC",
                   "LAGRANGE");
}

Referenced by validParams().

getNonlinearVariableOrders()

MooseEnum AddVariableAction::getNonlinearVariableOrders ( )

static

Get the possible variable orders.

Returns

MooseEnum with the possible variable orders (e.g., SECOND)

Definition at line 75 of file AddVariableAction.C.

{
  return MooseEnum("CONSTANT FIRST SECOND THIRD FOURTH", "FIRST", true);
}

Referenced by EqualValueEmbeddedConstraint::validParams(), and validParams().

getObjectParams() [1/2]

InputParameters& MooseObjectAction::getObjectParams ( )

inlineinherited

Retreive the parameters of the object to be created by this action.

Definition at line 34 of file MooseObjectAction.h.

{ return _moose_object_pars; }

Referenced by CreateProblemDefaultAction::act(), MaterialOutputAction::act(), MooseApp::getCheckpointDirectories(), CommonOutputAction::hasConsole(), and ActionWarehouse::printInputFile().

getObjectParams() [2/2]

const InputParameters& MooseObjectAction::getObjectParams ( ) const

inlineinherited

Constant version of retreiving the parameters of the object to be created by this action.

Definition at line 39 of file MooseObjectAction.h.

{ return _moose_object_pars; }

getParamTempl()

template<typename T >

const T & Action::getParamTempl ( const std::string &  name ) const

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns

The value of the parameter

Definition at line 254 of file Action.h.

{
  return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0));
}

Referenced by MooseApp::getCheckpointDirectories().

getShortName()

std::string Action::getShortName ( ) const

inherited

DEPRECATED METHODS.

Definition at line 244 of file Action.C.

{
  mooseDeprecated("getShortName() is deprecated.");
  return MooseUtils::shortName(_name);
}

getSubdomainIDs()

std::set< SubdomainID > AddVariableAction::getSubdomainIDs ( )

protected

Get the block ids from the input parameters.

Returns

A set of block ids defined in the input

Definition at line 240 of file AddVariableAction.C.

{
  // Extract and return the block ids supplied in the input
  std::set<SubdomainID> blocks;
  std::vector<SubdomainName> block_param =
      _moose_object_pars.get<std::vector<SubdomainName>>("block");
  for (const auto & subdomain_name : block_param)
  {
    SubdomainID blk_id = _problem->mesh().getSubdomainID(subdomain_name);
    blocks.insert(blk_id);
  }
  return blocks;
}

init()

void AddVariableAction::init ( )

protectedvirtual

Initialize the action's member variables.

Reimplemented in AddAuxVariableAction, and AddElementalFieldAction.

Definition at line 88 of file AddVariableAction.C.

{
  _components = _moose_object_pars.get<unsigned int>("components");
  if (_components == 0)
    mooseError("There must be at least one variable component, but somehow 0 has been specified");
 
  // We have to do some sanity checks because of our work to maintain backwards compatibility.
  // `family`, `order`, and `scaling` are all parameters duplicated between this action and the
  // `MooseVariable*` object itself. Consequently during input file parsing, the params objects for
  // both the action and MooseVariable object can be populated with the exact same parameters.
  // However, some applications actually create their variables solely through creation and setting
  // of `AddVariableAction` parameters which means that the `MooseVariableBase*` params will never
  // be populated. So we should apply the parameters directly from the action. There should be no
  // case in which both params objects get set by the user and they have different values
 
  if (_pars.isParamSetByUser("family") && _moose_object_pars.isParamSetByUser("family") &&
      !_pars.get<MooseEnum>("family").compareCurrent(_moose_object_pars.get<MooseEnum>("family")))
    mooseError("Both the MooseVariable* and Add*VariableAction parameters objects have had the "
               "`family` parameter set, and they are different values: ",
               _moose_object_pars.get<MooseEnum>("family"),
               " and ",
               _pars.get<MooseEnum>("family"),
               " respectively. I don't know how you achieved this, but you need to rectify it.");
 
  if (_pars.isParamSetByUser("order") && _moose_object_pars.isParamSetByUser("order") &&
      !_pars.get<MooseEnum>("order").compareCurrent(_moose_object_pars.get<MooseEnum>("order")))
    mooseError("Both the MooseVariable* and Add*VariableAction parameters objects have had the "
               "`order` parameter set, and they are different values: ",
               _moose_object_pars.get<MooseEnum>("order"),
               " and ",
               _pars.get<MooseEnum>("order"),
               " respectively. I don't know how you achieved this, but you need to rectify it.");
 
  if (_pars.isParamSetByUser("scaling") && _moose_object_pars.isParamSetByUser("scaling") &&
      _pars.get<std::vector<Real>>("scaling") !=
          _moose_object_pars.get<std::vector<Real>>("scaling"))
    mooseError("Both the MooseVariable* and Add*VariableAction parameters objects have had the "
               "`scaling` parameter set, and they are different values. I don't know how you "
               "achieved this, but you need to rectify it.");
 
  _moose_object_pars.applySpecificParameters(_pars, {"order", "family", "scaling"});
 
  // Determine the MooseVariable type
  _type = determineType(_fe_type, _components);
 
  // Need static_cast to resolve overloads
  _problem_add_var_method = static_cast<void (FEProblemBase::*)(
      const std::string &, const std::string &, InputParameters &)>(&FEProblemBase::addVariable);
}

Referenced by act(), and AddAuxVariableAction::init().

isParamValid()

bool Action::isParamValid ( const std::string &  name ) const

inlineinherited

Definition at line 144 of file Action.h.

{ return _pars.isParamValid(name); }

Referenced by CopyNodalVarsAction::act(), SetAdaptivityOptionsAction::act(), SetupMeshAction::act(), CreateDisplacedProblemAction::act(), AddPeriodicBCAction::autoTranslationBoundaries(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), and SetupMeshAction::setupMesh().

name()

const std::string& Action::name ( ) const

inlineinherited

The name of the action.

Definition at line 105 of file Action.h.

{ return _name; }

Referenced by AddElementalFieldAction::act(), CopyNodalVarsAction::act(), AdaptivityAction::act(), DeprecatedBlockAction::act(), DisplayGhostingAction::act(), act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), Action::addRelationshipManager(), createInitialConditionAction(), Action::getCheckedPointerParam(), Action::getParamTempl(), Action::isParamValid(), GlobalParamsAction::remove(), GlobalParamsAction::setDoubleIndexParam(), GlobalParamsAction::setScalarParam(), and GlobalParamsAction::setVectorParam().

paramError()

template<typename... Args>

void Action::paramError ( const std::string &  param, Args...  args  )

inlineinherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 155 of file Action.h.

  {
    auto prefix = param + ": ";
    if (!_pars.inputLocation(param).empty())
      prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
    mooseError(prefix, args...);
  }

parameters() [1/2]

InputParameters& Action::parameters ( )

inlineinherited

Definition at line 117 of file Action.h.

{ return _pars; }

Referenced by Action::getCheckedPointerParam(), GlobalParamsAction::remove(), GlobalParamsAction::setDoubleIndexParam(), GlobalParamsAction::setScalarParam(), and GlobalParamsAction::setVectorParam().

parameters() [2/2]

const InputParameters& Action::parameters ( ) const

inlineinherited

Definition at line 118 of file Action.h.

{ return _pars; }

paramInfo()

template<typename... Args>

void Action::paramInfo ( const std::string &  param, Args...  args  )

inlineinherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 186 of file Action.h.

  {
    auto prefix = param + ": ";
    if (!_pars.inputLocation(param).empty())
      prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
    mooseInfo(prefix, args...);
  }

paramWarning()

template<typename... Args>

void Action::paramWarning ( const std::string &  param, Args...  args  )

inlineinherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 170 of file Action.h.

  {
    auto prefix = param + ": ";
    if (!_pars.inputLocation(param).empty())
      prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
    mooseWarning(prefix, args...);
  }

registerMetaDataOnApp()

RestartableDataValue & MeshMetaDataInterface::registerMetaDataOnApp ( const std::string &  name, std::unique_ptr< RestartableDataValue >  data  )

privateinherited

Helper function for actually registering the restartable data.

Definition at line 23 of file MeshMetaDataInterface.C.

{
  return _meta_data_app.registerRestartableData(name, std::move(data), 0, true, true);
}

Referenced by MeshMetaDataInterface::getMeshProperty().

registerTimedSection()

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level  )

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns

The ID of the section - use when starting timing

Definition at line 51 of file PerfGraphInterface.C.

{
  if (_prefix != "")
    return _perf_graph.registerSection(_prefix + "::" + section_name, level);
  else
    return _perf_graph.registerSection(section_name, level);
}

specificTaskName()

const std::string& Action::specificTaskName ( ) const

inlineinherited

Definition at line 120 of file Action.h.

{ return _specific_task_name; }

timedAct()

void Action::timedAct ( )

inherited

The method called externally that causes the action to act()

Definition at line 90 of file Action.C.

{
  TIME_SECTION(_act_timer);
  act();
}

type()

const std::string& Action::type ( ) const

inlineinherited

Definition at line 115 of file Action.h.

{ return _action_type; }

Referenced by CreateProblemDefaultAction::act(), SetupDebugAction::act(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MaterialOutputAction::getParams(), and CommonOutputAction::hasConsole().

validParams()

InputParameters AddVariableAction::validParams ( )

static

Class constructor.

Definition at line 35 of file AddVariableAction.C.

{
  auto params = MooseObjectAction::validParams();
 
  // The user may specify a type in the Variables block, but if they don't we'll just use all the
  // parameters available from MooseVariableBase
  params.set<std::string>("type") = "MooseVariableBase";
 
  // The below is for backwards compatibility
  MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
  MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
  params.addParam<MooseEnum>(
      "family", families, "Specifies the family of FE shape functions to use for this variable");
  params.addParam<MooseEnum>("order",
                             orders,
                             "Specifies the order of the FE shape function to use "
                             "for this variable (additional orders not listed are "
                             "allowed)");
  params.addParam<std::vector<Real>>("scaling",
                                     "Specifies a scaling factor to apply to this variable");
  return params;
}

Referenced by AddElementalFieldAction::validParams(), and AddAuxVariableAction::validParams().

Member Data Documentation

_act_timer

PerfID Action::_act_timer

protectedinherited

Timers.

Definition at line 249 of file Action.h.

Referenced by Action::timedAct().

_action_factory

ActionFactory& Action::_action_factory

protectedinherited

Builds Actions.

Definition at line 219 of file Action.h.

Referenced by CommonOutputAction::create(), createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), and CreateExecutionerAction::setupAutoPreconditioning().

_action_type

std::string Action::_action_type

protectedinherited

Definition at line 210 of file Action.h.

Referenced by Action::type().

_all_tasks

std::set<std::string> Action::_all_tasks

protectedinherited

A list of all the tasks that this Action will satisfy.

Note: That this is not populated at construction time. However, all tasks will be added prior to act().

Definition at line 234 of file Action.h.

Referenced by Action::appendTask(), and Action::getAllTasks().

_app

MooseApp& Action::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 213 of file Action.h.

Referenced by CheckIntegrityAction::act(), CreateExecutionerAction::act(), SetAdaptivityOptionsAction::act(), ExecuteMeshGenerators::act(), CopyNodalVarsAction::act(), CreateProblemDefaultAction::act(), AddMeshGeneratorAction::act(), AddMeshModifierAction::act(), CreateProblemAction::act(), SplitMeshAction::act(), MeshOnlyAction::act(), SetupMeshAction::act(), AdaptivityAction::act(), SetupMeshCompleteAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), CouplingFunctorCheckAction::act(), AddRelationshipManager::act(), DisplayGhostingAction::act(), SetupRecoverFileBaseAction::act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), CheckOutputAction::checkConsoleOutput(), CheckOutputAction::checkMaterialOutput(), CheckOutputAction::checkPerfLogOutput(), CheckOutputAction::checkVariableOutput(), SetupMeshCompleteAction::completeSetup(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), SetupMeshAction::modifyParamsForUseSplit(), and SetupMeshAction::setupMesh().

_awh

ActionWarehouse& Action::_awh

protectedinherited

Reference to ActionWarehouse where we store object build by actions.

Definition at line 237 of file Action.h.

Referenced by CheckIntegrityAction::act(), SetupDampersAction::act(), CreateExecutionerAction::act(), CreateProblemDefaultAction::act(), SetupMeshAction::act(), AddRelationshipManager::act(), CommonOutputAction::create(), createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CommonOutputAction::hasConsole(), CreateExecutionerAction::setupAutoPreconditioning(), and SetupDebugAction::SetupDebugAction().

_components

unsigned int AddVariableAction::_components

protected

Number of components for an array variable.

Definition at line 93 of file AddVariableAction.h.

Referenced by addVariable(), createInitialConditionAction(), and init().

_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(), Adaptivity::adaptMesh(), FEProblemBase::adaptMesh(), SimplePredictor::apply(), MultiApp::backup(), FEProblemBase::backupMultiApps(), ReferenceResidualProblem::checkNonlinearConvergence(), FEProblemBase::checkProblemIntegrity(), CoarsenedPiecewiseLinear::CoarsenedPiecewiseLinear(), IterationAdaptiveDT::computeAdaptiveDT(), Transient::computeConstrainedDT(), NonlinearSystemBase::computeDamping(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeResidualTags(), NonlinearSystem::computeScaling(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), Steady::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), 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(), MultiAppConservativeTransfer::postExecute(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), EigenExecutionerBase::printEigenvalue(), MaterialPropertyDebugOutput::printMaterialMap(), AutomaticMortarGeneration::projectMasterNodesSinglePair(), AutomaticMortarGeneration::projectSlaveNodesSinglePair(), SolutionTimeAdaptiveDT::rejectStep(), DT2::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), SimplePredictor::shouldApply(), PicardSolve::solve(), NonlinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), PicardSolve::solveStep(), DT2::step(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), Transient::takeStep(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_current_task

const std::string& Action::_current_task

protectedinherited

The current action (even though we have seperate instances for each action)

Definition at line 240 of file Action.h.

Referenced by AddDGKernelAction::act(), AddKernelAction::act(), CheckIntegrityAction::act(), AddScalarKernelAction::act(), SetAdaptivityOptionsAction::act(), CopyNodalVarsAction::act(), AddInterfaceKernelAction::act(), CreateProblemDefaultAction::act(), SetupMeshCompleteAction::act(), AdaptivityAction::act(), SetupMeshAction::act(), CreateDisplacedProblemAction::act(), AddRelationshipManager::act(), MaterialDerivativeTestAction::act(), DisplayGhostingAction::act(), AddOutputAction::act(), SetupRecoverFileBaseAction::act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), and AddNodalNormalsAction::act().

_displaced_mesh

std::shared_ptr<MooseMesh>& Action::_displaced_mesh

protectedinherited

Definition at line 243 of file Action.h.

Referenced by SetupMeshAction::act(), SetupMeshCompleteAction::act(), CreateDisplacedProblemAction::act(), and Action::addRelationshipManager().

_factory

Factory& Action::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 216 of file Action.h.

Referenced by CreateExecutionerAction::act(), PartitionerAction::act(), SetAdaptivityOptionsAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AdaptivityAction::act(), SetupPredictorAction::act(), SetupPreconditionerAction::act(), SetupTimeStepperAction::act(), SetupResidualDebugAction::act(), CreateDisplacedProblemAction::act(), MaterialDerivativeTestAction::act(), DisplayGhostingAction::act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), AddControlAction::act(), AddNodalNormalsAction::act(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), and MaterialOutputAction::getParams().

_fe_type

FEType AddVariableAction::_fe_type

protected

FEType for the variable being created.

Definition at line 87 of file AddVariableAction.h.

Referenced by AddElementalFieldAction::init(), AddAuxVariableAction::init(), and init().

_mesh

std::shared_ptr<MooseMesh>& Action::_mesh

protectedinherited

Definition at line 242 of file Action.h.

Referenced by PartitionerAction::act(), SetAdaptivityOptionsAction::act(), CreateProblemDefaultAction::act(), AddMeshGeneratorAction::act(), AddMeshModifierAction::act(), CreateProblemAction::act(), SetupMeshAction::act(), SetupMeshCompleteAction::act(), AdaptivityAction::act(), CreateDisplacedProblemAction::act(), AddPeriodicBCAction::act(), and Action::addRelationshipManager().

_meta_data_app

MooseApp& MeshMetaDataInterface::_meta_data_app

privateinherited

Reference to the application.

Definition at line 67 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::registerMetaDataOnApp().

_moose_object_pars

InputParameters MooseObjectAction::_moose_object_pars

protectedinherited

The parameters for the object to be created.

Definition at line 51 of file MooseObjectAction.h.

Referenced by AddBCAction::act(), AddDamperAction::act(), AddKernelAction::act(), AddMarkerAction::act(), AddScalarKernelAction::act(), AddTransferAction::act(), PartitionerAction::act(), AddMultiAppAction::act(), AddInitialConditionAction::act(), AddVectorPostprocessorAction::act(), AddNodalKernelAction::act(), AddUserObjectAction::act(), AddICAction::act(), AddConstraintAction::act(), AddIndicatorAction::act(), CreateExecutionerAction::act(), AddDGKernelAction::act(), AddDiracKernelAction::act(), AddMaterialAction::act(), AddPostprocessorAction::act(), AddInterfaceKernelAction::act(), CreateProblemAction::act(), AddMeshGeneratorAction::act(), AddFieldSplitAction::act(), AddMeshModifierAction::act(), SetupMeshAction::act(), AddDistributionAction::act(), SetupTimeStepperAction::act(), SetupTimeIntegratorAction::act(), SetupPredictorAction::act(), SetupPreconditionerAction::act(), AddFunctionAction::act(), AddSamplerAction::act(), AddOutputAction::act(), act(), AddControlAction::act(), MooseObjectAction::addRelationshipManagers(), addVariable(), createInitialConditionAction(), MooseObjectAction::getObjectParams(), getSubdomainIDs(), AddElementalFieldAction::init(), init(), SetupMeshAction::modifyParamsForUseSplit(), MooseObjectAction::MooseObjectAction(), and CreateExecutionerAction::setupAutoPreconditioning().

_name

std::string Action::_name

protectedinherited

The name of the action.

Definition at line 207 of file Action.h.

Referenced by AddBCAction::act(), AddConstraintAction::act(), AddKernelAction::act(), AddDiracKernelAction::act(), AddScalarKernelAction::act(), AddInitialConditionAction::act(), AddUserObjectAction::act(), AddTransferAction::act(), AddInterfaceKernelAction::act(), PartitionerAction::act(), AddMaterialAction::act(), AddMultiAppAction::act(), AddDGKernelAction::act(), AddMarkerAction::act(), AddNodalKernelAction::act(), AddDamperAction::act(), AddVectorPostprocessorAction::act(), AddIndicatorAction::act(), AddPostprocessorAction::act(), AddMeshGeneratorAction::act(), AddFieldSplitAction::act(), AddMeshModifierAction::act(), SetupPreconditionerAction::act(), AddFunctionAction::act(), AddDistributionAction::act(), SetupTimeIntegratorAction::act(), AddSamplerAction::act(), AddOutputAction::act(), AddPeriodicBCAction::act(), AddControlAction::act(), SetupPostprocessorDataAction::act(), addVariable(), CouplingFunctorCheckAction::CouplingFunctorCheckAction(), Action::getBaseName(), Action::getShortName(), and Action::name().

_pars

InputParameters Action::_pars

protectedinherited

Input parameters for the action.

Definition at line 201 of file Action.h.

Referenced by AddICAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), Action::getParamTempl(), init(), Action::isParamValid(), Action::paramError(), Action::parameters(), Action::paramInfo(), Action::paramWarning(), and SetupMeshAction::setupMesh().

_perf_graph

PerfGraph& PerfGraphInterface::_perf_graph

protectedinherited

The performance graph to add to.

Definition at line 67 of file PerfGraphInterface.h.

Referenced by PerfGraphData::getValue(), and PerfGraphInterface::registerTimedSection().

_pg_params

const InputParameters* PerfGraphInterface::_pg_params

protectedinherited

Params.

Definition at line 64 of file PerfGraphInterface.h.

_prefix

std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 70 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::registerTimedSection().

_problem

std::shared_ptr<FEProblemBase>& Action::_problem

protectedinherited

Convenience reference to a problem this action works on.

Definition at line 246 of file Action.h.

Referenced by AddBCAction::act(), AddBoundsVectorsAction::act(), AddNodalKernelAction::act(), AddDGKernelAction::act(), CheckIntegrityAction::act(), InitProblemAction::act(), AddIndicatorAction::act(), AddInitialConditionAction::act(), AddVectorPostprocessorAction::act(), AddMarkerAction::act(), AddMaterialAction::act(), AddDamperAction::act(), AddICAction::act(), AddScalarKernelAction::act(), AddTransferAction::act(), AddUserObjectAction::act(), AddInterfaceKernelAction::act(), AddDiracKernelAction::act(), AddKernelAction::act(), CopyNodalVarsAction::act(), AddConstraintAction::act(), AddMultiAppAction::act(), CreateExecutionerAction::act(), SetAdaptivityOptionsAction::act(), SetupDampersAction::act(), AddPostprocessorAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), AddFieldSplitAction::act(), SetupDebugAction::act(), AdaptivityAction::act(), SetupTimeStepperAction::act(), SetupPredictorAction::act(), AddDistributionAction::act(), AddFunctionAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), SetupResidualDebugAction::act(), CreateDisplacedProblemAction::act(), MaterialDerivativeTestAction::act(), CouplingFunctorCheckAction::act(), SetupQuadratureAction::act(), DisplayGhostingAction::act(), AddSamplerAction::act(), AddExternalAuxVariableAction::act(), AddOutputAction::act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), AddControlAction::act(), AddNodalNormalsAction::act(), SetupPostprocessorDataAction::act(), Action::addRelationshipManager(), addVariable(), AddPeriodicBCAction::autoTranslationBoundaries(), CheckOutputAction::checkMaterialOutput(), CheckOutputAction::checkVariableOutput(), getSubdomainIDs(), MaterialOutputAction::materialOutputHelper(), and AddPeriodicBCAction::setPeriodicVars().

_problem_add_var_method

std::function<void(FEProblemBase &, const std::string &, const std::string &, InputParameters &)> AddVariableAction::_problem_add_var_method

protected

Definition at line 96 of file AddVariableAction.h.

Referenced by addVariable(), AddElementalFieldAction::init(), AddAuxVariableAction::init(), and init().

_registered_identifier

std::string Action::_registered_identifier

protectedinherited

Definition at line 204 of file Action.h.

Referenced by SetupMeshAction::act().

_scalar_var

bool AddVariableAction::_scalar_var

protected

True if the variable being created is a scalar.

Definition at line 90 of file AddVariableAction.h.

Referenced by createInitialConditionAction(), AddElementalFieldAction::init(), and AddAuxVariableAction::init().

_specific_task_name

std::string Action::_specific_task_name

protectedinherited

This member will only be populated if this Action instance is only designed to handle one task.

This happens when an Action is registered with several pieces of syntax in which case separate instances are built to handle the different incoming parameter values.

Definition at line 227 of file Action.h.

Referenced by Action::specificTaskName().

_type

std::string MooseObjectAction::_type

protectedinherited

The Object type that is being created.

Definition at line 48 of file MooseObjectAction.h.

Referenced by AddBCAction::act(), AddDamperAction::act(), AddKernelAction::act(), AddMarkerAction::act(), AddPostprocessorAction::act(), AddIndicatorAction::act(), AddNodalKernelAction::act(), AddMultiAppAction::act(), AddDiracKernelAction::act(), CreateExecutionerAction::act(), AddConstraintAction::act(), AddInitialConditionAction::act(), AddICAction::act(), AddVectorPostprocessorAction::act(), AddTransferAction::act(), PartitionerAction::act(), AddDGKernelAction::act(), AddScalarKernelAction::act(), AddMaterialAction::act(), AddUserObjectAction::act(), AddInterfaceKernelAction::act(), CreateProblemAction::act(), AddMeshGeneratorAction::act(), AddFieldSplitAction::act(), AddMeshModifierAction::act(), SetupMeshAction::act(), SetupPredictorAction::act(), AddFunctionAction::act(), AddDistributionAction::act(), SetupTimeStepperAction::act(), SetupTimeIntegratorAction::act(), SetupPreconditionerAction::act(), AddSamplerAction::act(), AddOutputAction::act(), AddControlAction::act(), addVariable(), MooseObjectAction::getMooseObjectType(), AddElementalFieldAction::init(), init(), and SetupMeshAction::modifyParamsForUseSplit().

FILE_SUFFIX

constexpr auto MeshMetaDataInterface::FILE_SUFFIX = "_mesh"

staticconstexprinherited

The suffix appended when writing the restartable data file.

Definition at line 32 of file MeshMetaDataInterface.h.

Referenced by SetupRecoverFileBaseAction::act(), and Checkpoint::output().

NAME

constexpr auto MeshMetaDataInterface::NAME = "<empty>"

staticconstexprinherited

The data name used when initializing the Restartable interface for non-MeshGenerator objects.

Definition at line 38 of file MeshMetaDataInterface.h.

SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"

staticconstexprinherited

The system name used when initializing the Restartable interface.

Definition at line 35 of file MeshMetaDataInterface.h.

Referenced by MeshGenerator::declareMeshProperty(), and MeshMetaDataInterface::getMeshProperty().

---

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

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