Q2PAction Class Reference

#include <Q2PAction.h>

Inheritance diagram for Q2PAction:

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

Private Attributes
VariableName	_pp_var
VariableName	_sat_var
UserObjectName	_water_density
UserObjectName	_water_relperm
UserObjectName	_water_relperm_for_diffusivity
Real	_water_viscosity
UserObjectName	_gas_density
UserObjectName	_gas_relperm
Real	_gas_viscosity
Real	_diffusivity
std::vector< OutputName >	_output_nodal_masses_to
std::vector< OutputName >	_output_total_masses_to
bool	_save_gas_flux_in_Q2PGasFluxResidual
bool	_save_water_flux_in_Q2PWaterFluxResidual
bool	_save_gas_Jacobian_in_Q2PGasJacobian
bool	_save_water_Jacobian_in_Q2PWaterJacobian
bool	_nodal_masses_not_outputted
bool	_total_masses_not_outputted
bool	_no_mass_calculations

Detailed Description

Definition at line 19 of file Q2PAction.h.

Constructor & Destructor Documentation

Q2PAction()

Q2PAction::Q2PAction

(

const InputParameters &

params

)

Definition at line 90 of file Q2PAction.C.

  : Action(params),
    _pp_var(getParam<NonlinearVariableName>("porepressure")),
    _sat_var(getParam<NonlinearVariableName>("saturation")),
    _water_density(getParam<UserObjectName>("water_density")),
    _water_relperm(getParam<UserObjectName>("water_relperm")),
    _water_relperm_for_diffusivity(isParamValid("water_relperm_for_diffusivity")
                                       ? getParam<UserObjectName>("water_relperm_for_diffusivity")
                                       : getParam<UserObjectName>("water_relperm")),
    _water_viscosity(getParam<Real>("water_viscosity")),
    _gas_density(getParam<UserObjectName>("gas_density")),
    _gas_relperm(getParam<UserObjectName>("gas_relperm")),
    _gas_viscosity(getParam<Real>("gas_viscosity")),
    _diffusivity(getParam<Real>("diffusivity")),
    _output_nodal_masses_to(getParam<std::vector<OutputName>>("output_nodal_masses_to")),
    _output_total_masses_to(getParam<std::vector<OutputName>>("output_total_masses_to")),
    _save_gas_flux_in_Q2PGasFluxResidual(getParam<bool>("save_gas_flux_in_Q2PGasFluxResidual")),
    _save_water_flux_in_Q2PWaterFluxResidual(
        getParam<bool>("save_water_flux_in_Q2PWaterFluxResidual")),
    _save_gas_Jacobian_in_Q2PGasJacobian(getParam<bool>("save_gas_Jacobian_in_Q2PGasJacobian")),
    _save_water_Jacobian_in_Q2PWaterJacobian(
        getParam<bool>("save_water_Jacobian_in_Q2PWaterJacobian"))
{
  _nodal_masses_not_outputted = false;
  if (_output_nodal_masses_to.size() == 0)
    _nodal_masses_not_outputted = true;
 
  _total_masses_not_outputted = false;
  if (_output_total_masses_to.size() == 0)
    _total_masses_not_outputted = true;
 
  _no_mass_calculations = (_nodal_masses_not_outputted && _total_masses_not_outputted);
}

Member Function Documentation

act()

void Q2PAction::act ( )

virtual

Definition at line 125 of file Q2PAction.C.

