PorousFlowUnsaturated Class Reference

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

#include <PorousFlowUnsaturated.h>

Inheritance diagram for PorousFlowUnsaturated:

Public Member Functions
	PorousFlowUnsaturated (const InputParameters &params)
virtual void	act () override

Protected Types
enum	RelpermTypeChoiceEnum { RelpermTypeChoiceEnum::FLAC, RelpermTypeChoiceEnum::COREY }
	Fluid relative permeability type (FLAC or Corey) More...
enum	CouplingTypeEnum { CouplingTypeEnum::Hydro, CouplingTypeEnum::ThermoHydro, CouplingTypeEnum::HydroMechanical, CouplingTypeEnum::ThermoHydroMechanical }
	Determines the coupling type. More...
enum	SimulationTypeChoiceEnum { SimulationTypeChoiceEnum::STEADY, SimulationTypeChoiceEnum::TRANSIENT }
	Whether steady or transient simulation. More...

Protected Member Functions
virtual void	addDictator () override
	Add the PorousFlowDictator object. 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	addVolumetricStrainMaterial (const std::vector< VariableName > &displacements, bool consistent_with_displaced_mesh)
	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)
	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)
	Adds a brine fluid Material. 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...

Protected Attributes
const bool	_add_saturation_aux
	Add an Aux Variable to record saturation. More...
const Real	_van_genuchten_alpha
	Van Genuchten alpha parameter. More...
const Real	_van_genuchten_m
	Van Genuchten m parameter. More...
enum PorousFlowUnsaturated::RelpermTypeChoiceEnum	_relperm_type
const Real	_relative_permeability_exponent
	Relative permeability exponent. More...
const Real	_s_res
	Residual saturation to use in the relative permeability expressions. More...
const NonlinearVariableName	_pp_var
	Porepressure NonlinearVariable name. More...
enum PorousFlowSinglePhaseBase::CouplingTypeEnum	_coupling_type
enum PorousFlowSinglePhaseBase::SimulationTypeChoiceEnum	_simulation_type
const UserObjectName &	_fp
	Name of the fluid-properties UserObject. More...
const Real	_biot_coefficient
	Fluid specific heat capacity at constant volume. More...
const bool	_add_darcy_aux
	Add a AuxVariables to record Darcy velocity. More...
const bool	_add_stress_aux
	Add AuxVariables for stress. More...
const bool	_use_brine
	Use PorousFlowBrine material. More...
const unsigned	_nacl_index
	Index of NaCl in list of fluid components. More...
std::vector< std::string >	_objects_to_add
	List of Kernels, AuxKernels, Materials, etc, to be added. 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< NonlinearVariableName > &	_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...
Moose::CoordinateSystemType	_coord_system
	Coordinate system of the simulation (eg RZ, XYZ, etc) More...
DependencyResolver< std::string >	_deps
	All dependencies of kernels, auxkernels, materials, etc, are stored in _dependencies. More...

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 25 of file PorousFlowUnsaturated.h.

Member Enumeration Documentation

CouplingTypeEnum

enum PorousFlowSinglePhaseBase::CouplingTypeEnum

strongprotectedinherited

Determines the coupling type.

Enumerator
Hydro
ThermoHydro
HydroMechanical
ThermoHydroMechanical

Definition at line 37 of file PorousFlowSinglePhaseBase.h.

                                    {
    Hydro,
    ThermoHydro,
    HydroMechanical,
    ThermoHydroMechanical
  } _coupling_type;

RelpermTypeChoiceEnum

enum PorousFlowUnsaturated::RelpermTypeChoiceEnum

strongprotected

Fluid relative permeability type (FLAC or Corey)

Enumerator
FLAC
COREY

Definition at line 43 of file PorousFlowUnsaturated.h.

{ FLAC, COREY } _relperm_type;

SimulationTypeChoiceEnum

enum PorousFlowSinglePhaseBase::SimulationTypeChoiceEnum

strongprotectedinherited

Whether steady or transient simulation.

Enumerator
STEADY
TRANSIENT

Definition at line 45 of file PorousFlowSinglePhaseBase.h.

{ STEADY, TRANSIENT } _simulation_type;

Constructor & Destructor Documentation

PorousFlowUnsaturated()

PorousFlowUnsaturated::PorousFlowUnsaturated

(

const InputParameters &

params

)

