Action to programatically add PorousFlowJoiner materials without having to manually enter them in the input file. More...

#include <PorousFlowAddMaterialJoiner.h>

Inheritance diagram for PorousFlowAddMaterialJoiner:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PorousFlowAddMaterialJoiner (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 *	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 &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

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

Public Attributes
const ConsoleStream	_console

Static Public Attributes
static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
void	addJoiner (bool at_nodes, bool is_ad, const std::string &material_property, const std::string &output_name)
	Adds a PorousFlowJoiner for the given material property. More...

bool	hasJoiner (std::string property)
	Helper method to determine if a PorousFLowJoiner material is already present in the input file for the given material property. 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...

bool	_block_restricted
	whether the Material that is currently being Joined is block-restricted More...

std::vector< SubdomainName >	_blocks
	if _block_restricted == true, then these are the blocks that the Joiner will be restricted to More...

std::vector< std::string >	_already_joined
	Vector of already joined materials (to avoid joining them again) 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

Detailed Description

Action to programatically add PorousFlowJoiner materials without having to manually enter them in the input file.

Definition at line 18 of file PorousFlowAddMaterialJoiner.h.

Constructor & Destructor Documentation

◆ PorousFlowAddMaterialJoiner()

PorousFlowAddMaterialJoiner::PorousFlowAddMaterialJoiner ( const InputParameters & params )

Definition at line 29 of file PorousFlowAddMaterialJoiner.C.

   : Action(params), _already_joined()
 {
 }

Member Function Documentation

◆ act()

void PorousFlowAddMaterialJoiner::act ( )

overridevirtual

Implements Action.

Definition at line 35 of file PorousFlowAddMaterialJoiner.C.

 {
   // This task only runs after the UserObject and material actions have run,
   // so we can get the name of the PorousFlowDictator UserObject and all material
   // types
   if (_current_task == "add_joiners")
   {
     // Get the user objects that have been added to get the name of the PorousFlowDictator
     std::vector<UserObject *> userobjects;
     _problem->theWarehouse()
         .query()
         .condition<AttribSystem>("UserObject")
         .condition<AttribThread>(0)
         .queryInto(userobjects);
     for (auto & userobject : userobjects)
       if (dynamic_cast<PorousFlowDictator *>(userobject))
         _dictator_name = userobject->name();
 
     // Get the list of materials that have been added
     auto materials = _problem->getMaterialWarehouse().getObjects();
     for (auto & mat : materials)
     {
       const InputParameters & params = mat->parameters();
 
       // Only check PorousFlowMaterials
       if (params.isParamValid("pf_material_type"))
       {
         const std::string pf_material_type = params.get<std::string>("pf_material_type");
 
         _block_restricted = params.isParamValid("block");
         if (_block_restricted &&
             (pf_material_type == "fluid_properties" || pf_material_type == "relative_permeability"))
         {
           // this Material is block-restricted, and we're about to add Joiners for it, so must get
           // a union of all the blocks for this material type in order to block-restrict the Joiner
           std::set<SubdomainName> unique_blocks;
           for (auto & mat2 : _problem->getMaterialWarehouse().getObjects())
           {
             const InputParameters & params2 = mat2->parameters();
             if (params2.isParamValid("pf_material_type") &&
                 params2.get<std::string>("pf_material_type") == pf_material_type)
             {
               if (!params2.isParamValid("block"))
               {
                 // a Material of this type is not block-restricted, so the non-block-restricted
                 // Joiner can be added
                 _block_restricted = false;
                 break;
               }
               const std::vector<SubdomainName> & bl =
                   params2.get<std::vector<SubdomainName>>("block");
               std::copy(bl.begin(), bl.end(), std::inserter(unique_blocks, unique_blocks.end()));
             }
           }
           _blocks.assign(unique_blocks.begin(), unique_blocks.end());
         }
 
         // Check if the material is evaluated at the nodes or qps
         const bool at_nodes = params.get<bool>("at_nodes");
 
         // Add joiner material for fluid properties materials
         if (pf_material_type == "fluid_properties")
         {
           // Check if the material defines AD material properties
           const bool is_ad = params.get<bool>("is_ad");
 
           // Key the addition of the joiner off the phase 0 fluid so it is only added once
           if (params.get<unsigned int>("phase") == 0)
           {
             // Join density and viscosity if they are calculated
             if (params.get<bool>("compute_density_and_viscosity"))
             {
               if (at_nodes)
               {
                 addJoiner(at_nodes,
                           is_ad,
                           "PorousFlow_fluid_phase_density_nodal",
                           "PorousFlow_density_nodal_all");
                 addJoiner(at_nodes,
                           is_ad,
                           "PorousFlow_viscosity_nodal",
                           "PorousFlow_viscosity_nodal_all");
               }
               else
               {
                 addJoiner(at_nodes,
                           is_ad,
                           "PorousFlow_fluid_phase_density_qp",
                           "PorousFlow_density_qp_all");
                 addJoiner(
                     at_nodes, is_ad, "PorousFlow_viscosity_qp", "PorousFlow_viscosity_qp_all");
               }
             }
 
             // Join enthalpy if it is calculated
             if (params.get<bool>("compute_enthalpy"))
             {
               if (at_nodes)
                 addJoiner(at_nodes,
                           is_ad,
                           "PorousFlow_fluid_phase_enthalpy_nodal",
                           "PorousFlow_enthalpy_nodal_all");
               else
                 addJoiner(at_nodes,
                           is_ad,
                           "PorousFlow_fluid_phase_enthalpy_qp",
                           "PorousFlow_enthalpy_qp_all");
             }
 
             // Join internal energy if it is calculated
             if (params.get<bool>("compute_internal_energy"))
             {
               if (at_nodes)
                 addJoiner(at_nodes,
                           is_ad,
                           "PorousFlow_fluid_phase_internal_energy_nodal",
                           "PorousFlow_internal_energy_nodal_all");
               else
                 addJoiner(at_nodes,
                           is_ad,
                           "PorousFlow_fluid_phase_internal_energy_qp",
                           "PorousFlow_internal_energy_qp_all");
             }
           }
         }
 
         // Add joiner materials for relative permeability materials
         if (pf_material_type == "relative_permeability")
         {
           // Check if the material defines AD material properties
           const bool is_ad = params.get<bool>("is_ad");
 
           // Key the addition of the joiner off the phase 0 fluid so it is only added once
           if (params.get<unsigned int>("phase") == 0)
           {
             if (at_nodes)
               addJoiner(at_nodes,
                         is_ad,
                         "PorousFlow_relative_permeability_nodal",
                         "PorousFlow_relative_permeability_nodal_all");
             else
               addJoiner(at_nodes,
                         is_ad,
                         "PorousFlow_relative_permeability_qp",
                         "PorousFlow_relative_permeability_qp_all");
           }
         }
       }
     }
   }
 }

◆ addJoiner()

void PorousFlowAddMaterialJoiner::addJoiner	(	bool	at_nodes,
		bool	is_ad,
		const std::string &	material_property,
		const std::string &	output_name
	)

protected

Adds a PorousFlowJoiner for the given material property.

Parameters

at_nodes	if true: produce a nodal material, otherwise: produce a qp material
is_ad	if true: join AD materials, otherwise: join normal material
material_property	join this PorousFlow material property
output_name	The unique name given to this PorousFlowJoiner in the input file

Definition at line 188 of file PorousFlowAddMaterialJoiner.C.

Referenced by act().

 {
   bool is_joined = false;
 
   // Check if this material is already joined
   if (std::find(_already_joined.begin(), _already_joined.end(), material_property) !=
       _already_joined.end())
     is_joined = true;
 
   if (hasJoiner(material_property))
     is_joined = true;
 
   if (!is_joined)
   {
     std::string material_type;
     is_ad ? material_type = "ADPorousFlowJoiner" : material_type = "PorousFlowJoiner";
     InputParameters params = _factory.getValidParams(material_type);
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<bool>("at_nodes") = at_nodes;
     params.set<std::string>("material_property") = material_property;
     if (_block_restricted)
       params.set<std::vector<SubdomainName>>("block") = _blocks;
     _problem->addMaterial(material_type, output_name, params);
 
     // Add material to the already joined list
     _already_joined.push_back(material_property);
   }
 }

◆ hasJoiner()

bool PorousFlowAddMaterialJoiner::hasJoiner ( std::string property )

protected

Helper method to determine if a PorousFLowJoiner material is already present in the input file for the given material property.

Parameters

property the material property to check

Returns: true if a PorousFlowJoiner is already present for property, false otherwise

Definition at line 221 of file PorousFlowAddMaterialJoiner.C.

Referenced by addJoiner().

 {
   // Get the list of materials in the input file
   auto actions = _awh.getActions<AddMaterialAction>();
 
   for (auto & action : actions)
   {
     AddMaterialAction * material = const_cast<AddMaterialAction *>(action);
 
     if (material->getMooseObjectType() == "PorousFlowJoiner")
     {
       // If a PorousFlowJoiner material has been included in the input file,
       // let the user know that it should be removed
       mooseDeprecated("PorousFlowJoiner materials are no longer required in the input "
                       "file.\nPlease remove all PorousFlowJoiner materials from this input file to "
                       "get rid of this warning");
 
       const std::string joiner_property =
           material->getObjectParams().get<std::string>("material_property");
 
       // Check if the given material property is joined by this material
       if (joiner_property == property)
         return true;
     }
   }
 
   // If no PorousFlowJoiner materials matched property, return false
   return false;
 }

◆ validParams()

InputParameters PorousFlowAddMaterialJoiner::validParams ( )

static

Definition at line 21 of file PorousFlowAddMaterialJoiner.C.

 {
   InputParameters params = Action::validParams();
   params.addClassDescription(
       "Adds PorousFlowJoiner materials as required for each phase-dependent property");
   return params;
 }

Member Data Documentation

◆ _already_joined

std::vector<std::string> PorousFlowAddMaterialJoiner::_already_joined

protected

Vector of already joined materials (to avoid joining them again)

Definition at line 59 of file PorousFlowAddMaterialJoiner.h.

Referenced by addJoiner().

◆ _block_restricted

bool PorousFlowAddMaterialJoiner::_block_restricted

protected

whether the Material that is currently being Joined is block-restricted

Definition at line 53 of file PorousFlowAddMaterialJoiner.h.

Referenced by act(), and addJoiner().

◆ _blocks

std::vector<SubdomainName> PorousFlowAddMaterialJoiner::_blocks

protected

if _block_restricted == true, then these are the blocks that the Joiner will be restricted to

Definition at line 56 of file PorousFlowAddMaterialJoiner.h.

Referenced by act(), and addJoiner().

◆ _dictator_name

std::string PorousFlowAddMaterialJoiner::_dictator_name

protected

Name of the PorousFlowDictator.

Definition at line 50 of file PorousFlowAddMaterialJoiner.h.

Referenced by act(), and addJoiner().

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

porous_flow/include/actions/PorousFlowAddMaterialJoiner.h
porous_flow/src/actions/PorousFlowAddMaterialJoiner.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PorousFlowAddMaterialJoiner()

Member Function Documentation

◆ act()

◆ addJoiner()

◆ hasJoiner()

◆ validParams()

Member Data Documentation

◆ _already_joined

◆ _block_restricted

◆ _blocks

◆ _dictator_name