{
  // add the kernels
  if (_current_task == "add_kernel")
  {
    std::string kernel_name;
    std::string kernel_type;
    InputParameters params = _factory.getValidParams("Q2PNodalMass");
 
    kernel_name = "Q2P_nodal_water_mass";
    kernel_type = "Q2PNodalMass";
    params = _factory.getValidParams(kernel_type);
    params.set<NonlinearVariableName>("variable") = _sat_var;
    params.set<std::vector<VariableName>>("other_var") = {_pp_var};
    params.set<bool>("var_is_porepressure") = false;
    if (!_no_mass_calculations)
      params.set<std::vector<AuxVariableName>>("save_in") = {"Q2P_nodal_water_mass_divided_by_dt"};
    params.set<UserObjectName>("fluid_density") = _water_density;
    _problem->addKernel(kernel_type, kernel_name, params);
 
    kernel_name = "Q2P_nodal_gas_mass";
    kernel_type = "Q2PNodalMass";
    params = _factory.getValidParams(kernel_type);
    params.set<NonlinearVariableName>("variable") = _pp_var;
    params.set<std::vector<VariableName>>("other_var") = {_sat_var};
    params.set<bool>("var_is_porepressure") = true;
    if (!_no_mass_calculations)
      params.set<std::vector<AuxVariableName>>("save_in") = {"Q2P_nodal_gas_mass_divided_by_dt"};
    params.set<UserObjectName>("fluid_density") = _gas_density;
    _problem->addKernel(kernel_type, kernel_name, params);
 
    kernel_name = "Q2P_nodal_water_mass_old";
    kernel_type = "Q2PNegativeNodalMassOld";
    params = _factory.getValidParams(kernel_type);
    params.set<NonlinearVariableName>("variable") = _sat_var;
    params.set<std::vector<VariableName>>("other_var") = {_pp_var};
    params.set<bool>("var_is_porepressure") = false;
    params.set<UserObjectName>("fluid_density") = _water_density;
    _problem->addKernel(kernel_type, kernel_name, params);
 
    kernel_name = "Q2P_nodal_gas_mass_old";
    kernel_type = "Q2PNegativeNodalMassOld";
    params = _factory.getValidParams(kernel_type);
    params.set<NonlinearVariableName>("variable") = _pp_var;
    params.set<std::vector<VariableName>>("other_var") = {_sat_var};
    params.set<bool>("var_is_porepressure") = true;
    params.set<UserObjectName>("fluid_density") = _gas_density;
    _problem->addKernel(kernel_type, kernel_name, params);
 
    kernel_name = "Q2P_water_flux";
    kernel_type = "Q2PSaturationFlux";
    params = _factory.getValidParams(kernel_type);
    params.set<NonlinearVariableName>("variable") = _sat_var;
    params.set<std::vector<VariableName>>("porepressure_variable") = {_pp_var};
    params.set<UserObjectName>("fluid_density") = _water_density;
    params.set<UserObjectName>("fluid_relperm") = _water_relperm;
    params.set<Real>("fluid_viscosity") = _water_viscosity;
    if (_save_water_flux_in_Q2PWaterFluxResidual)
      params.set<std::vector<AuxVariableName>>("save_in") = {"Q2PWaterFluxResidual"};
    if (_save_water_Jacobian_in_Q2PWaterJacobian)
      params.set<std::vector<AuxVariableName>>("diag_save_in") = {"Q2PWaterJacobian"};
    _problem->addKernel(kernel_type, kernel_name, params);
 
    kernel_name = "Q2P_gas_flux";
    kernel_type = "Q2PPorepressureFlux";
    params = _factory.getValidParams(kernel_type);
    params.set<NonlinearVariableName>("variable") = _pp_var;
    params.set<std::vector<VariableName>>("saturation_variable") = {_sat_var};
    params.set<UserObjectName>("fluid_density") = _gas_density;
    params.set<UserObjectName>("fluid_relperm") = _gas_relperm;
    params.set<Real>("fluid_viscosity") = _gas_viscosity;
    if (_save_gas_flux_in_Q2PGasFluxResidual)
      params.set<std::vector<AuxVariableName>>("save_in") = {"Q2PGasFluxResidual"};
    if (_save_gas_Jacobian_in_Q2PGasJacobian)
      params.set<std::vector<AuxVariableName>>("diag_save_in") = {"Q2PGasJacobian"};
    _problem->addKernel(kernel_type, kernel_name, params);
 
    kernel_name = "Q2P_liquid_diffusion";
    kernel_type = "Q2PSaturationDiffusion";
    params = _factory.getValidParams(kernel_type);
    params.set<NonlinearVariableName>("variable") = _sat_var;
    params.set<std::vector<VariableName>>("porepressure_variable") = {_pp_var};
    params.set<UserObjectName>("fluid_density") = _water_density;
    params.set<UserObjectName>("fluid_relperm") = _water_relperm_for_diffusivity;
    params.set<Real>("fluid_viscosity") = _water_viscosity;
    params.set<Real>("diffusivity") = _diffusivity;
    _problem->addKernel(kernel_type, kernel_name, params);
  }
 
  if (_current_task == "add_aux_variable")
  {
    FEType fe_type(Utility::string_to_enum<Order>(getParam<MooseEnum>("ORDER")),
                   Utility::string_to_enum<FEFamily>("LAGRANGE"));
    auto type = AddVariableAction::determineType(fe_type, 1);
    auto var_params = _factory.getValidParams(type);
    var_params.set<MooseEnum>("family") = "LAGRANGE";
    var_params.set<MooseEnum>("order") = getParam<MooseEnum>("ORDER");
 
    if (!_no_mass_calculations)
    {
      // user wants nodal masses or total masses
      _problem->addAuxVariable(type, "Q2P_nodal_water_mass_divided_by_dt", var_params);
      _problem->addAuxVariable(type, "Q2P_nodal_gas_mass_divided_by_dt", var_params);
    }
    if (_save_gas_flux_in_Q2PGasFluxResidual)
      _problem->addAuxVariable(type, "Q2PGasFluxResidual", var_params);
    if (_save_water_flux_in_Q2PWaterFluxResidual)
      _problem->addAuxVariable(type, "Q2PWaterFluxResidual", var_params);
    if (_save_gas_Jacobian_in_Q2PGasJacobian)
      _problem->addAuxVariable(type, "Q2PGasJacobian", var_params);
    if (_save_water_Jacobian_in_Q2PWaterJacobian)
      _problem->addAuxVariable(type, "Q2PWaterJacobian", var_params);
  }
 
  if (_current_task == "add_function" && _output_total_masses_to.size() > 0)
  {
    // user wants total masses, so need to build Functions to do this
    InputParameters params = _factory.getValidParams("ParsedFunction");
 
    params.set<std::string>("value") = "a*b";
 
    std::vector<std::string> vars;
    vars.push_back("a");
    vars.push_back("b");
    params.set<std::vector<std::string>>("vars") = vars;
 
    std::vector<std::string> vals_water;
    vals_water.push_back("Q2P_mass_water_divided_by_dt");
    vals_water.push_back("Q2P_dt");
    params.set<std::vector<std::string>>("vals") = vals_water;
    _problem->addFunction("ParsedFunction", "Q2P_water_mass_fcn", params);
 
    std::vector<std::string> vals_gas;
    vals_gas.push_back("Q2P_mass_gas_divided_by_dt");
    vals_gas.push_back("Q2P_dt");
    params.set<std::vector<std::string>>("vals") = vals_gas;
    _problem->addFunction("ParsedFunction", "Q2P_gas_mass_fcn", params);
  }
 
  if (_current_task == "add_postprocessor" && _output_total_masses_to.size() > 0)
  {
    // user wants total masses, so need to build Postprocessors to do this
 
    InputParameters params = _factory.getValidParams("TimestepSize");
 
    params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_BEGIN;
    params.set<std::vector<OutputName>>("outputs") = {"none"};
    _problem->addPostprocessor("TimestepSize", "Q2P_dt", params);
 
    params = _factory.getValidParams("NodalSum");
    params.set<std::vector<OutputName>>("outputs") = {"none"};
    params.set<std::vector<VariableName>>("variable") = {"Q2P_nodal_water_mass_divided_by_dt"};
    _problem->addPostprocessor("NodalSum", "Q2P_mass_water_divided_by_dt", params);
 
    params = _factory.getValidParams("FunctionValuePostprocessor");
    params.set<FunctionName>("function") = "Q2P_water_mass_fcn";
    params.set<std::vector<OutputName>>("outputs") = _output_total_masses_to;
    _problem->addPostprocessor("FunctionValuePostprocessor", "mass_water", params);
 
    params = _factory.getValidParams("NodalSum");
    params.set<std::vector<OutputName>>("outputs") = {"none"};
    params.set<std::vector<VariableName>>("variable") = {"Q2P_nodal_gas_mass_divided_by_dt"};
    _problem->addPostprocessor("NodalSum", "Q2P_mass_gas_divided_by_dt", params);
 
    params = _factory.getValidParams("FunctionValuePostprocessor");
    params.set<FunctionName>("function") = "Q2P_gas_mass_fcn";
    params.set<std::vector<OutputName>>("outputs") = _output_total_masses_to;
    _problem->addPostprocessor("FunctionValuePostprocessor", "mass_gas", params);
  }
}

