Action for simulation involving a single phase, partially or fully saturated fluid. More...

#include <PorousFlowUnsaturated.h>

Inheritance diagram for PorousFlowUnsaturated:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PorousFlowUnsaturated (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

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PerfGraph &	perfGraph ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

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

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	unique_action_name_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Types
enum class	RelpermTypeChoiceEnum { FLAC , COREY }
	Fluid relative permeability type (FLAC or Corey) More...

enum class	CouplingTypeEnum { Hydro , ThermoHydro , HydroMechanical , ThermoHydroMechanical }
	Determines the coupling type. More...

enum class	FluidPropertiesTypeEnum { PorousFlowSingleComponentFluid , PorousFlowBrine , Custom }
	Determines the fluid-properties type. More...

enum class	StabilizationEnum { None , Full , KT }

Protected Member Functions
virtual void	addKernels () override
	Add all Kernels.

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

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

virtual void	addMaterials () override
	Add all Materials.

virtual void	addUserObjects () override
	Add all other UserObjects.

virtual void	addDictator () override
	Add the PorousFlowDictator object.

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

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

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

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

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

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

void	addNearestQpMaterial ()
	Adds a PorousFlowNearestQp material.

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

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.

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.

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)

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.

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.

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

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

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

Protected Attributes
const bool	_add_saturation_aux
	Add an Aux Variable to record saturation.

const Real	_van_genuchten_alpha
	Van Genuchten alpha parameter.

const Real	_van_genuchten_m
	Van Genuchten m parameter.

enum PorousFlowUnsaturated::RelpermTypeChoiceEnum	_relperm_type

const Real	_relative_permeability_exponent
	Relative permeability exponent.

const Real	_s_res
	Residual saturation to use in the relative permeability expressions.

const std::string	_capillary_pressure_name
	Name of the capillary pressure UserObject.

const VariableName	_pp_var
	Porepressure NonlinearVariable name.

enum PorousFlowSinglePhaseBase::CouplingTypeEnum	_coupling_type

const bool	_thermal
	Flags to indicate whether thermal or mechanical effects are included.

const bool	_mechanical

enum PorousFlowSinglePhaseBase::FluidPropertiesTypeEnum	_fluid_properties_type

UserObjectName	_fp
	Name of the fluid-properties UserObject.

const Real	_biot_coefficient
	Fluid specific heat capacity at constant volume.

const bool	_add_darcy_aux
	Add a AuxVariables to record Darcy velocity.

const bool	_add_stress_aux
	Add AuxVariables for stress.

VariableName	_nacl_name
	Name of the NaCl variable.

const std::vector< AuxVariableName >	_save_component_rate_in
	Name of the variables (if any) that will record the fluid-components' rate of change.

const MooseEnum	_temperature_unit
	Unit used for temperature.

const MooseEnum	_pressure_unit
	Unit used for porepressure.

const MooseEnum	_time_unit
	Unit used for time.

const std::string	_base_name
	base_name used in the TensorMechanics strain calculator

std::vector< std::string >	_included_objects
	List of Kernels, AuxKernels, Materials, etc, that are added in this input file.

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

std::vector< SubdomainName >	_subdomain_names
	if this vector is not empty the variables, kernels and materials are restricted to these subdomains

const bool	_subdomain_names_set
	indicates, if the vector of subdomain names is set (dont set block restrictions, if not)

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

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

const RealVectorValue	_gravity
	Gravity.

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

const unsigned	_num_mass_fraction_vars
	Number of mass-fraction variables.

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

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

const unsigned	_ndisp
	Number of displacement variables supplied.

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

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

enum PorousFlowActionBase::StabilizationEnum	_stabilization

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

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

bool	_transient
	Flag to denote if the simulation is transient.

std::string	_registered_identifier

std::string	_specific_task_name

std::set< std::string >	_all_tasks

ActionWarehouse &	_awh

const std::string &	_current_task

std::shared_ptr< MooseMesh > &	_mesh

std::shared_ptr< MooseMesh > &	_displaced_mesh

std::shared_ptr< FEProblemBase > &	_problem

PerfID	_act_timer

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

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

Private Member Functions
bool	addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)

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

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

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

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

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

Private Attributes
const ParallelParamObject &	_parent

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

Detailed Description

Action for simulation involving a single phase, partially or fully saturated fluid.

The fluid's saturation is found using the van Genuchten expression, and the relative permeability is found using the FLAC or Corey expression.

Definition at line 19 of file PorousFlowUnsaturated.h.

Member Enumeration Documentation

◆ CouplingTypeEnum

enum class PorousFlowSinglePhaseBase::CouplingTypeEnum

strongprotectedinherited

Determines the coupling type.

Enumerator
Hydro
ThermoHydro
HydroMechanical
ThermoHydroMechanical

Definition at line 35 of file PorousFlowSinglePhaseBase.h.

                                    {
    Hydro,
    ThermoHydro,
    HydroMechanical,
    ThermoHydroMechanical
  } _coupling_type;

◆ FluidPropertiesTypeEnum

enum class PorousFlowSinglePhaseBase::FluidPropertiesTypeEnum

strongprotectedinherited

Determines the fluid-properties type.

Enumerator
PorousFlowSingleComponentFluid
PorousFlowBrine
Custom

Definition at line 47 of file PorousFlowSinglePhaseBase.h.

                                           {
    PorousFlowSingleComponentFluid,
    PorousFlowBrine,
    Custom
  } _fluid_properties_type;

