Base class for PorousFlow actions. More...

#include <PorousFlowActionBase.h>

Inheritance diagram for PorousFlowActionBase:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PorousFlowActionBase (const InputParameters &params)

virtual void	act () override

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type) override

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

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

void	timedAct ()

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 Types
enum	StabilizationEnum { StabilizationEnum::None, StabilizationEnum::Full, StabilizationEnum::KT }

Protected Member Functions
virtual void	addDictator ()=0
	Add the PorousFlowDictator object. More...

virtual void	addUserObjects ()
	Add all other UserObjects. More...

virtual void	addAuxObjects ()
	Add all AuxVariables and AuxKernels. More...

virtual void	addKernels ()
	Add all Kernels. More...

virtual void	addMaterialDependencies ()
	Add all material dependencies so that the correct version of each material can be added. More...

virtual void	addMaterials ()
	Add all Materials. More...

void	addSaturationAux (unsigned phase)
	Add an AuxVariable and AuxKernel to calculate saturation. More...

void	addDarcyAux (const RealVectorValue &gravity)
	Add AuxVariables and AuxKernels to calculate Darcy velocity. More...

void	addStressAux ()
	Add AuxVariables and AuxKernels to compute effective stress. More...

void	addTemperatureMaterial (bool at_nodes)
	Adds a nodal and a quadpoint Temperature material. More...

void	addMassFractionMaterial (bool at_nodes)
	Adds a nodal and a quadpoint MassFraction material. More...

void	addEffectiveFluidPressureMaterial (bool at_nodes)
	Adds a nodal and a quadpoint effective fluid pressure material. More...

void	addNearestQpMaterial ()
	Adds a PorousFlowNearestQp material. More...

void	addVolumetricStrainMaterial (const std::vector< VariableName > &displacements, const std::string &base_name)
	Adds a quadpoint volumetric strain material. More...

void	addSingleComponentFluidMaterial (bool at_nodes, unsigned phase, bool compute_density_and_viscosity, bool compute_internal_energy, bool compute_enthalpy, const UserObjectName &fp, const MooseEnum &temperature_unit, const MooseEnum &pressure_unit, const MooseEnum &time_unit)
	Adds a single-component fluid Material. More...

void	addBrineMaterial (const VariableName xnacl, bool at_nodes, unsigned phase, bool compute_density_and_viscosity, bool compute_internal_energy, bool compute_enthalpy, const MooseEnum &temperature_unit)
	Adds a brine fluid Material. More...

void	addRelativePermeabilityConst (bool at_nodes, unsigned phase, Real kr)
	Adds a relative-permeability Material of the constant variety (primarily to add kr = 1 in actions that add a default relatively permeability for objects that require kr even when the flow is fully saturated with a single phase) More...

void	addRelativePermeabilityCorey (bool at_nodes, unsigned phase, Real n, Real s_res, Real sum_s_res)
	Adds a relative-permeability Material of the Corey variety. More...

void	addRelativePermeabilityFLAC (bool at_nodes, unsigned phase, Real m, Real s_res, Real sum_s_res)
	Adds a relative-permeability Material of the FLAC variety. More...

void	addCapillaryPressureVG (Real m, Real alpha, std::string userobject_name)
	Adds a van Genuchten capillary pressure UserObject. More...

void	addAdvectiveFluxCalculatorSaturated (unsigned phase, bool multiply_by_density, std::string userobject_name)

void	addAdvectiveFluxCalculatorUnsaturated (unsigned phase, bool multiply_by_density, std::string userobject_name)

void	addAdvectiveFluxCalculatorSaturatedHeat (unsigned phase, bool multiply_by_density, std::string userobject_name)

void	addAdvectiveFluxCalculatorUnsaturatedHeat (unsigned phase, bool multiply_by_density, std::string userobject_name)

void	addAdvectiveFluxCalculatorSaturatedMultiComponent (unsigned phase, unsigned fluid_component, bool multiply_by_density, std::string userobject_name)

void	addAdvectiveFluxCalculatorUnsaturatedMultiComponent (unsigned phase, unsigned fluid_component, bool multiply_by_density, std::string userobject_name)

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::vector< std::string >	_included_objects
	List of Kernels, AuxKernels, Materials, etc, that are added in this input file. More...

const std::string	_dictator_name
	The name of the PorousFlowDictator object to be added. More...

const unsigned int	_num_aqueous_equilibrium
	Number of aqueous-equilibrium secondary species. More...

const unsigned int	_num_aqueous_kinetic
	Number of aqeuous-kinetic secondary species that are involved in mineralisation. More...

const RealVectorValue	_gravity
	Gravity. More...

const std::vector< VariableName >	_mass_fraction_vars
	Name of the mass-fraction variables (if any) More...

const unsigned	_num_mass_fraction_vars
	Number of mass-fraction variables. More...

const std::vector< VariableName >	_temperature_var
	Name of the temperature variable (if any) More...

const std::vector< VariableName > &	_displacements
	Displacement NonlinearVariable names (if any) More...

const unsigned	_ndisp
	Number of displacement variables supplied. More...

std::vector< VariableName >	_coupled_displacements
	Displacement Variable names. More...

const MooseEnum	_flux_limiter_type
	Flux limiter type in the Kuzmin-Turek FEM-TVD stabilization scheme. More...

enum PorousFlowActionBase::StabilizationEnum	_stabilization

const bool	_strain_at_nearest_qp
	Evaluate strain at the nearest quadpoint for porosity that depends on strain. More...

Moose::CoordinateSystemType	_coord_system
	Coordinate system of the simulation (eg RZ, XYZ, etc) More...

bool	_transient
	Flag to denote if the simulation is transient. 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

Base class for PorousFlow actions.

This act() method makes consistency checks and calls several methods that should be implemented in derived classes. This class also contains a number of utility functions that may be used by derived classes.

Derived classes should typically only override the following methods:

Definition at line 30 of file PorousFlowActionBase.h.

Member Enumeration Documentation

◆ StabilizationEnum

enum PorousFlowActionBase::StabilizationEnum

strongprotected

Enumerator
None
Full
KT

Definition at line 83 of file PorousFlowActionBase.h.

83 { None, Full, KT } _stabilization;

Homogenization::ConstraintType::None

PorousFlowActionBase::_stabilization

enum PorousFlowActionBase::StabilizationEnum _stabilization

Constructor & Destructor Documentation

◆ PorousFlowActionBase()

PorousFlowActionBase::PorousFlowActionBase ( const InputParameters & params )