Member Data Documentation

_diffusivity

Real Q2PAction::_diffusivity

private

Definition at line 36 of file Q2PAction.h.

Referenced by act().

_gas_density

UserObjectName Q2PAction::_gas_density

private

Definition at line 33 of file Q2PAction.h.

Referenced by act().

_gas_relperm

UserObjectName Q2PAction::_gas_relperm

private

Definition at line 34 of file Q2PAction.h.

Referenced by act().

_gas_viscosity

Real Q2PAction::_gas_viscosity

private

Definition at line 35 of file Q2PAction.h.

Referenced by act().

_no_mass_calculations

bool Q2PAction::_no_mass_calculations

private

Definition at line 45 of file Q2PAction.h.

Referenced by act(), and Q2PAction().

_nodal_masses_not_outputted

bool Q2PAction::_nodal_masses_not_outputted

private

Definition at line 43 of file Q2PAction.h.

Referenced by Q2PAction().

_output_nodal_masses_to

std::vector<OutputName> Q2PAction::_output_nodal_masses_to

private

Definition at line 37 of file Q2PAction.h.

Referenced by Q2PAction().

_output_total_masses_to

std::vector<OutputName> Q2PAction::_output_total_masses_to

private

Definition at line 38 of file Q2PAction.h.

Referenced by act(), and Q2PAction().

