www.mooseframework.org
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Attributes | List of all members
Q2PAction Class Reference

#include <Q2PAction.h>

Inheritance diagram for Q2PAction:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 Q2PAction (const InputParameters &params)
 
virtual void act ()
 
void timedAct ()
 
virtual void addRelationshipManagers (Moose::RelationshipManagerType when_type)
 
MooseObjectName uniqueActionName () const
 
const std::string & specificTaskName () const
 
const std::set< std::string > & getAllTasks () const
 
void appendTask (const std::string &task)
 
MooseAppgetMooseApp () const
 
const std::string & type () const
 
virtual const std::string & name () const
 
std::string typeAndName () const
 
std::string errorPrefix (const std::string &error_type) const
 
void callMooseError (std::string msg, const bool with_prefix) const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
const InputParametersparameters () const
 
MooseObjectName uniqueName () const
 
const T & getParam (const std::string &name) const
 
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 
getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 
bool isParamValid (const std::string &name) const
 
bool isParamSetByUser (const std::string &nm) const
 
void paramError (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramInfo (const std::string &param, Args... args) const
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void mooseError (Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseInfo (Args &&... args) const
 
PerfGraphperfGraph ()
 
std::string getDataFileName (const std::string &param) const
 
std::string getDataFileNameByName (const std::string &name, const std::string *param=nullptr) const
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static InputParameters validParams ()
 

Public Attributes

const ConsoleStream _console
 

Static Public Attributes

static constexpr auto SYSTEM
 
static constexpr auto NAME
 

Protected Member Functions

bool addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
 
void associateWithParameter (const std::string &param_name, InputParameters &params) const
 
void associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const
 
const T & getMeshProperty (const std::string &data_name, const std::string &prefix)
 
const T & getMeshProperty (const std::string &data_name)
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name) const
 
bool hasMeshProperty (const std::string &data_name) const
 
std::string meshPropertyName (const std::string &data_name) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 
std::string timedSectionName (const std::string &section_name) const
 

Static Protected Member Functions

static std::string meshPropertyName (const std::string &data_name, const std::string &prefix)
 

Protected Attributes

std::string _registered_identifier
 
std::string _specific_task_name
 
std::set< std::string > _all_tasks
 
ActionWarehouse_awh
 
const std::string & _current_task
 
std::shared_ptr< MooseMesh > & _mesh
 
std::shared_ptr< MooseMesh > & _displaced_mesh
 
std::shared_ptr< FEProblemBase > & _problem
 
PerfID _act_timer
 
MooseApp_app
 
const std::string _type
 
const std::string _name
 
const InputParameters_pars
 
Factory_factory
 
ActionFactory_action_factory
 
MooseApp_pg_moose_app
 
const std::string _prefix
 
const Parallel::Communicator & _communicator
 

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 14 of file Q2PAction.h.

Constructor & Destructor Documentation

◆ Q2PAction()

Q2PAction::Q2PAction ( const InputParameters params)

Definition at line 91 of file Q2PAction.C.

92  : Action(params),
93  _pp_var(getParam<NonlinearVariableName>("porepressure")),
94  _sat_var(getParam<NonlinearVariableName>("saturation")),
95  _water_density(getParam<UserObjectName>("water_density")),
96  _water_relperm(getParam<UserObjectName>("water_relperm")),
97  _water_relperm_for_diffusivity(isParamValid("water_relperm_for_diffusivity")
98  ? getParam<UserObjectName>("water_relperm_for_diffusivity")
99  : getParam<UserObjectName>("water_relperm")),
100  _water_viscosity(getParam<Real>("water_viscosity")),
101  _gas_density(getParam<UserObjectName>("gas_density")),
102  _gas_relperm(getParam<UserObjectName>("gas_relperm")),
103  _gas_viscosity(getParam<Real>("gas_viscosity")),
104  _diffusivity(getParam<Real>("diffusivity")),
105  _output_nodal_masses_to(getParam<std::vector<OutputName>>("output_nodal_masses_to")),
106  _output_total_masses_to(getParam<std::vector<OutputName>>("output_total_masses_to")),
107  _save_gas_flux_in_Q2PGasFluxResidual(getParam<bool>("save_gas_flux_in_Q2PGasFluxResidual")),
109  getParam<bool>("save_water_flux_in_Q2PWaterFluxResidual")),
110  _save_gas_Jacobian_in_Q2PGasJacobian(getParam<bool>("save_gas_Jacobian_in_Q2PGasJacobian")),
112  getParam<bool>("save_water_Jacobian_in_Q2PWaterJacobian"))
113 {
115  if (_output_nodal_masses_to.size() == 0)
117 
119  if (_output_total_masses_to.size() == 0)
121 
123 }
Real _diffusivity
Definition: Q2PAction.h:33
Real _gas_viscosity
Definition: Q2PAction.h:32
UserObjectName _water_density
Definition: Q2PAction.h:26
bool _total_masses_not_outputted
Definition: Q2PAction.h:41
Action(const InputParameters &parameters)
std::vector< OutputName > _output_total_masses_to
Definition: Q2PAction.h:35
UserObjectName _water_relperm
Definition: Q2PAction.h:27
std::vector< OutputName > _output_nodal_masses_to
Definition: Q2PAction.h:34
bool _save_gas_Jacobian_in_Q2PGasJacobian
Definition: Q2PAction.h:38
UserObjectName _water_relperm_for_diffusivity
Definition: Q2PAction.h:28
bool isParamValid(const std::string &name) const
bool _save_water_Jacobian_in_Q2PWaterJacobian
Definition: Q2PAction.h:39
bool _save_water_flux_in_Q2PWaterFluxResidual
Definition: Q2PAction.h:37
Real _water_viscosity
Definition: Q2PAction.h:29
bool _save_gas_flux_in_Q2PGasFluxResidual
Definition: Q2PAction.h:36
UserObjectName _gas_density
Definition: Q2PAction.h:30
VariableName _pp_var
Definition: Q2PAction.h:24
VariableName _sat_var
Definition: Q2PAction.h:25
const T & getParam(const std::string &name) const
bool _nodal_masses_not_outputted
Definition: Q2PAction.h:40
bool _no_mass_calculations
Definition: Q2PAction.h:42
UserObjectName _gas_relperm
Definition: Q2PAction.h:31

