MaterialOutputAction Class Reference

Creates AuxVariables and AuxKernels for automatic output of material properties. More...

#include <MaterialOutputAction.h>

Inheritance diagram for MaterialOutputAction:

Public Member Functions
	MaterialOutputAction (InputParameters params)
	Class constructor. More...
virtual void	act () override
	Method to add objects to the simulation or perform other setup tasks. More...
void	timedAct ()
	The method called externally that causes the action to act() More...
virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)
	Method to add a relationship manager for the objects being added to the system. 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 &	getParam (const std::string &name) const
	Retrieve a parameter for the object. More...

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

Protected Member Functions
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...
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level)
	Call to register a named section for timing. More...

Protected Attributes
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
template<typename T >
bool	hasProperty (const std::string &property_name)
	Helper method for testing if the material exists as a block or boundary material. More...
template<typename T >
std::vector< std::string >	materialOutputHelper (const std::string &property_name, const Material &material, bool get_names_only)
	Template method for creating the necessary objects for the various material property types. More...
InputParameters	getParams (const std::string &type, const std::string &property_name, const std::string &variable_name, const Material &material)
	A method for retrieving and partially filling the InputParameters object for an AuxVariable. More...
template<>
std::vector< std::string >	materialOutputHelper (const std::string &material_name, const Material &material, bool get_names_only)
template<>
std::vector< std::string >	materialOutputHelper (const std::string &material_name, const Material &material, bool get_names_only)
template<>
std::vector< std::string >	materialOutputHelper (const std::string &material_name, const Material &material, bool get_names_only)
template<>
std::vector< std::string >	materialOutputHelper (const std::string &material_name, const Material &material, bool get_names_only)
template<>
std::vector< std::string >	materialOutputHelper (const std::string &material_name, const Material &material, bool get_names_only)
template<>
std::vector< std::string >	materialOutputHelper (const std::string &property_name, const Material &material, bool get_names_only)
template<>
std::vector< std::string >	materialOutputHelper (const std::string &property_name, const Material &material, bool get_names_only)
template<>
std::vector< std::string >	materialOutputHelper (const std::string &property_name, const Material &material, bool get_names_only)
template<>
std::vector< std::string >	materialOutputHelper (const std::string &property_name, const Material &material, bool get_names_only)
template<>
std::vector< std::string >	materialOutputHelper (const std::string &property_name, const Material &material, bool get_names_only)

Private Attributes
std::shared_ptr< MaterialData >	_block_material_data
	Pointer the MaterialData object storing the block restricted materials. More...
std::shared_ptr< MaterialData >	_boundary_material_data
	Pointer the MaterialData object storing the boundary restricted materials. More...
std::map< std::string, std::set< SubdomainID > >	_block_variable_map
	Map of variable name that contains the blocks to which the variable should be restricted. More...
std::set< std::string >	_material_variable_names
	List of variables for the current Material object. More...
std::map< OutputName, std::set< std::string > >	_material_variable_names_map
	Map of output names and list of variables associated with the output. More...
OutputWarehouse &	_output_warehouse
	Reference to the OutputWarehouse. More...

Detailed Description

Creates AuxVariables and AuxKernels for automatic output of material properties.

Definition at line 28 of file MaterialOutputAction.h.

Constructor & Destructor Documentation

MaterialOutputAction()

MaterialOutputAction::MaterialOutputAction

(

InputParameters

params

)

Class constructor.

Parameters

params

Input parameters for this action object

Definition at line 54 of file MaterialOutputAction.C.

  : Action(params), _output_warehouse(_app.getOutputWarehouse())
{
}

Member Function Documentation

act()

void MaterialOutputAction::act ( )

overridevirtual

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

Implements Action.

Definition at line 60 of file MaterialOutputAction.C.