Definition at line 96 of file PorousFlowActionBase.C.

   : Action(params),
     PorousFlowDependencies(),
     _included_objects(),
     _dictator_name(getParam<std::string>("dictator_name")),
     _num_aqueous_equilibrium(getParam<unsigned int>("number_aqueous_equilibrium")),
     _num_aqueous_kinetic(getParam<unsigned int>("number_aqueous_kinetic")),
     _gravity(getParam<RealVectorValue>("gravity")),
     _mass_fraction_vars(isParamValid("mass_fraction_vars")
                             ? getParam<std::vector<VariableName>>("mass_fraction_vars")
                             : std::vector<VariableName>{}),
     _num_mass_fraction_vars(_mass_fraction_vars.size()),
     _temperature_var(isParamValid("temperature")
                          ? getParam<std::vector<VariableName>>("temperature")
                          : std::vector<VariableName>{}),
     _displacements(getParam<std::vector<VariableName>>("displacements")),
     _ndisp(_displacements.size()),
     _coupled_displacements(_ndisp),
     _flux_limiter_type(getParam<MooseEnum>("flux_limiter_type")),
     _stabilization(getParam<MooseEnum>("stabilization").getEnum<StabilizationEnum>()),
     _strain_at_nearest_qp(getParam<bool>("strain_at_nearest_qp"))
 {
   // convert vector of VariableName to vector of VariableName
   for (unsigned int i = 0; i < _ndisp; ++i)
     _coupled_displacements[i] = _displacements[i];
 }

Member Function Documentation

◆ act()

void PorousFlowActionBase::act ( )

overridevirtual

Implements Action.

Definition at line 133 of file PorousFlowActionBase.C.

 {
   // Check if the simulation is transient (note: can't do this in the ctor)
   _transient = _problem->isTransient();
 
   // Make sure that all mesh subdomains have the same coordinate system
   const auto & all_subdomains = _problem->mesh().meshSubdomains();
   if (all_subdomains.empty())
     mooseError("No subdomains found");
   _coord_system = _problem->getCoordSystem(*all_subdomains.begin());
   for (const auto & subdomain : all_subdomains)
     if (_problem->getCoordSystem(subdomain) != _coord_system)
       mooseError(
           "The PorousFlow Actions require all subdomains to have the same coordinate system.");
 
   // Note: this must be called before addMaterials!
   addMaterialDependencies();
 
   // Make the vector of added objects unique
   std::sort(_included_objects.begin(), _included_objects.end());
   _included_objects.erase(std::unique(_included_objects.begin(), _included_objects.end()),
                           _included_objects.end());
 
   if (_current_task == "add_user_object")
     addUserObjects();
 
   if (_current_task == "add_aux_variable" || _current_task == "add_aux_kernel")
     addAuxObjects();
 
   if (_current_task == "add_kernel")
     addKernels();
 
   if (_current_task == "add_material")
     addMaterials();
 }

◆ addAdvectiveFluxCalculatorSaturated()

void PorousFlowActionBase::addAdvectiveFluxCalculatorSaturated	(	unsigned	phase,
		bool	multiply_by_density,
		std::string	userobject_name
	)

protected

Definition at line 616 of file PorousFlowActionBase.C.

Referenced by PorousFlowFullySaturated::addUserObjects().

 {
   if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
   {
     const std::string userobject_type = "PorousFlowAdvectiveFluxCalculatorSaturated";
     InputParameters params = _factory.getValidParams(userobject_type);
     params.set<MooseEnum>("flux_limiter_type") = _flux_limiter_type;
     params.set<RealVectorValue>("gravity") = _gravity;
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<unsigned>("phase") = phase;
     params.set<bool>("multiply_by_density") = multiply_by_density;
     _problem->addUserObject(userobject_type, userobject_name, params);
   }
 }

◆ addAdvectiveFluxCalculatorSaturatedHeat()

void PorousFlowActionBase::addAdvectiveFluxCalculatorSaturatedHeat	(	unsigned	phase,
		bool	multiply_by_density,
		std::string	userobject_name
	)

protected

Definition at line 652 of file PorousFlowActionBase.C.

Referenced by PorousFlowFullySaturated::addUserObjects().

 {
   if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
   {
     const std::string userobject_type = "PorousFlowAdvectiveFluxCalculatorSaturatedHeat";
     InputParameters params = _factory.getValidParams(userobject_type);
     params.set<MooseEnum>("flux_limiter_type") = _flux_limiter_type;
     params.set<RealVectorValue>("gravity") = _gravity;
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<unsigned>("phase") = phase;
     params.set<bool>("multiply_by_density") = multiply_by_density;
     _problem->addUserObject(userobject_type, userobject_name, params);
   }
 }

◆ addAdvectiveFluxCalculatorSaturatedMultiComponent()

void PorousFlowActionBase::addAdvectiveFluxCalculatorSaturatedMultiComponent	(	unsigned	phase,
		unsigned	fluid_component,
		bool	multiply_by_density,
		std::string	userobject_name
	)

protected

Definition at line 688 of file PorousFlowActionBase.C.

Referenced by PorousFlowFullySaturated::addUserObjects().

 {
   if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
   {
     const std::string userobject_type = "PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent";
     InputParameters params = _factory.getValidParams(userobject_type);
     params.set<MooseEnum>("flux_limiter_type") = _flux_limiter_type;
     params.set<RealVectorValue>("gravity") = _gravity;
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<unsigned>("phase") = phase;
     params.set<bool>("multiply_by_density") = multiply_by_density;
     params.set<unsigned>("fluid_component") = fluid_component;
     _problem->addUserObject(userobject_type, userobject_name, params);
   }
 }

◆ addAdvectiveFluxCalculatorUnsaturated()

void PorousFlowActionBase::addAdvectiveFluxCalculatorUnsaturated	(	unsigned	phase,
		bool	multiply_by_density,
		std::string	userobject_name
	)

protected

Definition at line 634 of file PorousFlowActionBase.C.

Referenced by PorousFlowUnsaturated::addUserObjects().

 {
   if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
   {
     const std::string userobject_type = "PorousFlowAdvectiveFluxCalculatorUnsaturated";
     InputParameters params = _factory.getValidParams(userobject_type);
     params.set<MooseEnum>("flux_limiter_type") = _flux_limiter_type;
     params.set<RealVectorValue>("gravity") = _gravity;
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<unsigned>("phase") = phase;
     params.set<bool>("multiply_by_density") = multiply_by_density;
     _problem->addUserObject(userobject_type, userobject_name, params);
   }
 }

◆ addAdvectiveFluxCalculatorUnsaturatedHeat()

void PorousFlowActionBase::addAdvectiveFluxCalculatorUnsaturatedHeat	(	unsigned	phase,
		bool	multiply_by_density,
		std::string	userobject_name
	)

protected

Definition at line 670 of file PorousFlowActionBase.C.