Definition at line 68 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"))
{
  _objects_to_add.push_back("PorousFlowAdvectiveFlux");
  if (_simulation_type == SimulationTypeChoiceEnum::TRANSIENT)
    _objects_to_add.push_back("PorousFlowMassTimeDerivative");
  if ((_coupling_type == CouplingTypeEnum::HydroMechanical ||
       _coupling_type == CouplingTypeEnum::ThermoHydroMechanical) &&
      _simulation_type == SimulationTypeChoiceEnum::TRANSIENT)
    _objects_to_add.push_back("PorousFlowMassVolumetricExpansion");
  if (_coupling_type == CouplingTypeEnum::ThermoHydro ||
      _coupling_type == CouplingTypeEnum::ThermoHydroMechanical)
    _objects_to_add.push_back("PorousFlowHeatAdvection");
  if (_add_saturation_aux)
    _objects_to_add.push_back("SaturationAux");
}

Member Function Documentation

act()

void PorousFlowUnsaturated::act ( )

overridevirtual

Reimplemented from PorousFlowSinglePhaseBase.

Definition at line 93 of file PorousFlowUnsaturated.C.

{
  PorousFlowSinglePhaseBase::act();

  // add the kernels
  if (_current_task == "add_kernel")
  {
    std::string kernel_name = "PorousFlowUnsaturated_AdvectiveFlux";
    std::string kernel_type = "PorousFlowAdvectiveFlux";
    InputParameters params = _factory.getValidParams(kernel_type);
    params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
    params.set<RealVectorValue>("gravity") = _gravity;

    for (unsigned i = 0; i < _num_mass_fraction_vars; ++i)
    {
      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);
    }
    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);
  }
  if (_current_task == "add_kernel" && _simulation_type == SimulationTypeChoiceEnum::TRANSIENT)
  {
    std::string kernel_name = "PorousFlowUnsaturated_MassTimeDerivative";
    std::string kernel_type = "PorousFlowMassTimeDerivative";
    InputParameters params = _factory.getValidParams(kernel_type);
    params.set<UserObjectName>("PorousFlowDictator") = _dictator_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];
      _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;
    _problem->addKernel(kernel_type, kernel_name, params);
  }

  if ((_coupling_type == CouplingTypeEnum::HydroMechanical ||
       _coupling_type == CouplingTypeEnum::ThermoHydroMechanical) &&
      _current_task == "add_kernel" && _simulation_type == SimulationTypeChoiceEnum::TRANSIENT)
  {
    std::string kernel_name = "PorousFlowUnsaturated_MassVolumetricExpansion";
    std::string kernel_type = "PorousFlowMassVolumetricExpansion";
    InputParameters params = _factory.getValidParams(kernel_type);
    params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
    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 ((_coupling_type == CouplingTypeEnum::ThermoHydro ||
       _coupling_type == CouplingTypeEnum::ThermoHydroMechanical) &&
      _current_task == "add_kernel")
  {
    std::string kernel_name = "PorousFlowUnsaturated_HeatAdvection";
    std::string kernel_type = "PorousFlowHeatAdvection";
    InputParameters params = _factory.getValidParams(kernel_type);
    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);
  }

  // Add the capillary pressure UserObject
  std::string capillary_pressure_name = "PorousFlowUnsaturated_CapillaryPressureVG";
  addCapillaryPressureVG(_van_genuchten_m, _van_genuchten_alpha, capillary_pressure_name);

  if (_deps.dependsOn(_objects_to_add, "pressure_saturation_qp") && _current_task == "add_material")
  {
    std::string material_type = "PorousFlow1PhaseP";
    InputParameters params = _factory.getValidParams(material_type);

    std::string material_name = "PorousFlowUnsaturated_1PhaseP_VG_qp";
    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(_objects_to_add, "pressure_saturation_nodal") &&
      _current_task == "add_material")
  {
    std::string material_type = "PorousFlow1PhaseP";
    InputParameters params = _factory.getValidParams(material_type);

    std::string material_name = "PorousFlowUnsaturated_1PhaseP_VG_nodal";
    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(_objects_to_add, "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(_objects_to_add, "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(_objects_to_add, "volumetric_strain_qp") ||
      _deps.dependsOn(_objects_to_add, "volumetric_strain_nodal"))
    addVolumetricStrainMaterial(_coupled_displacements, true);

  // add relevant AuxVariables and AuxKernels
  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  )

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

Definition at line 384 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::act().

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

    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  )

protectedinherited

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

Referenced by act().

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

protectedinherited

Add AuxVariables and AuxKernels to calculate Darcy velocity.

Parameters

gravity

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

Definition at line 130 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::act().