_pp_var

VariableName Q2PAction::_pp_var

private

Definition at line 27 of file Q2PAction.h.

Referenced by act().

_sat_var

VariableName Q2PAction::_sat_var

private

Definition at line 28 of file Q2PAction.h.

Referenced by act().

_save_gas_flux_in_Q2PGasFluxResidual

bool Q2PAction::_save_gas_flux_in_Q2PGasFluxResidual

private

Definition at line 39 of file Q2PAction.h.

Referenced by act().

_save_gas_Jacobian_in_Q2PGasJacobian

bool Q2PAction::_save_gas_Jacobian_in_Q2PGasJacobian

private

Definition at line 41 of file Q2PAction.h.

Referenced by act().

_save_water_flux_in_Q2PWaterFluxResidual

bool Q2PAction::_save_water_flux_in_Q2PWaterFluxResidual

private

Definition at line 40 of file Q2PAction.h.

Referenced by act().

_save_water_Jacobian_in_Q2PWaterJacobian

bool Q2PAction::_save_water_Jacobian_in_Q2PWaterJacobian

private

Definition at line 42 of file Q2PAction.h.

Referenced by act().

_total_masses_not_outputted

bool Q2PAction::_total_masses_not_outputted

private

Definition at line 44 of file Q2PAction.h.

Referenced by Q2PAction().

_water_density

UserObjectName Q2PAction::_water_density

private

Definition at line 29 of file Q2PAction.h.

Referenced by act().

_water_relperm

UserObjectName Q2PAction::_water_relperm

private

Definition at line 30 of file Q2PAction.h.

Referenced by act().

_water_relperm_for_diffusivity

UserObjectName Q2PAction::_water_relperm_for_diffusivity

private

Definition at line 31 of file Q2PAction.h.

Referenced by act().

_water_viscosity

Real Q2PAction::_water_viscosity

private

Definition at line 32 of file Q2PAction.h.

Referenced by act().

---

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

• richards/include/actions/Q2PAction.h
• richards/src/actions/Q2PAction.C