Member Function Documentation

◆ act()

void Q2PAction::act ( )
virtual

Implements Action.

Definition at line 126 of file Q2PAction.C.

127 {
128  // add the kernels
129  if (_current_task == "add_kernel")
130  {
131  std::string kernel_name;
132  std::string kernel_type;
133  InputParameters params = _factory.getValidParams("Q2PNodalMass");
134 
135  kernel_name = "Q2P_nodal_water_mass";
136  kernel_type = "Q2PNodalMass";
137  params = _factory.getValidParams(kernel_type);
138  params.set<NonlinearVariableName>("variable") = _sat_var;
139  params.set<std::vector<VariableName>>("other_var") = {_pp_var};
140  params.set<bool>("var_is_porepressure") = false;
142  params.set<std::vector<AuxVariableName>>("save_in") = {"Q2P_nodal_water_mass_divided_by_dt"};
143  params.set<UserObjectName>("fluid_density") = _water_density;
144  _problem->addKernel(kernel_type, kernel_name, params);
145 
146  kernel_name = "Q2P_nodal_gas_mass";
147  kernel_type = "Q2PNodalMass";
148  params = _factory.getValidParams(kernel_type);
149  params.set<NonlinearVariableName>("variable") = _pp_var;
150  params.set<std::vector<VariableName>>("other_var") = {_sat_var};
151  params.set<bool>("var_is_porepressure") = true;
153  params.set<std::vector<AuxVariableName>>("save_in") = {"Q2P_nodal_gas_mass_divided_by_dt"};
154  params.set<UserObjectName>("fluid_density") = _gas_density;
155  _problem->addKernel(kernel_type, kernel_name, params);
156 
157  kernel_name = "Q2P_nodal_water_mass_old";
158  kernel_type = "Q2PNegativeNodalMassOld";
159  params = _factory.getValidParams(kernel_type);
160  params.set<NonlinearVariableName>("variable") = _sat_var;
161  params.set<std::vector<VariableName>>("other_var") = {_pp_var};
162  params.set<bool>("var_is_porepressure") = false;
163  params.set<UserObjectName>("fluid_density") = _water_density;
164  _problem->addKernel(kernel_type, kernel_name, params);
165 
166  kernel_name = "Q2P_nodal_gas_mass_old";
167  kernel_type = "Q2PNegativeNodalMassOld";
168  params = _factory.getValidParams(kernel_type);
169  params.set<NonlinearVariableName>("variable") = _pp_var;
170  params.set<std::vector<VariableName>>("other_var") = {_sat_var};
171  params.set<bool>("var_is_porepressure") = true;
172  params.set<UserObjectName>("fluid_density") = _gas_density;
173  _problem->addKernel(kernel_type, kernel_name, params);
174 
175  kernel_name = "Q2P_water_flux";
176  kernel_type = "Q2PSaturationFlux";
177  params = _factory.getValidParams(kernel_type);
178  params.set<NonlinearVariableName>("variable") = _sat_var;
179  params.set<std::vector<VariableName>>("porepressure_variable") = {_pp_var};
180  params.set<UserObjectName>("fluid_density") = _water_density;
181  params.set<UserObjectName>("fluid_relperm") = _water_relperm;
182  params.set<Real>("fluid_viscosity") = _water_viscosity;
184  params.set<std::vector<AuxVariableName>>("save_in") = {"Q2PWaterFluxResidual"};
186  params.set<std::vector<AuxVariableName>>("diag_save_in") = {"Q2PWaterJacobian"};
187  _problem->addKernel(kernel_type, kernel_name, params);
188 
189  kernel_name = "Q2P_gas_flux";
190  kernel_type = "Q2PPorepressureFlux";
191  params = _factory.getValidParams(kernel_type);
192  params.set<NonlinearVariableName>("variable") = _pp_var;
193  params.set<std::vector<VariableName>>("saturation_variable") = {_sat_var};
194  params.set<UserObjectName>("fluid_density") = _gas_density;
195  params.set<UserObjectName>("fluid_relperm") = _gas_relperm;
196  params.set<Real>("fluid_viscosity") = _gas_viscosity;
198  params.set<std::vector<AuxVariableName>>("save_in") = {"Q2PGasFluxResidual"};
200  params.set<std::vector<AuxVariableName>>("diag_save_in") = {"Q2PGasJacobian"};
201  _problem->addKernel(kernel_type, kernel_name, params);
202 
203  kernel_name = "Q2P_liquid_diffusion";
204  kernel_type = "Q2PSaturationDiffusion";
205  params = _factory.getValidParams(kernel_type);
206  params.set<NonlinearVariableName>("variable") = _sat_var;
207  params.set<std::vector<VariableName>>("porepressure_variable") = {_pp_var};
208  params.set<UserObjectName>("fluid_density") = _water_density;
209  params.set<UserObjectName>("fluid_relperm") = _water_relperm_for_diffusivity;
210  params.set<Real>("fluid_viscosity") = _water_viscosity;
211  params.set<Real>("diffusivity") = _diffusivity;
212  _problem->addKernel(kernel_type, kernel_name, params);
213  }
214 
215  if (_current_task == "add_aux_variable")
216  {
217  FEType fe_type(Utility::string_to_enum<Order>(getParam<MooseEnum>("ORDER")),
218  Utility::string_to_enum<FEFamily>("LAGRANGE"));
219  auto type = AddVariableAction::variableType(fe_type);
220  auto var_params = _factory.getValidParams(type);
221  var_params.set<MooseEnum>("family") = "LAGRANGE";
222  var_params.set<MooseEnum>("order") = getParam<MooseEnum>("ORDER");
223 
225  {
226  // user wants nodal masses or total masses
227  _problem->addAuxVariable(type, "Q2P_nodal_water_mass_divided_by_dt", var_params);
228  _problem->addAuxVariable(type, "Q2P_nodal_gas_mass_divided_by_dt", var_params);
229  }
231  _problem->addAuxVariable(type, "Q2PGasFluxResidual", var_params);
233  _problem->addAuxVariable(type, "Q2PWaterFluxResidual", var_params);
235  _problem->addAuxVariable(type, "Q2PGasJacobian", var_params);
237  _problem->addAuxVariable(type, "Q2PWaterJacobian", var_params);
238  }
239 
240  if (_current_task == "add_function" && _output_total_masses_to.size() > 0)
241  {
242  // user wants total masses, so need to build Functions to do this
243  InputParameters params = _factory.getValidParams("ParsedFunction");
244 
245  params.set<std::string>("value") = "a*b";
246 
247  std::vector<std::string> vars;
248  vars.push_back("a");
249  vars.push_back("b");
250  params.set<std::vector<std::string>>("vars") = vars;
251 
252  std::vector<std::string> vals_water;
253  vals_water.push_back("Q2P_mass_water_divided_by_dt");
254  vals_water.push_back("Q2P_dt");
255  params.set<std::vector<std::string>>("vals") = vals_water;
256  _problem->addFunction("ParsedFunction", "Q2P_water_mass_fcn", params);
257 
258  std::vector<std::string> vals_gas;
259  vals_gas.push_back("Q2P_mass_gas_divided_by_dt");
260  vals_gas.push_back("Q2P_dt");
261  params.set<std::vector<std::string>>("vals") = vals_gas;
262  _problem->addFunction("ParsedFunction", "Q2P_gas_mass_fcn", params);
263  }
264 
265  if (_current_task == "add_postprocessor" && _output_total_masses_to.size() > 0)
266  {
267  // user wants total masses, so need to build Postprocessors to do this
268 
269  InputParameters params = _factory.getValidParams("TimestepSize");
270 
271  params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_BEGIN;
272  params.set<std::vector<OutputName>>("outputs") = {"none"};
273  _problem->addPostprocessor("TimestepSize", "Q2P_dt", params);
274 
275  params = _factory.getValidParams("NodalSum");
276  params.set<std::vector<OutputName>>("outputs") = {"none"};
277  params.set<std::vector<VariableName>>("variable") = {"Q2P_nodal_water_mass_divided_by_dt"};
278  _problem->addPostprocessor("NodalSum", "Q2P_mass_water_divided_by_dt", params);
279 
280  params = _factory.getValidParams("FunctionValuePostprocessor");
281  params.set<FunctionName>("function") = "Q2P_water_mass_fcn";
282  params.set<std::vector<OutputName>>("outputs") = _output_total_masses_to;
283  _problem->addPostprocessor("FunctionValuePostprocessor", "mass_water", params);
284 
285  params = _factory.getValidParams("NodalSum");
286  params.set<std::vector<OutputName>>("outputs") = {"none"};
287  params.set<std::vector<VariableName>>("variable") = {"Q2P_nodal_gas_mass_divided_by_dt"};
288  _problem->addPostprocessor("NodalSum", "Q2P_mass_gas_divided_by_dt", params);
289 
290  params = _factory.getValidParams("FunctionValuePostprocessor");
291  params.set<FunctionName>("function") = "Q2P_gas_mass_fcn";
292  params.set<std::vector<OutputName>>("outputs") = _output_total_masses_to;
293  _problem->addPostprocessor("FunctionValuePostprocessor", "mass_gas", params);
294  }
295 }
Real _diffusivity
Definition: Q2PAction.h:33
Real _gas_viscosity
Definition: Q2PAction.h:32
UserObjectName _water_density
Definition: Q2PAction.h:26
static std::string variableType(const FEType &fe_type, const bool is_fv=false, const bool is_array=false)
std::vector< OutputName > _output_total_masses_to
Definition: Q2PAction.h:35
UserObjectName _water_relperm
Definition: Q2PAction.h:27
T & set(const std::string &name, bool quiet_mode=false)
InputParameters getValidParams(const std::string &name) const
bool _save_gas_Jacobian_in_Q2PGasJacobian
Definition: Q2PAction.h:38
UserObjectName _water_relperm_for_diffusivity
Definition: Q2PAction.h:28
Factory & _factory
bool _save_water_Jacobian_in_Q2PWaterJacobian
Definition: Q2PAction.h:39
bool _save_water_flux_in_Q2PWaterFluxResidual
Definition: Q2PAction.h:37
Real _water_viscosity
Definition: Q2PAction.h:29
bool _save_gas_flux_in_Q2PGasFluxResidual
Definition: Q2PAction.h:36
UserObjectName _gas_density
Definition: Q2PAction.h:30
VariableName _pp_var
Definition: Q2PAction.h:24
VariableName _sat_var
Definition: Q2PAction.h:25
const std::string & type() const
const std::string & _current_task
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
std::shared_ptr< FEProblemBase > & _problem
bool _no_mass_calculations
Definition: Q2PAction.h:42
UserObjectName _gas_relperm
Definition: Q2PAction.h:31