Referenced by PorousFlowUnsaturated::addUserObjects().

 {
   if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
   {
     const std::string userobject_type = "PorousFlowAdvectiveFluxCalculatorUnsaturatedHeat";
     InputParameters params = _factory.getValidParams(userobject_type);
     params.set<MooseEnum>("flux_limiter_type") = _flux_limiter_type;
     params.set<RealVectorValue>("gravity") = _gravity;
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<unsigned>("phase") = phase;
     params.set<bool>("multiply_by_density") = multiply_by_density;
     _problem->addUserObject(userobject_type, userobject_name, params);
   }
 }

◆ addAdvectiveFluxCalculatorUnsaturatedMultiComponent()

void PorousFlowActionBase::addAdvectiveFluxCalculatorUnsaturatedMultiComponent	(	unsigned	phase,
		unsigned	fluid_component,
		bool	multiply_by_density,
		std::string	userobject_name
	)

protected

Definition at line 708 of file PorousFlowActionBase.C.

Referenced by PorousFlowUnsaturated::addUserObjects().

 {
   if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
   {
     const std::string userobject_type =
         "PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent";
     InputParameters params = _factory.getValidParams(userobject_type);
     params.set<MooseEnum>("flux_limiter_type") = _flux_limiter_type;
     params.set<RealVectorValue>("gravity") = _gravity;
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<unsigned>("phase") = phase;
     params.set<bool>("multiply_by_density") = multiply_by_density;
     params.set<unsigned>("fluid_component") = fluid_component;
     _problem->addUserObject(userobject_type, userobject_name, params);
   }
 }

◆ addAuxObjects()

void PorousFlowActionBase::addAuxObjects ( )

protectedvirtual

Add all AuxVariables and AuxKernels.

Reimplemented in PorousFlowUnsaturated, and PorousFlowSinglePhaseBase.

Definition at line 206 of file PorousFlowActionBase.C.

Referenced by act(), and PorousFlowSinglePhaseBase::addAuxObjects().

207 {

208 }

◆ addBrineMaterial()

void PorousFlowActionBase::addBrineMaterial	(	const VariableName	xnacl,
		bool	at_nodes,
		unsigned	phase,
		bool	compute_density_and_viscosity,
		bool	compute_internal_energy,
		bool	compute_enthalpy,
		const MooseEnum &	temperature_unit
	)

protected

Adds a brine fluid Material.

Parameters

xnacl	the variable containing the mass fraction of NaCl in the fluid
phase	the phase number of the fluid
compute_density_and_viscosity	compute the density and viscosity of the fluid
compute_internal_energy	compute the fluid internal energy
compute_enthalpy	compute the fluid enthalpy
at_nodes	add a nodal material
temperature_unit	the unit of temperature (Kelvin or Celsius)

Definition at line 504 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::addMaterials().

 {
   if (_current_task == "add_material")
   {
     std::string material_type = "PorousFlowBrine";
     InputParameters params = _factory.getValidParams(material_type);
 
     params.set<std::vector<VariableName>>("xnacl") = {nacl_brine};
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<unsigned int>("phase") = phase;
     params.set<bool>("compute_density_and_viscosity") = compute_density_and_viscosity;
     params.set<bool>("compute_internal_energy") = compute_internal_energy;
     params.set<bool>("compute_enthalpy") = compute_enthalpy;
     params.set<MooseEnum>("temperature_unit") = temperature_unit;
 
     std::string material_name = "PorousFlowActionBase_FluidProperties_qp";
     if (at_nodes)
       material_name = "PorousFlowActionBase_FluidProperties";
 
     params.set<bool>("at_nodes") = at_nodes;
     _problem->addMaterial(material_type, material_name, params);
   }
 }

◆ addCapillaryPressureVG()

void PorousFlowActionBase::addCapillaryPressureVG	(	Real	m,
		Real	alpha,
		std::string	userobject_name
	)

protected

Adds a van Genuchten capillary pressure UserObject.

Parameters

m	van Genuchten exponent
alpha	van Genuchten alpha
userobject_name	name of the user object

Definition at line 603 of file PorousFlowActionBase.C.

Referenced by PorousFlowUnsaturated::addUserObjects().

 {
   if (_current_task == "add_user_object")
   {
     std::string userobject_type = "PorousFlowCapillaryPressureVG";
     InputParameters params = _factory.getValidParams(userobject_type);
     params.set<Real>("m") = m;
     params.set<Real>("alpha") = alpha;
     _problem->addUserObject(userobject_type, userobject_name, params);
   }
 }

◆ addDarcyAux()

void PorousFlowActionBase::addDarcyAux ( const RealVectorValue & gravity )

protected

Add AuxVariables and AuxKernels to calculate Darcy velocity.

Parameters

gravity gravitational acceleration pointing downwards (eg (0, 0, -9.8))

Definition at line 248 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::addAuxObjects().

 {
   if (_current_task == "add_aux_variable")
   {
     auto var_params = _factory.getValidParams("MooseVariableConstMonomial");
 
     _problem->addAuxVariable("MooseVariableConstMonomial", "darcy_vel_x", var_params);
     _problem->addAuxVariable("MooseVariableConstMonomial", "darcy_vel_y", var_params);
     _problem->addAuxVariable("MooseVariableConstMonomial", "darcy_vel_z", var_params);
   }
 
   if (_current_task == "add_aux_kernel")
   {
     std::string aux_kernel_type = "PorousFlowDarcyVelocityComponent";
     InputParameters params = _factory.getValidParams(aux_kernel_type);
 
     params.set<RealVectorValue>("gravity") = gravity;
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
 
     std::string aux_kernel_name = "PorousFlowActionBase_Darcy_x_Aux";
     params.set<MooseEnum>("component") = "x";
     params.set<AuxVariableName>("variable") = "darcy_vel_x";
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
 
     aux_kernel_name = "PorousFlowActionBase_Darcy_y_Aux";
     params.set<MooseEnum>("component") = "y";
     params.set<AuxVariableName>("variable") = "darcy_vel_y";
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
 
     aux_kernel_name = "PorousFlowActionBase_Darcy_z_Aux";
     params.set<MooseEnum>("component") = "z";
     params.set<AuxVariableName>("variable") = "darcy_vel_z";
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
   }
 }

◆ addDictator()

virtual void PorousFlowActionBase::addDictator ( )

protectedpure virtual

Add the PorousFlowDictator object.

Implemented in PorousFlowSinglePhaseBase.

Referenced by addUserObjects().

◆ addEffectiveFluidPressureMaterial()

void PorousFlowActionBase::addEffectiveFluidPressureMaterial ( bool at_nodes )

protected

Adds a nodal and a quadpoint effective fluid pressure material.

Parameters

at_nodes Add nodal effective fluid pressure material

