Action to automatically ensure that PorousFlowMaterials are correctly evaluated at either the qps, nodes, or both. More...

#include <PorousFlowAddMaterialAction.h>

Inheritance diagram for PorousFlowAddMaterialAction:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PorousFlowAddMaterialAction (const InputParameters &params)

virtual void	act () override

void	timedAct ()

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

MooseObjectName	uniqueActionName () const

const std::string &	specificTaskName () const

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

void	appendTask (const std::string &task)

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

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

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

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

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

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

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

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

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	unique_action_name_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
void	createDependencyList ()
	Creates a set of all actions, kernels, etc to check material dependency against in order to determine whether to add nodal and/or qp materials.

bool	isPFMaterialRequired (std::string pf_material_type, bool at_nodes)
	Check to see if the material with a given at_nodes parameter is required.

bool	isPFMaterialPresent (AddMaterialAction *material, bool at_nodes)
	Check to see if the material with a given at_nodes parameter has already been included in the input file (to void duplicate material property errors)

void	addPFMaterial (AddMaterialAction *material, bool at_nodes)
	Adds the material for the given at_nodes parameter.

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

void	associateWithParameter (const std::string &param_name, InputParameters &params) const

void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const

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

const T &	getMeshProperty (const std::string &data_name)

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

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

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::string	_dictator_name
	Name of the PorousFlowDictator.

std::set< std::string >	_dependency_list
	List of kernels, actions etc that may depend on PorousFlow materials.

std::vector< AddMaterialAction * >	_ama_materials
	List of all materials added in the input file by AddMaterialAction.

std::string	_registered_identifier

std::string	_specific_task_name

std::set< std::string >	_all_tasks

ActionWarehouse &	_awh

const std::string &	_current_task

std::shared_ptr< MooseMesh > &	_mesh

std::shared_ptr< MooseMesh > &	_displaced_mesh

std::shared_ptr< FEProblemBase > &	_problem

PerfID	_act_timer

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

DependencyResolver< std::string >	_deps
	All dependencies of kernels, auxkernels, materials, etc, are stored in _dependencies.

Private Member Functions
bool	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=Moose::RMSystemType::NONE)

virtual std::string	meshPropertyPrefix (const std::string &data_name) const

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

void	mooseErrorInternal (Args &&... args) const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
const ParallelParamObject &	_parent

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

Detailed Description

Action to automatically ensure that PorousFlowMaterials are correctly evaluated at either the qps, nodes, or both.

This action works by checking all materials added in the input file. If a material is a valid PorousFlowMaterial, then it does one of the following: 1) If the at_nodes parameter has been set by the user, then it leaves that material alone (this assumes that the user has correctly added that material). 2) If the at_nodes parameter has not been set by the user, then the action checks to see if this material is required at the qps, nodes or both, and makes sure that the correct versions are added. 3) If a PorousFlowJoiner material is included in the input file, it does nothing (as the PorousFlowAddMaterialJoiner action will check for these and give a message that these materials are no longer required in the input file)

Definition at line 32 of file PorousFlowAddMaterialAction.h.

Constructor & Destructor Documentation

◆ PorousFlowAddMaterialAction()

PorousFlowAddMaterialAction::PorousFlowAddMaterialAction ( const InputParameters & params )

Definition at line 35 of file PorousFlowAddMaterialAction.C.

  : Action(params), PorousFlowDependencies()
{
}

Member Function Documentation

◆ act()

void PorousFlowAddMaterialAction::act ( )

overridevirtual

Implements Action.

Definition at line 41 of file PorousFlowAddMaterialAction.C.