◆ validParams()

InputParameters Q2PAction::validParams ( )
static

Definition at line 27 of file Q2PAction.C.

28 {
29  MooseEnum orders("CONSTANT FIRST SECOND THIRD FOURTH", "FIRST");
30 
32  params.addRequiredParam<NonlinearVariableName>("porepressure", "The porepressure variable");
33  params.addRequiredParam<NonlinearVariableName>("saturation", "The water saturation variable");
34  params.addRequiredParam<UserObjectName>(
35  "water_density",
36  "A RichardsDensity UserObject that defines the water density as a function of porepressure.");
37  params.addRequiredParam<UserObjectName>(
38  "water_relperm",
39  "A RichardsRelPerm UserObject that defines the water relative permeability "
40  "as a function of water saturation (eg RichardsRelPermPower).");
41  params.addParam<UserObjectName>(
42  "water_relperm_for_diffusion",
43  "A RichardsRelPerm UserObject that defines the water relative permeability as a function of "
44  "water saturation that will be used in the diffusivity Kernel (eg RichardsRelPermPower). If "
45  "not given, water_relperm will be used instead, which is the most common use-case.");
46  params.addRequiredParam<Real>("water_viscosity", "The water viscosity");
47  params.addRequiredParam<UserObjectName>(
48  "gas_density",
49  "A RichardsDensity UserObject that defines the gas density as a function of porepressure.");
50  params.addRequiredParam<UserObjectName>(
51  "gas_relperm",
52  "A RichardsRelPerm UserObject that defines the gas relative permeability as a "
53  "function of water saturation (eg Q2PRelPermPowerGas).");
54  params.addRequiredParam<Real>("gas_viscosity", "The gas viscosity");
55  params.addRequiredParam<Real>("diffusivity", "The diffusivity");
56  params.addParam<std::vector<OutputName>>("output_nodal_masses_to",
57  {},
58  "Output Nodal masses to this Output object. If you "
59  "don't want any outputs, don't input anything here");
60  params.addParam<std::vector<OutputName>>(
61  "output_total_masses_to",
62  {},
63  "Output total water and gas mass to this Output object. If you "
64  "don't want any outputs, don't input anything here");
65  params.addParam<bool>("save_gas_flux_in_Q2PGasFluxResidual",
66  false,
67  "Save the residual for the "
68  "Q2PPorepressureFlux into "
69  "the AuxVariable called "
70  "Q2PGasFluxResidual");
71  params.addParam<bool>("save_water_flux_in_Q2PWaterFluxResidual",
72  false,
73  "Save the residual for the Q2PSaturationFlux into the AuxVariable called "
74  "Q2PWaterFluxResidual");
75  params.addParam<bool>("save_gas_Jacobian_in_Q2PGasJacobian",
76  false,
77  "Save the diagonal component of the Q2PPorepressureFlux Jacobian into the "
78  "AuxVariable called Q2PGasJacobian");
79  params.addParam<bool>("save_water_Jacobian_in_Q2PWaterJacobian",
80  false,
81  "Save the diagonal component of the Q2PSaturationFlux Jacobian into the "
82  "AuxVariable called Q2PWaterJacobian");
83  params.addParam<MooseEnum>(
84  "ORDER",
85  orders,
86  "The order for the porepressure and saturation: " + orders.getRawNames() +
87  " (only needed if you're calculating masses)");
88  return params;
89 }
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
std::string getRawNames() const
void addRequiredParam(const std::string &name, const std::string &doc_string)
static InputParameters validParams()
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