{
  if (_current_task == "add_aux_variable")
  {
    _problem->addAuxVariable("darcy_vel_x",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
    _problem->addAuxVariable("darcy_vel_y",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
    _problem->addAuxVariable("darcy_vel_z",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
  }

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

void PorousFlowSinglePhaseBase::addDictator ( )

overrideprotectedvirtualinherited

Add the PorousFlowDictator object.

Implements PorousFlowActionBase.

Definition at line 255 of file PorousFlowSinglePhaseBase.C.

{
  std::string uo_name = _dictator_name;
  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);
  if (_coupling_type == CouplingTypeEnum::ThermoHydro ||
      _coupling_type == CouplingTypeEnum::ThermoHydroMechanical)
    pf_vars.push_back(_temperature_var[0]);
  if (_coupling_type == CouplingTypeEnum::HydroMechanical ||
      _coupling_type == CouplingTypeEnum::ThermoHydroMechanical)
    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 319 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::act().

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

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

Referenced by PorousFlowSinglePhaseBase::act().

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

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

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

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

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

protectedinherited

Adds a relative-permeability Material of the FLAC variety.

Parameters

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

Referenced by act().

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

protectedinherited

Add an AuxVariable and AuxKernel to calculate saturation.

Parameters

phase

Saturation for this fluid phase

Definition at line 106 of file PorousFlowActionBase.C.

Referenced by act().

{
  std::string phase_str = Moose::stringify(phase);

  if (_current_task == "add_aux_variable")
    _problem->addAuxVariable("saturation" + phase_str,
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));

  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  )

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

Definition at line 355 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::act().

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

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

protectedinherited

Add AuxVariables and AuxKernels to compute effective stress.

Definition at line 172 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::act().

{
  if (_current_task == "add_aux_variable")
  {
    _problem->addAuxVariable("stress_xx",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
    _problem->addAuxVariable("stress_xy",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
    _problem->addAuxVariable("stress_xz",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
    _problem->addAuxVariable("stress_yx",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
    _problem->addAuxVariable("stress_yy",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
    _problem->addAuxVariable("stress_yz",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
    _problem->addAuxVariable("stress_zx",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
    _problem->addAuxVariable("stress_zy",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
    _problem->addAuxVariable("stress_zz",
                             FEType(Utility::string_to_enum<Order>("CONSTANT"),
                                    Utility::string_to_enum<FEFamily>("MONOMIAL")));
  }

  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 )

protectedinherited

Adds a nodal and a quadpoint Temperature material.

Parameters

at_nodes

Add nodal temperature Material

Definition at line 270 of file PorousFlowActionBase.C.

Referenced by PorousFlowSinglePhaseBase::act().

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

addVolumetricStrainMaterial()

void PorousFlowActionBase::addVolumetricStrainMaterial ( const std::vector< VariableName > &  displacements, bool  consistent_with_displaced_mesh  )

protectedinherited

Adds a quadpoint volumetric strain material.

Parameters

displacements	the names of the displacement variables
consistent_with_displaced_mesh	The volumetric strain should be consistent with the displaced mesh

Definition at line 338 of file PorousFlowActionBase.C.

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

{
  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;
    params.set<bool>("consistent_with_displaced_mesh") = consistent_with_displaced_mesh;
    _problem->addMaterial(material_type, material_name, params);
  }
}

Member Data Documentation

_add_darcy_aux

const bool PorousFlowSinglePhaseBase::_add_darcy_aux

protectedinherited

Add a AuxVariables to record Darcy velocity.

Definition at line 54 of file PorousFlowSinglePhaseBase.h.

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

_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 act(), and PorousFlowUnsaturated().

_add_stress_aux

const bool PorousFlowSinglePhaseBase::_add_stress_aux

protectedinherited

Add AuxVariables for stress.

Definition at line 57 of file PorousFlowSinglePhaseBase.h.

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

_biot_coefficient

const Real PorousFlowSinglePhaseBase::_biot_coefficient

protectedinherited

Fluid specific heat capacity at constant volume.

Definition at line 51 of file PorousFlowSinglePhaseBase.h.

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

_coord_system

Moose::CoordinateSystemType PorousFlowActionBase::_coord_system

protectedinherited

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

Definition at line 73 of file PorousFlowActionBase.h.

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

_coupled_displacements

std::vector<VariableName> PorousFlowActionBase::_coupled_displacements

protectedinherited

Displacement Variable names.

Definition at line 70 of file PorousFlowActionBase.h.

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

_coupling_type

enum PorousFlowSinglePhaseBase::CouplingTypeEnum PorousFlowSinglePhaseBase::_coupling_type

protectedinherited

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

_deps

DependencyResolver<std::string> PorousFlowDependencies::_deps

protectedinherited

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

Definition at line 38 of file PorousFlowDependencies.h.

Referenced by PorousFlowFullySaturated::act(), PorousFlowSinglePhaseBase::act(), act(), PorousFlowBasicTHM::act(), 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 43 of file PorousFlowActionBase.h.

Referenced by PorousFlowFullySaturated::act(), PorousFlowSinglePhaseBase::act(), act(), PorousFlowBasicTHM::act(), PorousFlowActionBase::addBrineMaterial(), PorousFlowActionBase::addDarcyAux(), PorousFlowSinglePhaseBase::addDictator(), PorousFlowActionBase::addEffectiveFluidPressureMaterial(), PorousFlowActionBase::addMassFractionMaterial(), PorousFlowActionBase::addRelativePermeabilityCorey(), PorousFlowActionBase::addRelativePermeabilityFLAC(), PorousFlowActionBase::addSingleComponentFluidMaterial(), PorousFlowActionBase::addTemperatureMaterial(), and PorousFlowActionBase::addVolumetricStrainMaterial().

_displacements

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

protectedinherited

Displacement NonlinearVariable names (if any)

Definition at line 64 of file PorousFlowActionBase.h.

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

_fp

const UserObjectName& PorousFlowSinglePhaseBase::_fp

protectedinherited

Name of the fluid-properties UserObject.

Definition at line 48 of file PorousFlowSinglePhaseBase.h.

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

_gravity

const RealVectorValue PorousFlowActionBase::_gravity

protectedinherited

Gravity.

Definition at line 52 of file PorousFlowActionBase.h.

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

_mass_fraction_vars

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

protectedinherited

Name of the mass-fraction variables (if any)

Definition at line 55 of file PorousFlowActionBase.h.

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

_nacl_index

const unsigned PorousFlowSinglePhaseBase::_nacl_index

protectedinherited

Index of NaCl in list of fluid components.

Definition at line 63 of file PorousFlowSinglePhaseBase.h.

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

_ndisp

const unsigned PorousFlowActionBase::_ndisp

protectedinherited

Number of displacement variables supplied.

Definition at line 67 of file PorousFlowActionBase.h.

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

_num_aqueous_equilibrium

const unsigned int PorousFlowActionBase::_num_aqueous_equilibrium

protectedinherited

Number of aqueous-equilibrium secondary species.

Definition at line 46 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 49 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 58 of file PorousFlowActionBase.h.

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

_objects_to_add

std::vector<std::string> PorousFlowActionBase::_objects_to_add

protectedinherited

List of Kernels, AuxKernels, Materials, etc, to be added.

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 40 of file PorousFlowActionBase.h.

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

_pp_var

const NonlinearVariableName PorousFlowSinglePhaseBase::_pp_var

protectedinherited

Porepressure NonlinearVariable name.

Definition at line 34 of file PorousFlowSinglePhaseBase.h.

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

_relative_permeability_exponent

const Real PorousFlowUnsaturated::_relative_permeability_exponent

protected

Relative permeability exponent.

Definition at line 46 of file PorousFlowUnsaturated.h.

Referenced by act().

_relperm_type

enum PorousFlowUnsaturated::RelpermTypeChoiceEnum PorousFlowUnsaturated::_relperm_type

protected

Referenced by act().

_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 act().

_simulation_type

enum PorousFlowSinglePhaseBase::SimulationTypeChoiceEnum PorousFlowSinglePhaseBase::_simulation_type

protectedinherited

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

_temperature_var

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

protectedinherited

Name of the temperature variable (if any)

Definition at line 61 of file PorousFlowActionBase.h.

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

_use_brine

const bool PorousFlowSinglePhaseBase::_use_brine

protectedinherited

Use PorousFlowBrine material.

Definition at line 60 of file PorousFlowSinglePhaseBase.h.

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

_van_genuchten_alpha

const Real PorousFlowUnsaturated::_van_genuchten_alpha

protected

Van Genuchten alpha parameter.

Definition at line 37 of file PorousFlowUnsaturated.h.

Referenced by act().

_van_genuchten_m

const Real PorousFlowUnsaturated::_van_genuchten_m

protected

Van Genuchten m parameter.

Definition at line 40 of file PorousFlowUnsaturated.h.

Referenced by act().

---

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

• porous_flow/include/actions/PorousFlowUnsaturated.h
• porous_flow/src/actions/PorousFlowUnsaturated.C