{
  // Create the list of kernels, auxkernels, actions etc that each material may be
  // required by
  createDependencyList();
 
  // Get the list of materials that have been added
  auto actions = _awh.getActions<AddMaterialAction>();
 
  for (auto & action : actions)
    _ama_materials.push_back(const_cast<AddMaterialAction *>(action));
 
  for (auto & material : _ama_materials)
  {
    InputParameters & pars = material->getObjectParams();
 
    // Check if the material is a PorousFlow material
    if (pars.isParamValid("pf_material_type"))
    {
      const std::string pf_material_type = pars.get<std::string>("pf_material_type");
 
      // PorousFlowJoiner materials are added automatically by the PorousFlowAddMaterialJoiner
      // action, so no need to check these here
      if (pf_material_type != "joiner")
      {
        // There are two possibilities that must be considered:
        // 1) The parameter at_nodes has been set by the user. In this case, the material will
        // be added as normal by AddMaterialAction
        // 2) The parameter at_nodes has not been set by the user. In this case, this action
        // will check to see if the material is required at the qps, at the nodes, or possibly both
 
        // Only check the second possibility
        if (!pars.isParamSetByUser("at_nodes"))
        {
          bool qp_material_required = false;
 
          // First, check the case at_nodes = false, as this is the default behaviour for the
          // at_nodes parameter. Note: the local variable at_nodes is set to true, so the material
          // is at the qps when !at_nodes
          const bool at_nodes = true;
 
          if (isPFMaterialRequired(pf_material_type, !at_nodes))
          {
            // This material is required at the qps, so add it as normal (setting the paramter
            // at_nodes = false for clarity)
            pars.set<bool>("at_nodes") = !at_nodes;
            qp_material_required = true;
          }
 
          // Check if the material is required at the nodes as well and that it isn't already
          // added in the input file. If it is needed and not already supplied, then it is added
          // in one of two ways: 1) If the material wasn't also required at the qps (checked above),
          // then we can simply set the at_nodes parameter to true. 2) If it was also required at
          // the qps, then a new material action is required to be added to the action warehouse
          if (isPFMaterialRequired(pf_material_type, at_nodes) &&
              !isPFMaterialPresent(material, at_nodes))
          {
            if (!qp_material_required)
              pars.set<bool>("at_nodes") = at_nodes;
            else
              addPFMaterial(material, at_nodes);
          }
        }
      }
    }
  }
}

◆ addPFMaterial()

void PorousFlowAddMaterialAction::addPFMaterial	(	AddMaterialAction *	material,
		bool	at_nodes
	)

protected

Adds the material for the given at_nodes parameter.

Parameters

material	pointer to the material in the action warehouse
at_nodes	true if material is evaluates at the nodes, false otherwise

Definition at line 210 of file PorousFlowAddMaterialAction.C.

{
  const std::string nodal_ext = at_nodes ? "_nodal" : "_qp";
 
  // Input parameters for the material that is being added
  InputParameters & pars = material->getObjectParams();
 
  // PorousFlowMaterial type
  const std::string pf_material_type = pars.get<std::string>("pf_material_type");
  const std::string moose_object_type = material->getMooseObjectType();
 
  // If it is a material that also has a fluid phase, then extract that to add to name
  std::string phase_str;
  if (pars.isParamValid("phase"))
  {
    unsigned int phase = pars.get<unsigned int>("phase");
    phase_str = "_phase" + Moose::stringify(phase);
  }
 
  // Add material to the action warehouse
  InputParameters action_params = _action_factory.getValidParams("AddMaterialAction");
  action_params.set<ActionWarehouse *>("awh") = &_awh;
 
  // Setup action for passed in material type
  action_params.set<std::string>("type") = moose_object_type;
 
  const std::string material_name = material->name() + phase_str + nodal_ext;
 
  auto action = MooseSharedNamespace::dynamic_pointer_cast<MooseObjectAction>(
      _action_factory.create("AddMaterialAction", material_name, action_params));
 
  action->getObjectParams().applyParameters(pars);
  action->getObjectParams().set<bool>("at_nodes") = at_nodes;
 
  _awh.addActionBlock(action);
}

Referenced by act().

◆ createDependencyList()

void PorousFlowAddMaterialAction::createDependencyList ( )

protected

Creates a set of all actions, kernels, etc to check material dependency against in order to determine whether to add nodal and/or qp materials.

Definition at line 110 of file PorousFlowAddMaterialAction.C.