Member Data Documentation

◆ _diffusivity

Real Q2PAction::_diffusivity
private

Definition at line 33 of file Q2PAction.h.

Referenced by act().

◆ _gas_density

UserObjectName Q2PAction::_gas_density
private

Definition at line 30 of file Q2PAction.h.

Referenced by act().

◆ _gas_relperm

UserObjectName Q2PAction::_gas_relperm
private

Definition at line 31 of file Q2PAction.h.

Referenced by act().

◆ _gas_viscosity

Real Q2PAction::_gas_viscosity
private

Definition at line 32 of file Q2PAction.h.

Referenced by act().

◆ _no_mass_calculations

bool Q2PAction::_no_mass_calculations
private

Definition at line 42 of file Q2PAction.h.

Referenced by act(), and Q2PAction().

◆ _nodal_masses_not_outputted

bool Q2PAction::_nodal_masses_not_outputted
private

Definition at line 40 of file Q2PAction.h.

Referenced by Q2PAction().

◆ _output_nodal_masses_to

std::vector<OutputName> Q2PAction::_output_nodal_masses_to
private

Definition at line 34 of file Q2PAction.h.

Referenced by Q2PAction().

◆ _output_total_masses_to

std::vector<OutputName> Q2PAction::_output_total_masses_to
private