Definition at line 416 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::addMaterials().

 {
   if (_current_task == "add_material")
   {
     std::string material_type = "PorousFlowEffectiveFluidPressure";
     InputParameters params = _factory.getValidParams(material_type);
 
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
 
     std::string material_name = "PorousFlowUnsaturated_EffectiveFluidPressure_qp";
     if (at_nodes)
       material_name = "PorousFlowUnsaturated_EffectiveFluidPressure";
 
     params.set<bool>("at_nodes") = at_nodes;
     _problem->addMaterial(material_type, material_name, params);
   }
 }

◆ addKernels()

void PorousFlowActionBase::addKernels ( )

protectedvirtual

Add all Kernels.

Reimplemented in PorousFlowBasicTHM, PorousFlowUnsaturated, PorousFlowSinglePhaseBase, and PorousFlowFullySaturated.

Definition at line 211 of file PorousFlowActionBase.C.

Referenced by act(), and PorousFlowSinglePhaseBase::addKernels().

212 {

213 }

◆ addMassFractionMaterial()

void PorousFlowActionBase::addMassFractionMaterial ( bool at_nodes )

protected

Adds a nodal and a quadpoint MassFraction material.

Parameters

at_nodes Add nodal mass-fraction material

Definition at line 391 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::addMaterials().

 {
   if (_current_task == "add_material")
   {
     if (!(parameters().hasDefaultCoupledValue("mass_fraction_vars") ||
           parameters().hasCoupledValue("mass_fraction_vars")))
       mooseError("Attempt to add a PorousFlowMassFraction material without setting the "
                  "mass_fraction_vars");
 
     std::string material_type = "PorousFlowMassFraction";
     InputParameters params = _factory.getValidParams(material_type);
 
     params.applySpecificParameters(parameters(), {"mass_fraction_vars"});
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
 
     std::string material_name = "PorousFlowActionBase_MassFraction_qp";
     if (at_nodes)
       material_name = "PorousFlowActionBase_MassFraction";
 
     params.set<bool>("at_nodes") = at_nodes;
     _problem->addMaterial(material_type, material_name, params);
   }
 }

◆ addMaterialDependencies()

void PorousFlowActionBase::addMaterialDependencies ( )

protectedvirtual

Add all material dependencies so that the correct version of each material can be added.

Reimplemented in PorousFlowBasicTHM, PorousFlowUnsaturated, PorousFlowSinglePhaseBase, and PorousFlowFullySaturated.

Definition at line 170 of file PorousFlowActionBase.C.

Referenced by act(), and PorousFlowSinglePhaseBase::addMaterialDependencies().

 {
   if (_strain_at_nearest_qp)
     _included_objects.push_back("PorousFlowNearestQp");
 
   // Check to see if there are any other PorousFlow objects like BCs that
   // may require specific versions of materials added using this action
 
   // Unique list of auxkernels added in input file
   auto auxkernels = _awh.getActions<AddKernelAction>();
   for (auto & auxkernel : auxkernels)
     _included_objects.push_back(auxkernel->getMooseObjectType());
 
   // Unique list of postprocessors added in input file
   auto postprocessors = _awh.getActions<AddPostprocessorAction>();
   for (auto & postprocessor : postprocessors)
     _included_objects.push_back(postprocessor->getMooseObjectType());
 
   // Unique list of BCs added in input file
   auto bcs = _awh.getActions<AddBCAction>();
   for (auto & bc : bcs)
     _included_objects.push_back(bc->getMooseObjectType());
 
   // Unique list of Dirac kernels added in input file
   auto diracs = _awh.getActions<AddDiracKernelAction>();
   for (auto & dirac : diracs)
     _included_objects.push_back(dirac->getMooseObjectType());
 }

◆ addMaterials()

void PorousFlowActionBase::addMaterials ( )

protectedvirtual

Add all Materials.

Reimplemented in PorousFlowBasicTHM, PorousFlowUnsaturated, PorousFlowSinglePhaseBase, and PorousFlowFullySaturated.

Definition at line 216 of file PorousFlowActionBase.C.

Referenced by act(), and PorousFlowSinglePhaseBase::addMaterials().

 {
   if (_strain_at_nearest_qp && _deps.dependsOn(_included_objects, "nearest_qp_nodal"))
     addNearestQpMaterial();
 }

◆ addNearestQpMaterial()

void PorousFlowActionBase::addNearestQpMaterial ( )

protected

Adds a PorousFlowNearestQp material.

Definition at line 435 of file PorousFlowActionBase.C.

Referenced by addMaterials().

 {
   if (_current_task == "add_material")
   {
     std::string material_type = "PorousFlowNearestQp";
     InputParameters params = _factory.getValidParams(material_type);
 
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<bool>("nodal_material") = true;
 
     std::string material_name = "PorousFlowActionBase_NearestQp";
     _problem->addMaterial(material_type, material_name, params);
   }
 }

◆ addRelationshipManagers() [1/3]

virtual void Action::addRelationshipManagers

◆ addRelationshipManagers() [2/3]

bool Action::addRelationshipManagers

◆ addRelationshipManagers() [3/3]

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

overridevirtual

Reimplemented from Action.

Definition at line 124 of file PorousFlowActionBase.C.

 {
   InputParameters ips = (_stabilization == StabilizationEnum::KT
                              ? _factory.getValidParams("PorousFlowAdvectiveFluxCalculatorSaturated")
                              : emptyInputParameters());
   addRelationshipManagers(input_rm_type, ips);
 }

◆ addRelativePermeabilityConst()

void PorousFlowActionBase::addRelativePermeabilityConst	(	bool	at_nodes,
		unsigned	phase,
		Real	kr
	)

protected

Adds a relative-permeability Material of the constant variety (primarily to add kr = 1 in actions that add a default relatively permeability for objects that require kr even when the flow is fully saturated with a single phase)

Parameters

at_nodes	whether the material is nodal
phase	the phase number of the fluid
kr	the relative permeability

Definition at line 535 of file PorousFlowActionBase.C.

Referenced by PorousFlowFullySaturated::addMaterials(), and PorousFlowBasicTHM::addMaterials().

 {
   if (_current_task == "add_material")
   {
     std::string material_type = "PorousFlowRelativePermeabilityConst";
     InputParameters params = _factory.getValidParams(material_type);
 
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<unsigned int>("phase") = phase;
     params.set<Real>("kr") = kr;
     std::string material_name = "PorousFlowActionBase_RelativePermeability_qp";
     if (at_nodes)
       material_name = "PorousFlowActionBase_RelativePermeability_nodal";
 
     params.set<bool>("at_nodes") = at_nodes;
     _problem->addMaterial(material_type, material_name, params);
   }
 }

◆ addRelativePermeabilityCorey()