◆ RelpermTypeChoiceEnum

enum class PorousFlowUnsaturated::RelpermTypeChoiceEnum

strongprotected

Fluid relative permeability type (FLAC or Corey)

Enumerator
FLAC
COREY

Definition at line 43 of file PorousFlowUnsaturated.h.

43{ FLAC, COREY } _relperm_type;

PorousFlowUnsaturated::_relperm_type

enum PorousFlowUnsaturated::RelpermTypeChoiceEnum _relperm_type

PorousFlowUnsaturated::RelpermTypeChoiceEnum::FLAC

@ FLAC

PorousFlowUnsaturated::RelpermTypeChoiceEnum::COREY

@ COREY

◆ StabilizationEnum

enum class PorousFlowActionBase::StabilizationEnum

strongprotectedinherited

Enumerator
None
Full
KT

Definition at line 89 of file PorousFlowActionBase.h.

89{ None, Full, KT } _stabilization;

PorousFlowActionBase::_stabilization

enum PorousFlowActionBase::StabilizationEnum _stabilization

PorousFlowActionBase::StabilizationEnum::None

@ None

PorousFlowActionBase::StabilizationEnum::Full

@ Full

PorousFlowActionBase::StabilizationEnum::KT

@ KT

Constructor & Destructor Documentation

◆ PorousFlowUnsaturated()

PorousFlowUnsaturated::PorousFlowUnsaturated ( const InputParameters & params )

Definition at line 67 of file PorousFlowUnsaturated.C.

  : PorousFlowSinglePhaseBase(params),
    _add_saturation_aux(getParam<bool>("add_saturation_aux")),
    _van_genuchten_alpha(getParam<Real>("van_genuchten_alpha")),
    _van_genuchten_m(getParam<Real>("van_genuchten_m")),
    _relperm_type(
        getParam<MooseEnum>("relative_permeability_type").getEnum<RelpermTypeChoiceEnum>()),
    _relative_permeability_exponent(getParam<Real>("relative_permeability_exponent")),
    _s_res(getParam<Real>("residual_saturation")),
    _capillary_pressure_name("PorousFlowUnsaturated_CapillaryPressureVG")
{
  if (_stabilization == StabilizationEnum::None)
    paramError("stabilization", "Some stabilization must be used in PorousFlowUnsaturated");
}

Member Function Documentation

◆ act()

void PorousFlowActionBase::act ( )

overridevirtualinherited

Implements Action.

Definition at line 139 of file PorousFlowActionBase.C.

{
  // Check if the simulation is transient (note: can't do this in the ctor)
  _transient = _problem->isTransient();
 
  // get subdomain IDs
  std::set<SubdomainID> _subdomain_ids;
  for (auto & name : _subdomain_names)
  {
    auto id = _mesh->getSubdomainID(name);
    if (id == Moose::INVALID_BLOCK_ID)
      paramError("block", "Subdomain \"" + name + "\" not found in mesh.");
    else
      _subdomain_ids.insert(id);
  }
 
  // Make sure that all mesh subdomains have the same coordinate system
  const auto & all_subdomains =
      _subdomain_names.empty() ? _problem->mesh().meshSubdomains() : _subdomain_ids;
 
  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
	)

protectedinherited

Definition at line 669 of file PorousFlowActionBase.C.

{
  if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
  {
    const std::string userobject_type = "PorousFlowAdvectiveFluxCalculatorSaturated";
    InputParameters params = _factory.getValidParams(userobject_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    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);
  }
}

Referenced by PorousFlowFullySaturated::addUserObjects().

◆ addAdvectiveFluxCalculatorSaturatedHeat()

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

protectedinherited

Definition at line 709 of file PorousFlowActionBase.C.

{
  if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
  {
    const std::string userobject_type = "PorousFlowAdvectiveFluxCalculatorSaturatedHeat";
    InputParameters params = _factory.getValidParams(userobject_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    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);
  }
}

Referenced by PorousFlowFullySaturated::addUserObjects().

◆ addAdvectiveFluxCalculatorSaturatedMultiComponent()

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

protectedinherited

Definition at line 749 of file PorousFlowActionBase.C.

{
  if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
  {
    const std::string userobject_type = "PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponent";
    InputParameters params = _factory.getValidParams(userobject_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    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);
  }
}

Referenced by PorousFlowFullySaturated::addUserObjects().

◆ addAdvectiveFluxCalculatorUnsaturated()

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

protectedinherited

Definition at line 689 of file PorousFlowActionBase.C.

{
  if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
  {
    const std::string userobject_type = "PorousFlowAdvectiveFluxCalculatorUnsaturated";
    InputParameters params = _factory.getValidParams(userobject_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    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);
  }
}

Referenced by addUserObjects().

◆ addAdvectiveFluxCalculatorUnsaturatedHeat()

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

protectedinherited

Definition at line 729 of file PorousFlowActionBase.C.

{
  if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
  {
    const std::string userobject_type = "PorousFlowAdvectiveFluxCalculatorUnsaturatedHeat";
    InputParameters params = _factory.getValidParams(userobject_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    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);
  }
}

Referenced by addUserObjects().

◆ addAdvectiveFluxCalculatorUnsaturatedMultiComponent()

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

protectedinherited

Definition at line 771 of file PorousFlowActionBase.C.

{
  if (_stabilization == StabilizationEnum::KT && _current_task == "add_user_object")
  {
    const std::string userobject_type =
        "PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent";
    InputParameters params = _factory.getValidParams(userobject_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    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);
  }
}