{
  mooseAssert(_problem,
              "FEProblemBase pointer is nullptr, it is needed for auto material property output");

  // Do nothing if the application does not have output
  if (!_app.actionWarehouse().hasActions("add_output"))
    return;

  bool get_names_only = _current_task == "add_output_aux_variables" ? true : false;

  // Set the pointers to the MaterialData objects (Note, these pointers are not available at
  // construction)
  _block_material_data = _problem->getMaterialData(Moose::BLOCK_MATERIAL_DATA);
  _boundary_material_data = _problem->getMaterialData(Moose::BOUNDARY_MATERIAL_DATA);

  // A complete list of all Material objects
  const auto & material_ptrs = _problem->getMaterialWarehouse().getObjects();

  // Handle setting of material property output in [Outputs] sub-blocks
  // Output objects can enable material property output, the following code examines the parameters
  // for each Output object and sets a flag if any Output object has output set and also builds a
  // list if the
  // properties are limited via the 'show_material_properties' parameters
  bool outputs_has_properties = false;
  std::set<std::string> output_object_properties;

  const auto & output_actions = _app.actionWarehouse().getActionListByName("add_output");
  for (const auto & act : output_actions)
  {
    // Extract the Output action
    AddOutputAction * action = dynamic_cast<AddOutputAction *>(act);
    if (!action)
      continue;

    // Add the material property names from the output object parameters to the list of properties
    // to output
    InputParameters & params = action->getObjectParams();
    if (params.isParamValid("output_material_properties") &&
        params.get<bool>("output_material_properties"))
    {
      outputs_has_properties = true;
      std::vector<std::string> prop_names =
          params.get<std::vector<std::string>>("show_material_properties");
      output_object_properties.insert(prop_names.begin(), prop_names.end());
    }
  }

  // Loop through each material object
  std::set<std::string> material_names;
  for (const auto & mat : material_ptrs)
  {
    // Extract the names of the output objects to which the material properties will be exported
    std::set<OutputName> outputs = mat->getOutputs();

    // Extract the property names that will actually be output
    std::vector<std::string> output_properties =
        mat->getParam<std::vector<std::string>>("output_properties");

    // Append the properties listed in the Outputs block
    if (outputs_has_properties)
      output_properties.insert(output_properties.end(),
                               output_object_properties.begin(),
                               output_object_properties.end());

    // Clear the list of variable names for the current material object, this list will be populated
    // with all the
    // variables names for the current material object and is needed for purposes of controlling the
    // which output objects
    // show the material property data
    _material_variable_names.clear();

    // Create necessary outputs for the properties if:
    //   (1) The Outputs block has material output enabled
    //   (2) If the Material object itself has set the 'outputs' parameter
    if (outputs_has_properties || outputs.find("none") == outputs.end())
    {
      // Add the material property for output if the name is contained in the 'output_properties'
      // list
      // or if the list is empty (all properties)
      const std::set<std::string> names = mat->getSuppliedItems();
      std::vector<std::string> curr_material_names;
      for (const auto & name : names)
      {
        // Add the material property for output
        if (output_properties.empty() ||
            std::find(output_properties.begin(), output_properties.end(), name) !=
                output_properties.end())
        {
          if (hasProperty<Real>(name))
          {
            curr_material_names = materialOutputHelper<Real>(name, *mat, get_names_only);
            material_names.insert(curr_material_names.begin(), curr_material_names.end());
          }

          else if (hasProperty<RealVectorValue>(name))
          {
            curr_material_names = materialOutputHelper<RealVectorValue>(name, *mat, get_names_only);
            material_names.insert(curr_material_names.begin(), curr_material_names.end());
          }

          else if (hasProperty<RealTensorValue>(name))
          {
            curr_material_names = materialOutputHelper<RealTensorValue>(name, *mat, get_names_only);
            material_names.insert(curr_material_names.begin(), curr_material_names.end());
          }

          else if (hasProperty<RankTwoTensor>(name))
          {
            curr_material_names = materialOutputHelper<RankTwoTensor>(name, *mat, get_names_only);
            material_names.insert(curr_material_names.begin(), curr_material_names.end());
          }

          else if (hasProperty<RankFourTensor>(name))
          {
            curr_material_names = materialOutputHelper<RankFourTensor>(name, *mat, get_names_only);
            material_names.insert(curr_material_names.begin(), curr_material_names.end());
          }

          else
            mooseWarning("The type for material property '",
                         name,
                         "' is not supported for automatic output.");
        }

        // If the material object as limited outputs, store the variables associated with the output
        // objects
        if (!outputs.empty())
          for (const auto & output_name : outputs)
            _material_variable_names_map[output_name].insert(_material_variable_names.begin(),
                                                             _material_variable_names.end());
      }
    }
  }

  if (_current_task == "add_output_aux_variables")
  {

    // Create the AuxVariables
    FEType fe_type(
        CONSTANT,
        MONOMIAL); // currently only elemental variables are support for material property output
    for (const auto & var_name : material_names)
      _problem->addAuxVariable(var_name, fe_type);
  }
  else
  {
    // When a Material object has 'output_properties' defined all other properties not listed must
    // be added to the hide list for the output objects so that properties that are not desired do
    // not appear.
    for (const auto & it : _material_variable_names_map)
    {
      std::set<std::string> hide;
      std::set_difference(material_names.begin(),
                          material_names.end(),
                          it.second.begin(),
                          it.second.end(),
                          std::inserter(hide, hide.begin()));

      _output_warehouse.addInterfaceHideVariables(it.first, hide);
    }
  }
}