void PorousFlowActionBase::addRelativePermeabilityCorey	(	bool	at_nodes,
		unsigned	phase,
		Real	n,
		Real	s_res,
		Real	sum_s_res
	)

protected

Adds a relative-permeability Material of the Corey variety.

Parameters

at_nodes	whether the material is nodal
phase	the phase number of the fluid
n	The Corey exponent
s_res	The residual saturation for this phase
sum_s_res	The sum of residual saturations over all phases

Definition at line 555 of file PorousFlowActionBase.C.

Referenced by PorousFlowUnsaturated::addMaterials().

 {
   if (_current_task == "add_material")
   {
     std::string material_type = "PorousFlowRelativePermeabilityCorey";
     InputParameters params = _factory.getValidParams(material_type);
 
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<Real>("n") = n;
     params.set<unsigned int>("phase") = phase;
     params.set<Real>("s_res") = s_res;
     params.set<Real>("sum_s_res") = sum_s_res;
 
     std::string material_name = "PorousFlowActionBase_RelativePermeability_qp";
     if (at_nodes)
       material_name = "PorousFlowActionBase_RelativePermeability_nodal";
 
     params.set<bool>("at_nodes") = at_nodes;
     _problem->addMaterial(material_type, material_name, params);
   }
 }

◆ addRelativePermeabilityFLAC()

void PorousFlowActionBase::addRelativePermeabilityFLAC	(	bool	at_nodes,
		unsigned	phase,
		Real	m,
		Real	s_res,
		Real	sum_s_res
	)

protected

Adds a relative-permeability Material of the FLAC variety.

Parameters

at_nodes	whether the material is nodal
phase	the phase number of the fluid
m	The FLAC exponent
s_res	The residual saturation for this phase
sum_s_res	The sum of residual saturations over all phases

Definition at line 579 of file PorousFlowActionBase.C.

Referenced by PorousFlowUnsaturated::addMaterials().

 {
   if (_current_task == "add_material")
   {
     std::string material_type = "PorousFlowRelativePermeabilityFLAC";
     InputParameters params = _factory.getValidParams(material_type);
 
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<Real>("m") = m;
     params.set<unsigned int>("phase") = phase;
     params.set<Real>("s_res") = s_res;
     params.set<Real>("sum_s_res") = sum_s_res;
 
     std::string material_name = "PorousFlowActionBase_RelativePermeability_qp";
     if (at_nodes)
       material_name = "PorousFlowActionBase_RelativePermeability_nodal";
 
     params.set<bool>("at_nodes") = at_nodes;
     _problem->addMaterial(material_type, material_name, params);
   }
 }

◆ addSaturationAux()

void PorousFlowActionBase::addSaturationAux ( unsigned phase )

protected

Add an AuxVariable and AuxKernel to calculate saturation.

Parameters

phase Saturation for this fluid phase

Definition at line 223 of file PorousFlowActionBase.C.

Referenced by PorousFlowUnsaturated::addAuxObjects().

 {
   std::string phase_str = Moose::stringify(phase);
 
   if (_current_task == "add_aux_variable")
   {
     auto var_params = _factory.getValidParams("MooseVariableConstMonomial");
     _problem->addAuxVariable("MooseVariableConstMonomial", "saturation" + phase_str, var_params);
   }
 
   if (_current_task == "add_aux_kernel")
   {
     std::string aux_kernel_type = "MaterialStdVectorAux";
     InputParameters params = _factory.getValidParams(aux_kernel_type);
 
     std::string aux_kernel_name = "PorousFlowActionBase_SaturationAux" + phase_str;
     params.set<MaterialPropertyName>("property") = "PorousFlow_saturation_qp";
     params.set<unsigned>("index") = phase;
     params.set<AuxVariableName>("variable") = "saturation" + phase_str;
     params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
   }
 }

◆ addSingleComponentFluidMaterial()

void PorousFlowActionBase::addSingleComponentFluidMaterial	(	bool	at_nodes,
		unsigned	phase,
		bool	compute_density_and_viscosity,
		bool	compute_internal_energy,
		bool	compute_enthalpy,
		const UserObjectName &	fp,
		const MooseEnum &	temperature_unit,
		const MooseEnum &	pressure_unit,
		const MooseEnum &	time_unit
	)

protected

Adds a single-component fluid Material.

Parameters

phase	the phase number of the fluid
fp	the name of the FluidProperties UserObject
compute_density_and_viscosity	compute the density and viscosity of the fluid
compute_internal_energy	compute the fluid internal energy
compute_enthalpy	compute the fluid enthalpy
at_nodes	add a nodal material
temperature_unit	the unit of temperature (Kelvin or Celsius)
pressure_unit	the unit of pressure (MPa or Pa)
time_unit	the unit of time (seconds, days, hours, etc)

Definition at line 469 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::addMaterials().

 {
   if (_current_task == "add_material")
   {
     std::string material_type = "PorousFlowSingleComponentFluid";
     InputParameters params = _factory.getValidParams(material_type);
 
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<unsigned int>("phase") = phase;
     params.set<bool>("compute_density_and_viscosity") = compute_density_and_viscosity;
     params.set<bool>("compute_internal_energy") = compute_internal_energy;
     params.set<bool>("compute_enthalpy") = compute_enthalpy;
     params.set<UserObjectName>("fp") = fp;
     params.set<MooseEnum>("temperature_unit") = temperature_unit;
     params.set<MooseEnum>("pressure_unit") = pressure_unit;
     params.set<MooseEnum>("time_unit") = time_unit;
 
     std::string material_name = "PorousFlowActionBase_FluidProperties_qp";
     if (at_nodes)
       material_name = "PorousFlowActionBase_FluidProperties";
 
     params.set<bool>("at_nodes") = at_nodes;
     _problem->addMaterial(material_type, material_name, params);
   }
 }

◆ addStressAux()

void PorousFlowActionBase::addStressAux ( )

protected

Add AuxVariables and AuxKernels to compute effective stress.