{
  // Unique list of kernels added in input file
  auto kernels = _awh.getActions<AddKernelAction>();
  for (auto & kernel : kernels)
    _dependency_list.insert(kernel->getMooseObjectType());
 
  // Unique list of PorousFlowActions added in input file
  auto actions = _awh.getActions<PorousFlowActionBase>();
  for (auto & action : actions)
    _dependency_list.insert(action->name());
 
  // Unique list of auxkernels added in input file
  auto auxkernels = _awh.getActions<AddKernelAction>();
  for (auto & auxkernel : auxkernels)
    _dependency_list.insert(auxkernel->getMooseObjectType());
 
  // Unique list of postprocessors added in input file
  auto postprocessors = _awh.getActions<AddPostprocessorAction>();
  for (auto & postprocessor : postprocessors)
    _dependency_list.insert(postprocessor->getMooseObjectType());
 
  // Unique list of userojects added in input file
  auto userobjects = _awh.getActions<AddUserObjectAction>();
  for (auto & userobject : userobjects)
    _dependency_list.insert(userobject->getMooseObjectType());
 
  // Unique list of BCs added in input file
  auto bcs = _awh.getActions<AddBCAction>();
  for (auto & bc : bcs)
    _dependency_list.insert(bc->getMooseObjectType());
 
  // Unique list of Dirac kernels added in input file
  auto diracs = _awh.getActions<AddDiracKernelAction>();
  for (auto & dirac : diracs)
    _dependency_list.insert(dirac->getMooseObjectType());
}

Referenced by act().

◆ isPFMaterialPresent()

bool PorousFlowAddMaterialAction::isPFMaterialPresent	(	AddMaterialAction *	material,
		bool	at_nodes
	)

protected

Check to see if the material with a given at_nodes parameter has already been included in the input file (to void duplicate material property errors)

Parameters

material	pointer to the material in the action warehouse
at_nodes	true if material is evaluated at the nodes, false otherwise

Returns: true is the material is already added in the input file, false otherwise

Definition at line 166 of file PorousFlowAddMaterialAction.C.

{
  bool is_present = false;
 
  // Need to check that it hasn't been added in the input file also to
  // avoid a duplicate material property error
  for (auto & ama_material : _ama_materials)
  {
    if (ama_material->name() != material->name() &&
        ama_material->getMooseObjectType() == material->getMooseObjectType())
    {
      InputParameters & mat_params = ama_material->getObjectParams();
      const bool mat_at_nodes = mat_params.get<bool>("at_nodes");
 
      InputParameters & pars = material->getObjectParams();
 
      // If the material isn't related to a fluid phase, it is present if
      // its at_nodes parameter is equal to the given at_nodes
      if (mat_at_nodes == at_nodes && !pars.isParamValid("phase"))
        is_present = true;
 
      // If the material is related to a fluid phase, it is present if
      // its at_nodes parameter is equal to the given at_nodes, and its
      // phase is equal to phase
      if (pars.isParamValid("phase"))
      {
        const unsigned int phase = pars.get<unsigned int>("phase");
 
        if (mat_params.isParamValid("phase") && mat_params.get<unsigned int>("phase") == phase)
          is_present = true;
      }
 
      // Finally, if the material is block restricted then it is not already
      // present if the block parameter is not identical
      if (mat_params.get<std::vector<SubdomainName>>("block") !=
          pars.get<std::vector<SubdomainName>>("block"))
        is_present = false;
    }
  }
 
  return is_present;
}

Referenced by act().

◆ isPFMaterialRequired()

bool PorousFlowAddMaterialAction::isPFMaterialRequired	(	std::string	pf_material_type,
		bool	at_nodes
	)

protected

Check to see if the material with a given at_nodes parameter is required.

Parameters

at_nodes true if material is evaluated at the nodes, false otherwise

Returns: true is the material is required, false otherwise

Definition at line 149 of file PorousFlowAddMaterialAction.C.

{
  const std::string nodal_ext = at_nodes ? "_nodal" : "_qp";
 
  // Check if this material is required by looping through the list of dependencies
  bool required = false;
  for (auto item : _dependency_list)
  {
    required = _deps.dependsOn(item, pf_material_type + nodal_ext);
    if (required)
      break;
  }
 
  return required;
}

Referenced by act().

◆ validParams()

InputParameters PorousFlowAddMaterialAction::validParams ( )

static

Definition at line 27 of file PorousFlowAddMaterialAction.C.

{
  InputParameters params = Action::validParams();
  params.addClassDescription(
      "Makes sure that the correct nodal and/or qp materials are added for each property");
  return params;
}