addRelationshipManagers() [1/2]

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 95 of file Action.C.

{
  const auto & buildable_types = moose_object_pars.getBuildableRelationshipManagerTypes();

  // These need unique names
  static unsigned int unique_object_id = 0;

  for (const auto & buildable_type : buildable_types)
  {
    unique_object_id++;

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

    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<std::string>("for_whom") = name();

    // Figure out if we shouldn't be adding this one yet
    if (((rm_type & input_rm_type) != input_rm_type) // Does this RM not have the type passed in?

        || // 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 and Geometric one that we already added earlier?

        (((input_rm_type & Moose::RelationshipManagerType::ALGEBRAIC) ==
          Moose::RelationshipManagerType::ALGEBRAIC) &&
         (rm_type == (Moose::RelationshipManagerType::GEOMETRIC |
                      Moose::RelationshipManagerType::ALGEBRAIC)) &&
         rm_params.template get<bool>("attach_geometric_early")))
      continue;

    // 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
      continue;
    }
    // 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::ALGEBRAIC &&
             (rm_params.get<Moose::RelationshipManagerType>("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
      mooseError("Missing required parameters for RelationshipManager " + rm_name + " for object " +
                 name());
  }
}

addRelationshipManagers() [2/2]

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

virtualinherited

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 in MooseObjectAction.

Definition at line 92 of file Action.C.

{}

appendTask()

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

inlineinherited

Definition at line 118 of file Action.h.

{ _all_tasks.insert(task); }

getAllTasks()

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

inlineinherited

Definition at line 94 of file Action.h.

Referenced by AddKernelAction::act().

{ return _all_tasks; }

getBaseName()

std::string Action::getBaseName ( ) const

inherited

Deprecated name methods, use name()

Definition at line 200 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 111 of file Action.h.

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

getParam()

template<typename T >

const T & Action::getParam ( 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 225 of file Action.h.

Referenced by CreateDisplacedProblemAction::act(), AddPeriodicBCAction::act(), AddPeriodicBCAction::autoTranslationBoundaries(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), and MooseApp::getCheckpointDirectories().

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

getParams()

InputParameters MaterialOutputAction::getParams ( const std::string &  type, const std::string &  property_name, const std::string &  variable_name, const Material &  material  )

private

A method for retrieving and partially filling the InputParameters object for an AuxVariable.

Parameters

type	The type of AuxVariable
property_name	The property name to associated with that action
variable_name	The AuxVariable name to create
material	A Material object containing the property of interest

Returns

An InputParameter object with common properties added.

Definition at line 225 of file MaterialOutputAction.C.

{
  // Append the list of output variables for the current material
  _material_variable_names.insert(variable_name);

  // Set the action parameters
  InputParameters params = _factory.getValidParams(type);

  params.set<MaterialPropertyName>("property") = property_name;
  params.set<AuxVariableName>("variable") = variable_name;
  params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;

  if (material.boundaryRestricted())
    params.set<std::vector<BoundaryName>>("boundary") = material.boundaryNames();
  else
    params.set<std::vector<SubdomainName>>("block") = material.blocks();

  return params;
}

getShortName()

std::string Action::getShortName ( ) const

inherited

DEPRECATED METHODS.

Definition at line 193 of file Action.C.

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

hasProperty()

template<typename T >

bool MaterialOutputAction::hasProperty ( const std::string &  property_name )

private

Helper method for testing if the material exists as a block or boundary material.

Template Parameters

T	The property type (e.g., REAL)

Parameters

property_name

The name of the property to test

Definition at line 109 of file MaterialOutputAction.h.

{
  if (_block_material_data->haveProperty<T>(property_name) ||
      _boundary_material_data->haveProperty<T>(property_name))
    return true;
  else
    return false;
}

isParamValid()

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

inlineinherited

Definition at line 116 of file Action.h.

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

{ return _pars.isParamValid(name); }

materialOutputHelper() [1/11]

template<typename T >

std::vector< std::string > MaterialOutputAction::materialOutputHelper ( const std::string &  property_name, const Material &  material, bool  get_names_only  )

private

Template method for creating the necessary objects for the various material property types.

Template Parameters

T	The type of material property that automatic output is being performed

Parameters

property_name	The name of the material property to output
material	A pointer to the Material object containing the property of interest
get_names_only	A bool used to indicate that only the variable names should be returned

Returns

A vector of names that can be used as AuxVariable names

By default this function produces an mooseError, you must create a specialization for any type that you wish to have the automatic output capability. Also, you need to add a test for this type within the act() method.

Definition at line 100 of file MaterialOutputAction.h.

{
  mooseError("Unknown type, you must create a specialization of materialOutputHelper");
}

materialOutputHelper() [2/11]

template<>

std::vector<std::string> MaterialOutputAction::materialOutputHelper ( const std::string &  material_name, const Material &  material, bool  get_names_only  )

private

materialOutputHelper() [3/11]

template<>

std::vector<std::string> MaterialOutputAction::materialOutputHelper ( const std::string &  material_name, const Material &  material, bool  get_names_only  )

private

materialOutputHelper() [4/11]

template<>

std::vector<std::string> MaterialOutputAction::materialOutputHelper ( const std::string &  material_name, const Material &  material, bool  get_names_only  )

private

materialOutputHelper() [5/11]

template<>

std::vector<std::string> MaterialOutputAction::materialOutputHelper ( const std::string &  material_name, const Material &  material, bool  get_names_only  )

private

materialOutputHelper() [6/11]

template<>

std::vector<std::string> MaterialOutputAction::materialOutputHelper ( const std::string &  material_name, const Material &  material, bool  get_names_only  )

private

materialOutputHelper() [7/11]

template<>

std::vector<std::string> MaterialOutputAction::materialOutputHelper ( const std::string &  property_name, const Material &  material, bool  get_names_only  )

private

Definition at line 291 of file MaterialOutputAction.C.

{
  std::vector<std::string> names(LIBMESH_DIM * LIBMESH_DIM);

  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
    for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
    {
      std::ostringstream oss;
      oss << property_name << "_" << i << j;
      names[i * LIBMESH_DIM + j] = oss.str();

      if (!get_names_only)
      {
        auto params = getParams("MaterialRealTensorValueAux", property_name, oss.str(), material);
        params.set<unsigned int>("row") = i;
        params.set<unsigned int>("column") = j;
        _problem->addAuxKernel("MaterialRealTensorValueAux", material.name() + oss.str(), params);
      }
    }

  return names;
}

materialOutputHelper() [8/11]

template<>

std::vector<std::string> MaterialOutputAction::materialOutputHelper ( const std::string &  property_name, const Material &  material, bool  get_names_only  )

private

Definition at line 250 of file MaterialOutputAction.C.

{
  std::vector<std::string> names = {property_name};
  if (!get_names_only)
  {
    auto params = getParams("MaterialRealAux", property_name, property_name, material);
    _problem->addAuxKernel("MaterialRealAux", material.name() + property_name, params);
  }

  return names;
}

materialOutputHelper() [9/11]

template<>

std::vector<std::string> MaterialOutputAction::materialOutputHelper ( const std::string &  property_name, const Material &  material, bool  get_names_only  )

private

Definition at line 318 of file MaterialOutputAction.C.

{
  std::vector<std::string> names(LIBMESH_DIM * LIBMESH_DIM);

  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
    for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
    {
      std::ostringstream oss;
      oss << property_name << "_" << i << j;
      names[i * LIBMESH_DIM + j] = oss.str();

      if (!get_names_only)
      {
        auto params = getParams("MaterialRankTwoTensorAux", property_name, oss.str(), material);
        params.set<unsigned int>("i") = i;
        params.set<unsigned int>("j") = j;
        _problem->addAuxKernel("MaterialRankTwoTensorAux", material.name() + oss.str(), params);
      }
    }

  return names;
}

materialOutputHelper() [10/11]

template<>

std::vector<std::string> MaterialOutputAction::materialOutputHelper ( const std::string &  property_name, const Material &  material, bool  get_names_only  )

private

Definition at line 266 of file MaterialOutputAction.C.

{
  std::array<char, 3> suffix = {{'x', 'y', 'z'}};
  std::vector<std::string> names(3);
  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
  {
    std::ostringstream oss;
    oss << property_name << "_" << suffix[i];
    names[i] = oss.str();

    if (!get_names_only)
    {
      auto params = getParams("MaterialRealVectorValueAux", property_name, oss.str(), material);
      params.set<unsigned int>("component") = i;
      _problem->addAuxKernel("MaterialRealVectorValueAux", material.name() + oss.str(), params);
    }
  }

  return names;
}

materialOutputHelper() [11/11]

template<>

std::vector<std::string> MaterialOutputAction::materialOutputHelper ( const std::string &  property_name, const Material &  material, bool  get_names_only  )

private

Definition at line 345 of file MaterialOutputAction.C.

{
  std::vector<std::string> names(Utility::pow<4>(LIBMESH_DIM));

  unsigned int counter = 0;
  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
    for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
      for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
        for (unsigned int l = 0; l < LIBMESH_DIM; ++l)
        {
          std::ostringstream oss;
          oss << property_name << "_" << i << j << k << l;
          names[counter++] = oss.str();

          if (!get_names_only)
          {
            auto params =
                getParams("MaterialRankFourTensorAux", property_name, oss.str(), material);
            params.set<unsigned int>("i") = i;
            params.set<unsigned int>("j") = j;
            params.set<unsigned int>("k") = k;
            params.set<unsigned int>("l") = l;
            _problem->addAuxKernel(
                "MaterialRankFourTensorAux", material.name() + oss.str(), params);
          }
        }

  return names;
}

name()

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

inlineinherited

The name of the action.

Definition at line 77 of file Action.h.

Referenced by AddElementalFieldAction::act(), CopyNodalVarsAction::act(), AdaptivityAction::act(), DeprecatedBlockAction::act(), AddMortarInterfaceAction::act(), DisplayGhostingAction::act(), AddAuxVariableAction::act(), AddPeriodicBCAction::act(), act(), AddVariableAction::act(), Action::addRelationshipManagers(), CheckOutputAction::checkVariableOutput(), AddVariableAction::createInitialConditionAction(), Action::getCheckedPointerParam(), Action::getParam(), Action::isParamValid(), GlobalParamsAction::remove(), GlobalParamsAction::setDoubleIndexParam(), GlobalParamsAction::setScalarParam(), and GlobalParamsAction::setVectorParam().

{ return _name; }

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 127 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 89 of file Action.h.

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

{ return _pars; }

parameters() [2/2]

const InputParameters& Action::parameters ( ) const

inlineinherited

Definition at line 90 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 157 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 141 of file Action.h.

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

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 50 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 92 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 86 of file Action.C.

{
  TIME_SECTION(_act_timer);
  act();
}

type()

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

inlineinherited

Definition at line 87 of file Action.h.

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

{ return _action_type; }

Member Data Documentation

_act_timer

PerfID Action::_act_timer

protectedinherited

Timers.

Definition at line 220 of file Action.h.

Referenced by Action::timedAct().

_action_factory

ActionFactory& Action::_action_factory

protectedinherited

Builds Actions.

Definition at line 190 of file Action.h.

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

_action_type

std::string Action::_action_type

protectedinherited

Definition at line 181 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 205 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 184 of file Action.h.

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

_awh

ActionWarehouse& Action::_awh

protectedinherited

Reference to ActionWarehouse where we store object build by actions.

Definition at line 208 of file Action.h.

Referenced by CheckIntegrityAction::act(), SetupDampersAction::act(), CreateProblemDefaultAction::act(), AddRelationshipManager::act(), CheckOutputAction::checkVariableOutput(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CommonOutputAction::hasConsole(), and SetupDebugAction::SetupDebugAction().

_block_material_data

std::shared_ptr<MaterialData> MaterialOutputAction::_block_material_data

private

Pointer the MaterialData object storing the block restricted materials.

Definition at line 80 of file MaterialOutputAction.h.

Referenced by act(), and hasProperty().

_block_variable_map

std::map<std::string, std::set<SubdomainID> > MaterialOutputAction::_block_variable_map

private

Map of variable name that contains the blocks to which the variable should be restricted.

Definition at line 86 of file MaterialOutputAction.h.

_boundary_material_data

std::shared_ptr<MaterialData> MaterialOutputAction::_boundary_material_data

private

Pointer the MaterialData object storing the boundary restricted materials.

Definition at line 83 of file MaterialOutputAction.h.

Referenced by act(), and hasProperty().

_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(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), FEProblemBase::FEProblemBase(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MultiApp::globalAppToLocal(), InversePowerMethod::init(), NonlinearEigen::init(), Steady::init(), FEProblemBase::initialAdaptMesh(), FEProblemBase::initialSetup(), EigenExecutionerBase::inversePowerIteration(), Transient::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseObject::mooseDeprecated(), MooseObject::mooseInfo(), MooseObject::mooseWarning(), PerfGraphOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), Console::outputPostprocessors(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), EigenExecutionerBase::printEigenvalue(), MaterialPropertyDebugOutput::printMaterialMap(), SolutionTimeAdaptiveDT::rejectStep(), DT2::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), SimplePredictor::shouldApply(), NonlinearSystem::solve(), PicardSolve::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), PicardSolve::solveStep(), DT2::step(), AB2PredictorCorrector::step(), NonlinearEigen::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 211 of file Action.h.

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

_displaced_mesh

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

protectedinherited

Definition at line 214 of file Action.h.

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

_factory

Factory& Action::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 187 of file Action.h.

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

_material_variable_names

std::set<std::string> MaterialOutputAction::_material_variable_names

private

List of variables for the current Material object.

Definition at line 89 of file MaterialOutputAction.h.

Referenced by act(), and getParams().

_material_variable_names_map

std::map<OutputName, std::set<std::string> > MaterialOutputAction::_material_variable_names_map

private

Map of output names and list of variables associated with the output.

Definition at line 92 of file MaterialOutputAction.h.

Referenced by act().

_mesh

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

protectedinherited

Definition at line 213 of file Action.h.

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

_name

std::string Action::_name

protectedinherited

The name of the action.

Definition at line 178 of file Action.h.

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

_output_warehouse

OutputWarehouse& MaterialOutputAction::_output_warehouse

private

Reference to the OutputWarehouse.

Definition at line 95 of file MaterialOutputAction.h.

Referenced by act().

_pars

InputParameters Action::_pars

protectedinherited

Input parameters for the action.

Definition at line 172 of file Action.h.

Referenced by AddICAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), Action::getParam(), 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 66 of file PerfGraphInterface.h.

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

_pg_params

const InputParameters* PerfGraphInterface::_pg_params

protectedinherited

Params.

Definition at line 63 of file PerfGraphInterface.h.

_prefix

std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 69 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 217 of file Action.h.

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

_registered_identifier

std::string Action::_registered_identifier

protectedinherited

Definition at line 175 of file Action.h.

_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 198 of file Action.h.

Referenced by Action::specificTaskName().

---

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

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