Definition at line 286 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::addAuxObjects().

 {
   if (_current_task == "add_aux_variable")
   {
     auto var_params = _factory.getValidParams("MooseVariableConstMonomial");
     _problem->addAuxVariable("MooseVariableConstMonomial", "stress_xx", var_params);
     _problem->addAuxVariable("MooseVariableConstMonomial", "stress_xy", var_params);
     _problem->addAuxVariable("MooseVariableConstMonomial", "stress_xz", var_params);
     _problem->addAuxVariable("MooseVariableConstMonomial", "stress_yx", var_params);
     _problem->addAuxVariable("MooseVariableConstMonomial", "stress_yy", var_params);
     _problem->addAuxVariable("MooseVariableConstMonomial", "stress_yz", var_params);
     _problem->addAuxVariable("MooseVariableConstMonomial", "stress_zx", var_params);
     _problem->addAuxVariable("MooseVariableConstMonomial", "stress_zy", var_params);
     _problem->addAuxVariable("MooseVariableConstMonomial", "stress_zz", var_params);
   }
 
   if (_current_task == "add_aux_kernel")
   {
     std::string aux_kernel_type = "RankTwoAux";
     InputParameters params = _factory.getValidParams(aux_kernel_type);
 
     params.set<MaterialPropertyName>("rank_two_tensor") = "stress";
     params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
 
     std::string aux_kernel_name = "PorousFlowAction_stress_xx";
     params.set<AuxVariableName>("variable") = "stress_xx";
     params.set<unsigned>("index_i") = 0;
     params.set<unsigned>("index_j") = 0;
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
 
     aux_kernel_name = "PorousFlowAction_stress_xy";
     params.set<AuxVariableName>("variable") = "stress_xy";
     params.set<unsigned>("index_i") = 0;
     params.set<unsigned>("index_j") = 1;
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
 
     aux_kernel_name = "PorousFlowAction_stress_xz";
     params.set<AuxVariableName>("variable") = "stress_xz";
     params.set<unsigned>("index_i") = 0;
     params.set<unsigned>("index_j") = 2;
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
 
     aux_kernel_name = "PorousFlowAction_stress_yx";
     params.set<AuxVariableName>("variable") = "stress_yx";
     params.set<unsigned>("index_i") = 1;
     params.set<unsigned>("index_j") = 0;
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
 
     aux_kernel_name = "PorousFlowAction_stress_yy";
     params.set<AuxVariableName>("variable") = "stress_yy";
     params.set<unsigned>("index_i") = 1;
     params.set<unsigned>("index_j") = 1;
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
 
     aux_kernel_name = "PorousFlowAction_stress_yz";
     params.set<AuxVariableName>("variable") = "stress_yz";
     params.set<unsigned>("index_i") = 1;
     params.set<unsigned>("index_j") = 2;
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
 
     aux_kernel_name = "PorousFlowAction_stress_zx";
     params.set<AuxVariableName>("variable") = "stress_zx";
     params.set<unsigned>("index_i") = 2;
     params.set<unsigned>("index_j") = 0;
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
 
     aux_kernel_name = "PorousFlowAction_stress_zy";
     params.set<AuxVariableName>("variable") = "stress_zy";
     params.set<unsigned>("index_i") = 2;
     params.set<unsigned>("index_j") = 1;
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
 
     aux_kernel_name = "PorousFlowAction_stress_zz";
     params.set<AuxVariableName>("variable") = "stress_zz";
     params.set<unsigned>("index_i") = 2;
     params.set<unsigned>("index_j") = 2;
     _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
   }
 }

◆ addTemperatureMaterial()

void PorousFlowActionBase::addTemperatureMaterial ( bool at_nodes )

protected

Adds a nodal and a quadpoint Temperature material.

Parameters

at_nodes Add nodal temperature Material

Definition at line 367 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::addMaterials().

 {
   if (_current_task == "add_material")
   {
     if (!parameters().hasDefaultCoupledValue("temperature"))
       mooseError("Attempt to add a PorousFlowTemperature material without setting a temperature "
                  "variable");
 
     std::string material_type = "PorousFlowTemperature";
     InputParameters params = _factory.getValidParams(material_type);
 
     params.applySpecificParameters(parameters(), {"temperature"});
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
 
     std::string material_name = "PorousFlowActionBase_Temperature_qp";
     if (at_nodes)
       material_name = "PorousFlowActionBase_Temperature";
 
     params.set<bool>("at_nodes") = at_nodes;
     _problem->addMaterial(material_type, material_name, params);
   }
 }

◆ addUserObjects()

void PorousFlowActionBase::addUserObjects ( )

protectedvirtual

Add all other UserObjects.

Reimplemented in PorousFlowUnsaturated, and PorousFlowFullySaturated.

Definition at line 200 of file PorousFlowActionBase.C.

Referenced by act(), PorousFlowFullySaturated::addUserObjects(), and PorousFlowUnsaturated::addUserObjects().

 {
   addDictator();
 }

◆ addVolumetricStrainMaterial()

void PorousFlowActionBase::addVolumetricStrainMaterial	(	const std::vector< VariableName > &	displacements,
		const std::string &	base_name
	)

protected

Adds a quadpoint volumetric strain material.

Parameters

displacements	the names of the displacement variables
base_name	The base_name used in the TensorMechanics strain calculator displaced mesh

Definition at line 451 of file PorousFlowActionBase.C.

Referenced by PorousFlowFullySaturated::addMaterials(), PorousFlowUnsaturated::addMaterials(), and PorousFlowBasicTHM::addMaterials().

 {
   if (_current_task == "add_material")
   {
     std::string material_type = "PorousFlowVolumetricStrain";
     InputParameters params = _factory.getValidParams(material_type);
 
     std::string material_name = "PorousFlowActionBase_VolumetricStrain";
     params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
     params.set<std::vector<VariableName>>("displacements") = displacements;
     if (!base_name.empty())
       params.set<std::string>("base_name") = base_name;
     _problem->addMaterial(material_type, material_name, params);
   }
 }

◆ validParams()

InputParameters PorousFlowActionBase::validParams ( )

static