Definition at line 35 of file Q2PAction.h.

Referenced by act(), and Q2PAction().

◆ _pp_var

VariableName Q2PAction::_pp_var
private

Definition at line 24 of file Q2PAction.h.

Referenced by act().

◆ _sat_var

VariableName Q2PAction::_sat_var
private

Definition at line 25 of file Q2PAction.h.

Referenced by act().

◆ _save_gas_flux_in_Q2PGasFluxResidual

bool Q2PAction::_save_gas_flux_in_Q2PGasFluxResidual
private

Definition at line 36 of file Q2PAction.h.

Referenced by act().

◆ _save_gas_Jacobian_in_Q2PGasJacobian

bool Q2PAction::_save_gas_Jacobian_in_Q2PGasJacobian
private

Definition at line 38 of file Q2PAction.h.

Referenced by act().

◆ _save_water_flux_in_Q2PWaterFluxResidual

bool Q2PAction::_save_water_flux_in_Q2PWaterFluxResidual
private

Definition at line 37 of file Q2PAction.h.

Referenced by act().

◆ _save_water_Jacobian_in_Q2PWaterJacobian

bool Q2PAction::_save_water_Jacobian_in_Q2PWaterJacobian
private

Definition at line 39 of file Q2PAction.h.

Referenced by act().

◆ _total_masses_not_outputted

bool Q2PAction::_total_masses_not_outputted
private

Definition at line 41 of file Q2PAction.h.

Referenced by Q2PAction().

◆ _water_density

UserObjectName Q2PAction::_water_density
private

Definition at line 26 of file Q2PAction.h.

Referenced by act().

◆ _water_relperm

UserObjectName Q2PAction::_water_relperm
private

Definition at line 27 of file Q2PAction.h.

Referenced by act().

◆ _water_relperm_for_diffusivity

UserObjectName Q2PAction::_water_relperm_for_diffusivity
private

Definition at line 28 of file Q2PAction.h.

Referenced by act().

◆ _water_viscosity

Real Q2PAction::_water_viscosity
private

Definition at line 29 of file Q2PAction.h.

Referenced by act().


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