Referenced by addUserObjects().

◆ addAuxObjects()

void PorousFlowUnsaturated::addAuxObjects ( )

overrideprotectedvirtual

Add all AuxVariables and AuxKernels.

Reimplemented from PorousFlowSinglePhaseBase.

Definition at line 331 of file PorousFlowUnsaturated.C.

{
  PorousFlowSinglePhaseBase::addAuxObjects();
 
  if (_add_saturation_aux)
    addSaturationAux(0);
}

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

protectedinherited

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 543 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_material")
  {
    std::string material_type = "PorousFlowBrine";
    InputParameters params = _factory.getValidParams(material_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

Referenced by PorousFlowSinglePhaseBase::addMaterials().

◆ addCapillaryPressureVG()

void PorousFlowActionBase::addCapillaryPressureVG	(	Real	m,
		Real	alpha,
		std::string	userobject_name,
		Real	sat_lr = `0.0`
	)

protectedinherited

Adds a van Genuchten capillary pressure UserObject.

Parameters

m	van Genuchten exponent
alpha	van Genuchten alpha
userobject_name	name of the user object
sat_lr	liquid residual saturation

Definition at line 650 of file PorousFlowActionBase.C.

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

Referenced by addUserObjects().

◆ addDarcyAux()

void PorousFlowActionBase::addDarcyAux ( const RealVectorValue & gravity )

protectedinherited

Add AuxVariables and AuxKernels to calculate Darcy velocity.

Parameters

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

Definition at line 269 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_aux_variable")
  {
    auto var_params = _factory.getValidParams("MooseVariableConstMonomial");
    if (_subdomain_names_set)
      var_params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    _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);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

Referenced by PorousFlowSinglePhaseBase::addAuxObjects().

◆ addDictator()

void PorousFlowSinglePhaseBase::addDictator ( )

overrideprotectedvirtualinherited

Add the PorousFlowDictator object.

Implements PorousFlowActionBase.

Definition at line 383 of file PorousFlowSinglePhaseBase.C.

{
  const std::string uo_name = _dictator_name;
  const std::string uo_type = "PorousFlowDictator";
  InputParameters params = _factory.getValidParams(uo_type);
  std::vector<VariableName> pf_vars = _mass_fraction_vars;
  pf_vars.push_back(_pp_var);
  // Only couple if in the same nonlinear system
  params.set<SolverSystemName>("solver_sys") =
      _problem->getSystemBase(_problem->getSystem(_pp_var).name()).name();
  if (_thermal &&
      (_problem->getSystem(_temperature_var[0]).number() == _problem->getSystem(_pp_var).number()))
    pf_vars.push_back(_temperature_var[0]);
  if (_mechanical && _coupled_displacements.size() &&
      (_problem->getSystem(_coupled_displacements[0]).number() ==
       _problem->getSystem(_pp_var).number()))
    pf_vars.insert(pf_vars.end(), _coupled_displacements.begin(), _coupled_displacements.end());
  params.set<std::vector<VariableName>>("porous_flow_vars") = pf_vars;
  params.set<unsigned int>("number_fluid_phases") = 1;
  params.set<unsigned int>("number_fluid_components") = _num_mass_fraction_vars + 1;
  params.set<unsigned int>("number_aqueous_equilibrium") = _num_aqueous_equilibrium;
  params.set<unsigned int>("number_aqueous_kinetic") = _num_aqueous_kinetic;
  _problem->addUserObject(uo_type, uo_name, params);
}

◆ addEffectiveFluidPressureMaterial()

void PorousFlowActionBase::addEffectiveFluidPressureMaterial ( bool at_nodes )

protectedinherited

Adds a nodal and a quadpoint effective fluid pressure material.

Parameters

at_nodes Add nodal effective fluid pressure material

Definition at line 447 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_material")
  {
    std::string material_type = "PorousFlowEffectiveFluidPressure";
    InputParameters params = _factory.getValidParams(material_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

Referenced by PorousFlowSinglePhaseBase::addMaterials().

◆ addKernels()

void PorousFlowUnsaturated::addKernels ( )

overrideprotectedvirtual

Add all Kernels.

Reimplemented from PorousFlowSinglePhaseBase.

Definition at line 110 of file PorousFlowUnsaturated.C.

{
  PorousFlowSinglePhaseBase::addKernels();
 
  // add the kernels
  if (_stabilization == StabilizationEnum::Full)
  {
    const std::string kernel_type = "PorousFlowAdvectiveFlux";
    InputParameters params = _factory.getValidParams(kernel_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
    params.set<RealVectorValue>("gravity") = _gravity;
 
    for (unsigned i = 0; i < _num_mass_fraction_vars; ++i)
    {
      const std::string kernel_name = "PorousFlowUnsaturated_AdvectiveFlux" + Moose::stringify(i);
      params.set<unsigned int>("fluid_component") = i;
      params.set<NonlinearVariableName>("variable") = _mass_fraction_vars[i];
      _problem->addKernel(kernel_type, kernel_name, params);
    }
    const std::string kernel_name =
        "PorousFlowUnsaturated_AdvectiveFlux" + Moose::stringify(_num_mass_fraction_vars);
    params.set<unsigned int>("fluid_component") = _num_mass_fraction_vars;
    params.set<NonlinearVariableName>("variable") = _pp_var;
    _problem->addKernel(kernel_type, kernel_name, params);
  }
  else if (_stabilization == StabilizationEnum::KT)
  {
    const std::string kernel_type = "PorousFlowFluxLimitedTVDAdvection";
    InputParameters params = _factory.getValidParams(kernel_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
 
    for (unsigned i = 0; i < _num_mass_fraction_vars; ++i)
    {
      const std::string kernel_name = "PorousFlowFluxLimited_DarcyFlow" + Moose::stringify(i);
      params.set<UserObjectName>("advective_flux_calculator") =
          "PorousFlowUnsaturated_AC_" + Moose::stringify(i);
      params.set<NonlinearVariableName>("variable") = _mass_fraction_vars[i];
      _problem->addKernel(kernel_type, kernel_name, params);
    }
    const std::string kernel_name =
        "PorousFlowFluxLimited_DarcyFlow" + Moose::stringify(_num_mass_fraction_vars);
    params.set<NonlinearVariableName>("variable") = _pp_var;
    params.set<UserObjectName>("advective_flux_calculator") =
        "PorousFlowUnsaturated_AC_" + Moose::stringify(_num_mass_fraction_vars);
    _problem->addKernel(kernel_type, kernel_name, params);
  }
 
  if (_transient)
  {
    std::string kernel_name = "PorousFlowUnsaturated_MassTimeDerivative";
    std::string kernel_type = "PorousFlowMassTimeDerivative";
    InputParameters params = _factory.getValidParams(kernel_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
    params.set<bool>("strain_at_nearest_qp") = _strain_at_nearest_qp;
    if (!_base_name.empty())
      params.set<std::string>("base_name") = _base_name;
 
    for (unsigned i = 0; i < _num_mass_fraction_vars; ++i)
    {
      kernel_name = "PorousFlowUnsaturated_MassTimeDerivative" + Moose::stringify(i);
      params.set<unsigned int>("fluid_component") = i;
      params.set<NonlinearVariableName>("variable") = _mass_fraction_vars[i];
      if (_save_component_rate_in.size() != 0)
        params.set<std::vector<AuxVariableName>>("save_in") = {_save_component_rate_in[i]};
      _problem->addKernel(kernel_type, kernel_name, params);
    }
    kernel_name =
        "PorousFlowUnsaturated_MassTimeDerivative" + Moose::stringify(_num_mass_fraction_vars);
    params.set<unsigned int>("fluid_component") = _num_mass_fraction_vars;
    params.set<NonlinearVariableName>("variable") = _pp_var;
    if (_save_component_rate_in.size() != 0)
      params.set<std::vector<AuxVariableName>>("save_in") = {
          _save_component_rate_in[_num_mass_fraction_vars]};
    _problem->addKernel(kernel_type, kernel_name, params);
  }
 
  if (_mechanical && _transient)
  {
    std::string kernel_name = "PorousFlowUnsaturated_MassVolumetricExpansion";
    std::string kernel_type = "PorousFlowMassVolumetricExpansion";
    InputParameters params = _factory.getValidParams(kernel_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
    params.set<bool>("strain_at_nearest_qp") = _strain_at_nearest_qp;
 
    for (unsigned i = 0; i < _num_mass_fraction_vars; ++i)
    {
      kernel_name = "PorousFlowUnsaturated_MassVolumetricExpansion" + Moose::stringify(i);
      params.set<unsigned>("fluid_component") = i;
      params.set<NonlinearVariableName>("variable") = _mass_fraction_vars[i];
      _problem->addKernel(kernel_type, kernel_name, params);
    }
    kernel_name =
        "PorousFlowUnsaturated_MassVolumetricExpansion" + Moose::stringify(_num_mass_fraction_vars);
    params.set<unsigned>("fluid_component") = _num_mass_fraction_vars;
    params.set<NonlinearVariableName>("variable") = _pp_var;
    _problem->addKernel(kernel_type, kernel_name, params);
  }
 
  if (_thermal)
  {
    if (_stabilization == StabilizationEnum::Full)
    {
      const std::string kernel_name = "PorousFlowUnsaturated_HeatAdvection";
      const std::string kernel_type = "PorousFlowHeatAdvection";
      InputParameters params = _factory.getValidParams(kernel_type);
      if (_subdomain_names_set)
        params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
      params.set<NonlinearVariableName>("variable") = _temperature_var[0];
      params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
      params.set<RealVectorValue>("gravity") = _gravity;
      _problem->addKernel(kernel_type, kernel_name, params);
    }
    else if (_stabilization == StabilizationEnum::KT)
    {
      const std::string kernel_name = "PorousFlowUnsaturated_HeatAdvection";
      const std::string kernel_type = "PorousFlowFluxLimitedTVDAdvection";
      InputParameters params = _factory.getValidParams(kernel_type);
      if (_subdomain_names_set)
        params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
      params.set<NonlinearVariableName>("variable") = _temperature_var[0];
      params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
      params.set<UserObjectName>("advective_flux_calculator") = "PorousFlowUnsaturatedHeat_AC";
      _problem->addKernel(kernel_type, kernel_name, params);
    }
  }
}

◆ addMassFractionMaterial()

void PorousFlowActionBase::addMassFractionMaterial ( bool at_nodes )

protectedinherited

Adds a nodal and a quadpoint MassFraction material.

Parameters

at_nodes Add nodal mass-fraction material

Definition at line 420 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_material")
  {
    if (!(parameters().hasDefaultCoupledValue("mass_fraction_vars") ||
          parameters().hasCoupledVar("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);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

Referenced by PorousFlowSinglePhaseBase::addMaterials().

◆ addMaterialDependencies()

void PorousFlowUnsaturated::addMaterialDependencies ( )

overrideprotectedvirtual

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

Reimplemented from PorousFlowSinglePhaseBase.

Definition at line 83 of file PorousFlowUnsaturated.C.

{
  PorousFlowSinglePhaseBase::addMaterialDependencies();
 
  // Add necessary objects to list of PorousFlow objects added by this action
  _included_objects.push_back("PorousFlowAdvectiveFlux");
 
  if (_transient)
    _included_objects.push_back("PorousFlowMassTimeDerivative");
 
  if (_mechanical && _transient)
    _included_objects.push_back("PorousFlowMassVolumetricExpansion");
 
  if (_thermal)
    _included_objects.push_back("PorousFlowHeatAdvection");
 
  if (_add_saturation_aux)
    _included_objects.push_back("SaturationAux");
 
  if (_stabilization == StabilizationEnum::KT)
    _included_objects.push_back("PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponent");
 
  if (_stabilization == StabilizationEnum::KT && _thermal)
    _included_objects.push_back("PorousFlowAdvectiveFluxCalculatorUnsaturatedHeat");
}

◆ addMaterials()

void PorousFlowUnsaturated::addMaterials ( )

overrideprotectedvirtual

Add all Materials.

Reimplemented from PorousFlowSinglePhaseBase.

Definition at line 278 of file PorousFlowUnsaturated.C.

{
  PorousFlowSinglePhaseBase::addMaterials();
 
  if (_deps.dependsOn(_included_objects, "pressure_saturation_qp"))
  {
    const std::string material_type = "PorousFlow1PhaseP";
    const std::string material_name = "PorousFlowUnsaturated_1PhaseP_VG_qp";
    InputParameters params = _factory.getValidParams(material_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
    params.set<std::vector<VariableName>>("porepressure") = {_pp_var};
    params.set<UserObjectName>("capillary_pressure") = _capillary_pressure_name;
    params.set<bool>("at_nodes") = false;
    _problem->addMaterial(material_type, material_name, params);
  }
  if (_deps.dependsOn(_included_objects, "pressure_saturation_nodal"))
  {
    const std::string material_type = "PorousFlow1PhaseP";
    const std::string material_name = "PorousFlowUnsaturated_1PhaseP_VG_nodal";
    InputParameters params = _factory.getValidParams(material_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
    params.set<std::vector<VariableName>>("porepressure") = {_pp_var};
    params.set<UserObjectName>("capillary_pressure") = _capillary_pressure_name;
    params.set<bool>("at_nodes") = true;
    _problem->addMaterial(material_type, material_name, params);
  }
 
  if (_deps.dependsOn(_included_objects, "relative_permeability_qp"))
  {
    if (_relperm_type == RelpermTypeChoiceEnum::FLAC)
      addRelativePermeabilityFLAC(false, 0, _relative_permeability_exponent, _s_res, _s_res);
    else
      addRelativePermeabilityCorey(false, 0, _relative_permeability_exponent, _s_res, _s_res);
  }
 
  if (_deps.dependsOn(_included_objects, "relative_permeability_nodal"))
  {
    if (_relperm_type == RelpermTypeChoiceEnum::FLAC)
      addRelativePermeabilityFLAC(true, 0, _relative_permeability_exponent, _s_res, _s_res);
    else
      addRelativePermeabilityCorey(true, 0, _relative_permeability_exponent, _s_res, _s_res);
  }
 
  if (_deps.dependsOn(_included_objects, "volumetric_strain_qp") ||
      _deps.dependsOn(_included_objects, "volumetric_strain_nodal"))
    addVolumetricStrainMaterial(_coupled_displacements, _base_name);
}

◆ addNearestQpMaterial()

void PorousFlowActionBase::addNearestQpMaterial ( )

protectedinherited

Adds a PorousFlowNearestQp material.

Definition at line 468 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_material")
  {
    std::string material_type = "PorousFlowNearestQp";
    InputParameters params = _factory.getValidParams(material_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

Referenced by PorousFlowActionBase::addMaterials().

◆ addRelationshipManagers() [1/3]

virtual void Action::addRelationshipManagers ( Moose::RelationshipManagerType when_type )

virtualinherited

Reimplemented from Action.

◆ addRelationshipManagers() [2/3]

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

overridevirtualinherited

Reimplemented from Action.

Definition at line 130 of file PorousFlowActionBase.C.

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

Referenced by PorousFlowActionBase::addRelationshipManagers().

◆ addRelationshipManagers() [3/3]

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

inherited

◆ addRelativePermeabilityConst()

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

protectedinherited

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 576 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_material")
  {
    std::string material_type = "PorousFlowRelativePermeabilityConst";
    InputParameters params = _factory.getValidParams(material_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

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

◆ addRelativePermeabilityCorey()

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

protectedinherited

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 598 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_material")
  {
    std::string material_type = "PorousFlowRelativePermeabilityCorey";
    InputParameters params = _factory.getValidParams(material_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

Referenced by addMaterials().

◆ addRelativePermeabilityFLAC()

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

protectedinherited

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 624 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_material")
  {
    std::string material_type = "PorousFlowRelativePermeabilityFLAC";
    InputParameters params = _factory.getValidParams(material_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

Referenced by addMaterials().

◆ addSaturationAux()

void PorousFlowActionBase::addSaturationAux ( unsigned phase )

protectedinherited

Add an AuxVariable and AuxKernel to calculate saturation.

Parameters

phase Saturation for this fluid phase

Definition at line 242 of file PorousFlowActionBase.C.

{
  std::string phase_str = Moose::stringify(phase);
 
  if (_current_task == "add_aux_variable")
  {
    auto var_params = _factory.getValidParams("MooseVariableConstMonomial");
    if (_subdomain_names_set)
      var_params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    _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);
  }
}

Referenced by addAuxObjects().

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

protectedinherited

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 506 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_material")
  {
    std::string material_type = "PorousFlowSingleComponentFluid";
    InputParameters params = _factory.getValidParams(material_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

Referenced by PorousFlowSinglePhaseBase::addMaterials().

◆ addStressAux()

void PorousFlowActionBase::addStressAux ( )

protectedinherited

Add AuxVariables and AuxKernels to compute effective stress.

Definition at line 311 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_aux_variable")
  {
    auto var_params = _factory.getValidParams("MooseVariableConstMonomial");
    if (_subdomain_names_set)
      var_params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
    _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);
  }
}

Referenced by PorousFlowSinglePhaseBase::addAuxObjects().

◆ addTemperatureMaterial()

void PorousFlowActionBase::addTemperatureMaterial ( bool at_nodes )

protectedinherited

Adds a nodal and a quadpoint Temperature material.

Parameters

at_nodes Add nodal temperature Material

Definition at line 394 of file PorousFlowActionBase.C.

{
  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);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

Referenced by PorousFlowSinglePhaseBase::addMaterials().

◆ addUserObjects()

void PorousFlowUnsaturated::addUserObjects ( )

overrideprotectedvirtual

Add all other UserObjects.

Reimplemented from PorousFlowActionBase.

Definition at line 246 of file PorousFlowUnsaturated.C.

{
  PorousFlowSinglePhaseBase::addUserObjects();
 
  // Add the capillary pressure UserObject
  addCapillaryPressureVG(_van_genuchten_m, _van_genuchten_alpha, _capillary_pressure_name, _s_res);
 
  // add Advective Flux calculator UserObjects, if required
  if (_stabilization == StabilizationEnum::KT)
  {
    for (unsigned i = 0; i < _num_mass_fraction_vars; ++i)
    {
      const std::string userobject_name = "PorousFlowUnsaturated_AC_" + Moose::stringify(i);
      addAdvectiveFluxCalculatorUnsaturatedMultiComponent(0, i, true, userobject_name);
    }
    const std::string userobject_name =
        "PorousFlowUnsaturated_AC_" + Moose::stringify(_num_mass_fraction_vars);
    if (_num_mass_fraction_vars == 0)
      addAdvectiveFluxCalculatorUnsaturated(0, true, userobject_name); // 1 component only
    else
      addAdvectiveFluxCalculatorUnsaturatedMultiComponent(
          0, _num_mass_fraction_vars, true, userobject_name);
 
    if (_thermal)
    {
      const std::string userobject_name = "PorousFlowUnsaturatedHeat_AC";
      addAdvectiveFluxCalculatorUnsaturatedHeat(0, true, userobject_name);
    }
  }
}

◆ addVolumetricStrainMaterial()

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

protectedinherited

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 486 of file PorousFlowActionBase.C.

{
  if (_current_task == "add_material")
  {
    std::string material_type = "PorousFlowVolumetricStrain";
    InputParameters params = _factory.getValidParams(material_type);
    if (_subdomain_names_set)
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    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);
  }
}

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

◆ validParams()

InputParameters PorousFlowUnsaturated::validParams ( )

static

Definition at line 27 of file PorousFlowUnsaturated.C.

{
  InputParameters params = PorousFlowSinglePhaseBase::validParams();
  params.addParam<bool>("add_saturation_aux", true, "Add an AuxVariable that records saturation");
  params.addRangeCheckedParam<Real>(
      "van_genuchten_alpha",
      1.0E-6,
      "van_genuchten_alpha > 0.0",
      "Van Genuchten alpha parameter used to determine saturation from porepressure");
  params.addRangeCheckedParam<Real>(
      "van_genuchten_m",
      0.6,
      "van_genuchten_m > 0 & van_genuchten_m < 1",
      "Van Genuchten m parameter used to determine saturation from porepressure");
  MooseEnum relperm_type_choice("FLAC Corey", "FLAC");
  params.addParam<MooseEnum>("relative_permeability_type",
                             relperm_type_choice,
                             "Type of relative-permeability function.  FLAC relperm = (1+m)S^m - "
                             "mS^(1+m).  Corey relperm = S^m.  m is the exponent.  Here S = "
                             "(saturation - residual)/(1 - residual)");
  params.addRangeCheckedParam<Real>("relative_permeability_exponent",
                                    3.0,
                                    "relative_permeability_exponent>=0",
                                    "Relative permeability exponent");
  params.addRangeCheckedParam<Real>(
      "residual_saturation",
      0.0,
      "residual_saturation>=0.0 & residual_saturation<1.0",
      "Residual saturation to use in the relative permeability expression");
  params.addClassDescription("Adds Kernels and fluid-property Materials necessary to simulate a "
                             "single-phase saturated-unsaturated flow problem.  The saturation is "
                             "computed using van Genuchten's expression.  No Kernels for diffusion "
                             "and dispersion of fluid components are added.  To run a simulation "
                             "you will also need to provide various other Materials for each mesh "
                             "block, depending on your simulation type, viz: permeability, "
                             "porosity, elasticity tensor, strain calculator, stress calculator, "
                             "matrix internal energy, thermal conductivity, diffusivity");
  return params;
}

Member Data Documentation

◆ _add_darcy_aux

const bool PorousFlowSinglePhaseBase::_add_darcy_aux

protectedinherited

Add a AuxVariables to record Darcy velocity.

Definition at line 60 of file PorousFlowSinglePhaseBase.h.

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

◆ _add_saturation_aux

const bool PorousFlowUnsaturated::_add_saturation_aux

protected

Add an Aux Variable to record saturation.

Definition at line 34 of file PorousFlowUnsaturated.h.

Referenced by addAuxObjects(), and addMaterialDependencies().

◆ _add_stress_aux

const bool PorousFlowSinglePhaseBase::_add_stress_aux

protectedinherited

Add AuxVariables for stress.

Definition at line 63 of file PorousFlowSinglePhaseBase.h.

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

◆ _base_name

const std::string PorousFlowSinglePhaseBase::_base_name

protectedinherited

base_name used in the TensorMechanics strain calculator

Definition at line 81 of file PorousFlowSinglePhaseBase.h.

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

◆ _biot_coefficient

const Real PorousFlowSinglePhaseBase::_biot_coefficient

protectedinherited

Fluid specific heat capacity at constant volume.

Definition at line 57 of file PorousFlowSinglePhaseBase.h.

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

◆ _capillary_pressure_name

const std::string PorousFlowUnsaturated::_capillary_pressure_name

protected

Name of the capillary pressure UserObject.

Definition at line 52 of file PorousFlowUnsaturated.h.

Referenced by addMaterials(), and addUserObjects().

◆ _coord_system

Moose::CoordinateSystemType PorousFlowActionBase::_coord_system

protectedinherited

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

Definition at line 95 of file PorousFlowActionBase.h.

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

◆ _coupled_displacements

std::vector<VariableName> PorousFlowActionBase::_coupled_displacements

protectedinherited

Displacement Variable names.

Definition at line 84 of file PorousFlowActionBase.h.

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

◆ _coupling_type

enum PorousFlowSinglePhaseBase::CouplingTypeEnum PorousFlowSinglePhaseBase::_coupling_type

protectedinherited

◆ _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 PorousFlowActionBase::addMaterials(), PorousFlowBasicTHM::addMaterials(), PorousFlowFullySaturated::addMaterials(), PorousFlowSinglePhaseBase::addMaterials(), addMaterials(), PorousFlowAddMaterialAction::isPFMaterialRequired(), and PorousFlowDependencies::PorousFlowDependencies().

◆ _dictator_name

const std::string PorousFlowActionBase::_dictator_name

protectedinherited

The name of the PorousFlowDictator object to be added.

Definition at line 51 of file PorousFlowActionBase.h.

◆ _displacements

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

protectedinherited

Displacement NonlinearVariable names (if any)

Definition at line 78 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addKernels().

◆ _fluid_properties_type

enum PorousFlowSinglePhaseBase::FluidPropertiesTypeEnum PorousFlowSinglePhaseBase::_fluid_properties_type

protectedinherited

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

◆ _flux_limiter_type

const MooseEnum PorousFlowActionBase::_flux_limiter_type

protectedinherited

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

Definition at line 87 of file PorousFlowActionBase.h.

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

◆ _fp

UserObjectName PorousFlowSinglePhaseBase::_fp

protectedinherited

Name of the fluid-properties UserObject.

Definition at line 54 of file PorousFlowSinglePhaseBase.h.

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

◆ _gravity

const RealVectorValue PorousFlowActionBase::_gravity

protectedinherited

Gravity.

Definition at line 66 of file PorousFlowActionBase.h.

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

◆ _included_objects

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

protectedinherited

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 PorousFlowActionBase::act(), PorousFlowActionBase::addMaterialDependencies(), PorousFlowBasicTHM::addMaterialDependencies(), PorousFlowFullySaturated::addMaterialDependencies(), PorousFlowSinglePhaseBase::addMaterialDependencies(), addMaterialDependencies(), PorousFlowActionBase::addMaterials(), PorousFlowBasicTHM::addMaterials(), PorousFlowFullySaturated::addMaterials(), PorousFlowSinglePhaseBase::addMaterials(), and addMaterials().

◆ _mass_fraction_vars

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

protectedinherited

Name of the mass-fraction variables (if any)

Definition at line 69 of file PorousFlowActionBase.h.

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

◆ _mechanical

const bool PorousFlowSinglePhaseBase::_mechanical

protectedinherited

Definition at line 44 of file PorousFlowSinglePhaseBase.h.

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

◆ _nacl_name

VariableName PorousFlowSinglePhaseBase::_nacl_name

protectedinherited

Name of the NaCl variable.

Definition at line 66 of file PorousFlowSinglePhaseBase.h.

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

◆ _ndisp

const unsigned PorousFlowActionBase::_ndisp

protectedinherited

Number of displacement variables supplied.

Definition at line 81 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addKernels().

◆ _num_aqueous_equilibrium

const unsigned int PorousFlowActionBase::_num_aqueous_equilibrium

protectedinherited

Number of aqueous-equilibrium secondary species.

Definition at line 60 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addDictator().

◆ _num_aqueous_kinetic

const unsigned int PorousFlowActionBase::_num_aqueous_kinetic

protectedinherited

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

Definition at line 63 of file PorousFlowActionBase.h.

Referenced by PorousFlowSinglePhaseBase::addDictator().

◆ _num_mass_fraction_vars

const unsigned PorousFlowActionBase::_num_mass_fraction_vars

protectedinherited

Number of mass-fraction variables.

Definition at line 72 of file PorousFlowActionBase.h.

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

◆ _pp_var

const VariableName PorousFlowSinglePhaseBase::_pp_var

protectedinherited

Porepressure NonlinearVariable name.

Definition at line 32 of file PorousFlowSinglePhaseBase.h.

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

◆ _pressure_unit

const MooseEnum PorousFlowSinglePhaseBase::_pressure_unit

protectedinherited

Unit used for porepressure.

Definition at line 75 of file PorousFlowSinglePhaseBase.h.

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

◆ _relative_permeability_exponent

const Real PorousFlowUnsaturated::_relative_permeability_exponent

protected

Relative permeability exponent.

Definition at line 46 of file PorousFlowUnsaturated.h.

Referenced by addMaterials().

◆ _relperm_type

enum PorousFlowUnsaturated::RelpermTypeChoiceEnum PorousFlowUnsaturated::_relperm_type

protected

Referenced by addMaterials().

◆ _s_res

const Real PorousFlowUnsaturated::_s_res

protected

Residual saturation to use in the relative permeability expressions.

Definition at line 49 of file PorousFlowUnsaturated.h.

Referenced by addMaterials(), and addUserObjects().

◆ _save_component_rate_in

const std::vector<AuxVariableName> PorousFlowSinglePhaseBase::_save_component_rate_in

protectedinherited

Name of the variables (if any) that will record the fluid-components' rate of change.

Definition at line 69 of file PorousFlowSinglePhaseBase.h.

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

◆ _stabilization

enum PorousFlowActionBase::StabilizationEnum PorousFlowActionBase::_stabilization

protectedinherited

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

◆ _strain_at_nearest_qp

const bool PorousFlowActionBase::_strain_at_nearest_qp

protectedinherited

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

Definition at line 92 of file PorousFlowActionBase.h.

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

◆ _subdomain_names

std::vector<SubdomainName> PorousFlowActionBase::_subdomain_names

protectedinherited

if this vector is not empty the variables, kernels and materials are restricted to these subdomains

Definition at line 54 of file PorousFlowActionBase.h.

◆ _subdomain_names_set

const bool PorousFlowActionBase::_subdomain_names_set

protectedinherited

indicates, if the vector of subdomain names is set (dont set block restrictions, if not)

Definition at line 57 of file PorousFlowActionBase.h.

◆ _temperature_unit

const MooseEnum PorousFlowSinglePhaseBase::_temperature_unit

protectedinherited

Unit used for temperature.

Definition at line 72 of file PorousFlowSinglePhaseBase.h.

Referenced by PorousFlowSinglePhaseBase::addMaterials().

◆ _temperature_var

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

protectedinherited

Name of the temperature variable (if any)

Definition at line 75 of file PorousFlowActionBase.h.

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

◆ _thermal

const bool PorousFlowSinglePhaseBase::_thermal

protectedinherited

Flags to indicate whether thermal or mechanical effects are included.

Definition at line 43 of file PorousFlowSinglePhaseBase.h.

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

◆ _time_unit

const MooseEnum PorousFlowSinglePhaseBase::_time_unit

protectedinherited

Unit used for time.

Definition at line 78 of file PorousFlowSinglePhaseBase.h.

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

◆ _transient

bool PorousFlowActionBase::_transient

protectedinherited

Flag to denote if the simulation is transient.

Definition at line 98 of file PorousFlowActionBase.h.

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

◆ _van_genuchten_alpha

const Real PorousFlowUnsaturated::_van_genuchten_alpha

protected

Van Genuchten alpha parameter.

Definition at line 37 of file PorousFlowUnsaturated.h.

Referenced by addUserObjects().

◆ _van_genuchten_m

const Real PorousFlowUnsaturated::_van_genuchten_m

protected

Van Genuchten m parameter.

Definition at line 40 of file PorousFlowUnsaturated.h.

Referenced by addUserObjects().

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

porous_flow/include/actions/PorousFlowUnsaturated.h
porous_flow/src/actions/PorousFlowUnsaturated.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

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ CouplingTypeEnum

◆ FluidPropertiesTypeEnum

◆ RelpermTypeChoiceEnum

◆ StabilizationEnum

Constructor & Destructor Documentation

◆ PorousFlowUnsaturated()

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

◆ _add_darcy_aux

◆ _add_saturation_aux

◆ _add_stress_aux

◆ _base_name

◆ _biot_coefficient

◆ _capillary_pressure_name

◆ _coord_system

◆ _coupled_displacements

◆ _coupling_type

◆ _deps

◆ _dictator_name

◆ _displacements

◆ _fluid_properties_type

◆ _flux_limiter_type

◆ _fp

◆ _gravity

◆ _included_objects

◆ _mass_fraction_vars

◆ _mechanical

◆ _nacl_name

◆ _ndisp

◆ _num_aqueous_equilibrium

◆ _num_aqueous_kinetic

◆ _num_mass_fraction_vars

◆ _pp_var

◆ _pressure_unit

◆ _relative_permeability_exponent