Definition at line 22 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::validParams().

 {
   InputParameters params = Action::validParams();
   params.addParam<std::string>(
       "dictator_name",
       "dictator",
       "The name of the dictator user object that is created by this Action");
   params.addClassDescription("Adds the PorousFlowDictator UserObject.  This class also contains "
                              "many utility functions for adding other pieces of an input file, "
                              "which may be used by derived classes.");
   params.addParam<RealVectorValue>("gravity",
                                    RealVectorValue(0.0, 0.0, -10.0),
                                    "Gravitational acceleration vector downwards (m/s^2)");
   params.addCoupledVar("temperature",
                        293.0,
                        "For isothermal simulations, this is the temperature "
                        "at which fluid properties (and stress-free strains) "
                        "are evaluated at.  Otherwise, this is the name of "
                        "the temperature variable.  Units = Kelvin");
   params.addCoupledVar("mass_fraction_vars",
                        "List of variables that represent the mass fractions.  Format is 'f_ph0^c0 "
                        "f_ph0^c1 f_ph0^c2 ... f_ph0^c(N-1) f_ph1^c0 f_ph1^c1 fph1^c2 ... "
                        "fph1^c(N-1) ... fphP^c0 f_phP^c1 fphP^c2 ... fphP^c(N-1)' where "
                        "N=num_components and P=num_phases, and it is assumed that "
                        "f_ph^cN=1-sum(f_ph^c,{c,0,N-1}) so that f_ph^cN need not be given.  If no "
                        "variables are provided then num_phases=1=num_components.");
   params.addParam<unsigned int>("number_aqueous_equilibrium",
                                 0,
                                 "The number of secondary species in the aqueous-equilibrium "
                                 "reaction system.  (Leave as zero if the simulation does not "
                                 "involve chemistry)");
   params.addParam<unsigned int>("number_aqueous_kinetic",
                                 0,
                                 "The number of secondary species in the aqueous-kinetic reaction "
                                 "system involved in precipitation and dissolution.  (Leave as zero "
                                 "if the simulation does not involve chemistry)");
   params.addParam<std::vector<VariableName>>(
       "displacements",
       {},
       "The name of the displacement variables (relevant only for "
       "mechanically-coupled simulations)");
   params.addParam<std::vector<MaterialPropertyName>>(
       "eigenstrain_names",
       {},
       "List of all eigenstrain models used in mechanics calculations. "
       "Typically the eigenstrain_name used in "
       "ComputeThermalExpansionEigenstrain.  Only needed for "
       "thermally-coupled simulations with thermal expansion.");
   params.addParam<bool>(
       "use_displaced_mesh", false, "Use displaced mesh computations in mechanical kernels");
   MooseEnum flux_limiter_type("MinMod VanLeer MC superbee None", "VanLeer");
   params.addParam<MooseEnum>(
       "flux_limiter_type",
       flux_limiter_type,
       "Type of flux limiter to use if stabilization=KT.  'None' means that no antidiffusion "
       "will be added in the Kuzmin-Turek scheme");
   MooseEnum stabilization("None Full KT", "Full");
   params.addParam<MooseEnum>("stabilization",
                              stabilization,
                              "Numerical stabilization used.  'Full' means full upwinding.  'KT' "
                              "means FEM-TVD stabilization of Kuzmin-Turek");
   params.addParam<bool>(
       "strain_at_nearest_qp",
       false,
       "Only relevant for models in which porosity depends on strain.  If true, then when "
       "calculating nodal porosity that depends on strain, the strain at the nearest quadpoint will "
       "be used.  This adds a small extra computational burden, and is only necessary for "
       "simulations involving: (1) elements that are not linear lagrange or (2) certain PorousFlow "
       "Dirac Kernels (as specified in their documentation).  If you set this to true, you will "
       "also want to set the same parameter to true for related Kernels and Materials (which is "
       "probably easiest to do in the GlobalParams block)");
   return params;
 }

Member Data Documentation

◆ _coord_system

Moose::CoordinateSystemType PorousFlowActionBase::_coord_system

protected

Coordinate system of the simulation (eg RZ, XYZ, etc)

Definition at line 89 of file PorousFlowActionBase.h.

Referenced by act(), and PorousFlowSinglePhaseBase::addKernels().

◆ _coupled_displacements

std::vector<VariableName> PorousFlowActionBase::_coupled_displacements

protected

Displacement Variable names.

Definition at line 78 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addDictator(), PorousFlowSinglePhaseBase::addKernels(), PorousFlowFullySaturated::addMaterials(), PorousFlowBasicTHM::addMaterials(), and PorousFlowUnsaturated::addMaterials().

◆ _deps

DependencyResolver<std::string> PorousFlowDependencies::_deps

protectedinherited

All dependencies of kernels, auxkernels, materials, etc, are stored in _dependencies.

Definition at line 37 of file PorousFlowDependencies.h.

Referenced by PorousFlowFullySaturated::addMaterials(), PorousFlowSinglePhaseBase::addMaterials(), PorousFlowBasicTHM::addMaterials(), PorousFlowUnsaturated::addMaterials(), addMaterials(), PorousFlowAddMaterialAction::isPFMaterialRequired(), and PorousFlowDependencies::PorousFlowDependencies().

◆ _dictator_name

const std::string PorousFlowActionBase::_dictator_name

protected

The name of the PorousFlowDictator object to be added.

Definition at line 51 of file PorousFlowActionBase.h.

Referenced by addAdvectiveFluxCalculatorSaturated(), addAdvectiveFluxCalculatorSaturatedHeat(), addAdvectiveFluxCalculatorSaturatedMultiComponent(), addAdvectiveFluxCalculatorUnsaturated(), addAdvectiveFluxCalculatorUnsaturatedHeat(), addAdvectiveFluxCalculatorUnsaturatedMultiComponent(), addBrineMaterial(), addDarcyAux(), PorousFlowSinglePhaseBase::addDictator(), addEffectiveFluidPressureMaterial(), PorousFlowFullySaturated::addKernels(), PorousFlowSinglePhaseBase::addKernels(), PorousFlowUnsaturated::addKernels(), PorousFlowBasicTHM::addKernels(), addMassFractionMaterial(), PorousFlowFullySaturated::addMaterials(), PorousFlowBasicTHM::addMaterials(), PorousFlowUnsaturated::addMaterials(), addNearestQpMaterial(), addRelativePermeabilityConst(), addRelativePermeabilityCorey(), addRelativePermeabilityFLAC(), addSingleComponentFluidMaterial(), addTemperatureMaterial(), and addVolumetricStrainMaterial().

◆ _displacements

const std::vector<VariableName>& PorousFlowActionBase::_displacements

protected

Displacement NonlinearVariable names (if any)

Definition at line 72 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addKernels().

◆ _flux_limiter_type

const MooseEnum PorousFlowActionBase::_flux_limiter_type

protected

Flux limiter type in the Kuzmin-Turek FEM-TVD stabilization scheme.

Definition at line 81 of file PorousFlowActionBase.h.

Referenced by addAdvectiveFluxCalculatorSaturated(), addAdvectiveFluxCalculatorSaturatedHeat(), addAdvectiveFluxCalculatorSaturatedMultiComponent(), addAdvectiveFluxCalculatorUnsaturated(), addAdvectiveFluxCalculatorUnsaturatedHeat(), and addAdvectiveFluxCalculatorUnsaturatedMultiComponent().

◆ _gravity

const RealVectorValue PorousFlowActionBase::_gravity

protected

Gravity.

Definition at line 60 of file PorousFlowActionBase.h.

Referenced by addAdvectiveFluxCalculatorSaturated(), addAdvectiveFluxCalculatorSaturatedHeat(), addAdvectiveFluxCalculatorSaturatedMultiComponent(), addAdvectiveFluxCalculatorUnsaturated(), addAdvectiveFluxCalculatorUnsaturatedHeat(), addAdvectiveFluxCalculatorUnsaturatedMultiComponent(), PorousFlowSinglePhaseBase::addAuxObjects(), PorousFlowFullySaturated::addKernels(), PorousFlowSinglePhaseBase::addKernels(), PorousFlowUnsaturated::addKernels(), and PorousFlowBasicTHM::addKernels().

