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

virtual const std::string &	name () const

std::string	typeAndName () const

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

void	callMooseError (std::string msg, const bool with_prefix) const

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

const InputParameters &	parameters () const

MooseObjectName	uniqueName () 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 &	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 &nm) const

void	paramError (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

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

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

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

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

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

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

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

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

PerfGraph &	perfGraph ()

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

std::string	getDataFileNameByName (const std::string &name, const std::string *param=nullptr) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console

Static Public Attributes
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. More...

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

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) More...

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

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

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. More...

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

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

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

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

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. More...

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.

Referenced by act().

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

◆ 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.

Referenced by act().

 {
   // 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());
 }

◆ 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.

Referenced by act().

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

◆ 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.

Referenced by act().

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

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