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 Member Functions
	PorousFlowAddMaterialJoiner (const InputParameters &params)

virtual void	act () override

Protected Member Functions
void	addJoiner (bool at_nodes, 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...

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

std::vector< std::string >	_already_joined
	Vector of already joined materials (to avoid joining them again) More...

Detailed Description

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

Definition at line 23 of file PorousFlowAddMaterialJoiner.h.

Constructor & Destructor Documentation

◆ PorousFlowAddMaterialJoiner()

PorousFlowAddMaterialJoiner::PorousFlowAddMaterialJoiner ( const InputParameters & params )

Definition at line 30 of file PorousFlowAddMaterialJoiner.C.

   : Action(params), _already_joined()
 {
 }

Member Function Documentation

◆ act()

void PorousFlowAddMaterialJoiner::act ( )

overridevirtual

Definition at line 36 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");
  
         // 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")
         {
           // 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,
                           "PorousFlow_fluid_phase_density_nodal",
                           "PorousFlow_density_nodal_all");
                 addJoiner(at_nodes, "PorousFlow_viscosity_nodal", "PorousFlow_viscosity_nodal_all");
               }
               else
               {
                 addJoiner(
                     at_nodes, "PorousFlow_fluid_phase_density_qp", "PorousFlow_density_qp_all");
                 addJoiner(at_nodes, "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,
                           "PorousFlow_fluid_phase_enthalpy_nodal",
                           "PorousFlow_enthalpy_nodal_all");
               else
                 addJoiner(
                     at_nodes, "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,
                           "PorousFlow_fluid_phase_internal_energy_nodal",
                           "PorousFlow_internal_energy_nodal_all");
               else
                 addJoiner(at_nodes,
                           "PorousFlow_fluid_phase_internal_energy_qp",
                           "PorousFlow_internal_energy_qp_all");
             }
           }
         }
  
         // Add joiner materials for relative permeability materials
         if (pf_material_type == "relative_permeability")
         {
           // 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,
                         "PorousFlow_relative_permeability_nodal",
                         "PorousFlow_relative_permeability_nodal_all");
             else
               addJoiner(at_nodes,
                         "PorousFlow_relative_permeability_qp",
                         "PorousFlow_relative_permeability_qp_all");
           }
         }
       }
     }
   }
 }

◆ addJoiner()

void PorousFlowAddMaterialJoiner::addJoiner	(	bool	at_nodes,
		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
material_property	join this PorousFlow material property
output_name	The unique name given to this PorousFlowJoiner in the input file

Definition at line 141 of file PorousFlowAddMaterialJoiner.C.

 {
   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 = "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;
     _problem->addMaterial(material_type, output_name, params);
  
     // Add material to the already joined list
     _already_joined.push_back(material_property);
   }
 }

Referenced by act().

◆ 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 170 of file PorousFlowAddMaterialJoiner.C.

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