◆ _included_objects

std::vector<std::string> PorousFlowActionBase::_included_objects

protected

List of Kernels, AuxKernels, Materials, etc, that are added in this input file.

This list will be used to determine what Materials need to be added. Actions may add or remove things from this list

Definition at line 48 of file PorousFlowActionBase.h.

Referenced by act(), PorousFlowFullySaturated::addMaterialDependencies(), PorousFlowSinglePhaseBase::addMaterialDependencies(), PorousFlowBasicTHM::addMaterialDependencies(), PorousFlowUnsaturated::addMaterialDependencies(), addMaterialDependencies(), PorousFlowFullySaturated::addMaterials(), PorousFlowSinglePhaseBase::addMaterials(), PorousFlowBasicTHM::addMaterials(), PorousFlowUnsaturated::addMaterials(), and addMaterials().

◆ _mass_fraction_vars

const std::vector<VariableName> PorousFlowActionBase::_mass_fraction_vars

protected

Name of the mass-fraction variables (if any)

Definition at line 63 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addDictator(), PorousFlowFullySaturated::addKernels(), and PorousFlowUnsaturated::addKernels().

◆ _ndisp

const unsigned PorousFlowActionBase::_ndisp

protected

Number of displacement variables supplied.

Definition at line 75 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addKernels().

◆ _num_aqueous_equilibrium

const unsigned int PorousFlowActionBase::_num_aqueous_equilibrium

protected

Number of aqueous-equilibrium secondary species.

Definition at line 54 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addDictator().

◆ _num_aqueous_kinetic

const unsigned int PorousFlowActionBase::_num_aqueous_kinetic

protected

Number of aqeuous-kinetic secondary species that are involved in mineralisation.

Definition at line 57 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addDictator().

◆ _num_mass_fraction_vars

const unsigned PorousFlowActionBase::_num_mass_fraction_vars

protected

Number of mass-fraction variables.

Definition at line 66 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addDictator(), PorousFlowFullySaturated::addKernels(), PorousFlowUnsaturated::addKernels(), PorousFlowFullySaturated::addUserObjects(), PorousFlowUnsaturated::addUserObjects(), PorousFlowBasicTHM::PorousFlowBasicTHM(), and PorousFlowSinglePhaseBase::PorousFlowSinglePhaseBase().

◆ _stabilization

enum PorousFlowActionBase::StabilizationEnum PorousFlowActionBase::_stabilization

protected

Referenced by addAdvectiveFluxCalculatorSaturated(), addAdvectiveFluxCalculatorSaturatedHeat(), addAdvectiveFluxCalculatorSaturatedMultiComponent(), addAdvectiveFluxCalculatorUnsaturated(), addAdvectiveFluxCalculatorUnsaturatedHeat(), addAdvectiveFluxCalculatorUnsaturatedMultiComponent(), PorousFlowFullySaturated::addKernels(), PorousFlowUnsaturated::addKernels(), PorousFlowFullySaturated::addMaterialDependencies(), PorousFlowUnsaturated::addMaterialDependencies(), addRelationshipManagers(), PorousFlowFullySaturated::addUserObjects(), PorousFlowUnsaturated::addUserObjects(), and PorousFlowUnsaturated::PorousFlowUnsaturated().

◆ _strain_at_nearest_qp

const bool PorousFlowActionBase::_strain_at_nearest_qp

protected

Evaluate strain at the nearest quadpoint for porosity that depends on strain.

Definition at line 86 of file PorousFlowActionBase.h.

Referenced by PorousFlowFullySaturated::addKernels(), PorousFlowSinglePhaseBase::addKernels(), PorousFlowUnsaturated::addKernels(), addMaterialDependencies(), and addMaterials().

◆ _temperature_var

const std::vector<VariableName> PorousFlowActionBase::_temperature_var

protected

Name of the temperature variable (if any)

Definition at line 69 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addDictator(), PorousFlowFullySaturated::addKernels(), PorousFlowSinglePhaseBase::addKernels(), PorousFlowUnsaturated::addKernels(), PorousFlowBasicTHM::addKernels(), and PorousFlowSinglePhaseBase::PorousFlowSinglePhaseBase().

◆ _transient

bool PorousFlowActionBase::_transient

protected

Flag to denote if the simulation is transient.

Definition at line 92 of file PorousFlowActionBase.h.

Referenced by act(), PorousFlowFullySaturated::addKernels(), PorousFlowSinglePhaseBase::addKernels(), PorousFlowUnsaturated::addKernels(), PorousFlowBasicTHM::addKernels(), PorousFlowFullySaturated::addMaterialDependencies(), PorousFlowSinglePhaseBase::addMaterialDependencies(), PorousFlowBasicTHM::addMaterialDependencies(), and PorousFlowUnsaturated::addMaterialDependencies().

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

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ StabilizationEnum

Constructor & Destructor Documentation

◆ PorousFlowActionBase()

Member Function Documentation

◆ act()

◆ addAdvectiveFluxCalculatorSaturated()

◆ addAdvectiveFluxCalculatorSaturatedHeat()

◆ addAdvectiveFluxCalculatorSaturatedMultiComponent()

◆ addAdvectiveFluxCalculatorUnsaturated()

◆ addAdvectiveFluxCalculatorUnsaturatedHeat()

◆ addAdvectiveFluxCalculatorUnsaturatedMultiComponent()

◆ addAuxObjects()

◆ addBrineMaterial()

◆ addCapillaryPressureVG()

◆ addDarcyAux()

◆ addDictator()

◆ addEffectiveFluidPressureMaterial()

◆ addKernels()

◆ addMassFractionMaterial()

◆ addMaterialDependencies()

◆ addMaterials()

◆ addNearestQpMaterial()

◆ addRelationshipManagers() [1/3]

◆ addRelationshipManagers() [2/3]

◆ addRelationshipManagers() [3/3]

◆ addRelativePermeabilityConst()

◆ addRelativePermeabilityCorey()

◆ addRelativePermeabilityFLAC()

◆ addSaturationAux()

◆ addSingleComponentFluidMaterial()

◆ addStressAux()

◆ addTemperatureMaterial()

◆ addUserObjects()

◆ addVolumetricStrainMaterial()

◆ validParams()

Member Data Documentation

◆ _coord_system

◆ _coupled_displacements

◆ _deps

◆ _dictator_name

◆ _displacements

◆ _flux_limiter_type

◆ _gravity

◆ _included_objects

◆ _mass_fraction_vars

◆ _ndisp

◆ _num_aqueous_equilibrium

◆ _num_aqueous_kinetic

◆ _num_mass_fraction_vars

◆ _stabilization

◆ _strain_at_nearest_qp

◆ _temperature_var

◆ _transient