www.mooseframework.org
PorousFlowActionBase.C
Go to the documentation of this file.
1 /****************************************************************/
2 /* MOOSE - Multiphysics Object Oriented Simulation Environment */
3 /* */
4 /* All contents are licensed under LGPL V2.1 */
5 /* See LICENSE for full restrictions */
6 /****************************************************************/
7 #include "PorousFlowActionBase.h"
8 
9 #include "FEProblem.h"
10 #include "MooseMesh.h"
11 #include "libmesh/string_to_enum.h"
12 #include "Conversion.h"
13 
14 template <>
15 InputParameters
17 {
18  InputParameters params = validParams<Action>();
19  params.addParam<std::string>(
20  "dictator_name",
21  "dictator",
22  "The name of the dictator user object that is created by this Action");
23  params.addClassDescription("Adds the PorousFlowDictator UserObject. This class also contains "
24  "many utility functions for adding other pieces of an input file, "
25  "which may be used by derived classes.");
26  params.addParam<RealVectorValue>("gravity",
27  RealVectorValue(0.0, 0.0, -10.0),
28  "Gravitational acceleration vector downwards (m/s^2)");
29  params.addCoupledVar("temperature",
30  293.0,
31  "For isothermal simulations, this is the temperature "
32  "at which fluid properties (and stress-free strains) "
33  "are evaluated at. Otherwise, this is the name of "
34  "the temperature variable. Units = Kelvin");
35  params.addCoupledVar("mass_fraction_vars",
36  "List of variables that represent the mass fractions. Format is 'f_ph0^c0 "
37  "f_ph0^c1 f_ph0^c2 ... f_ph0^c(N-1) f_ph1^c0 f_ph1^c1 fph1^c2 ... "
38  "fph1^c(N-1) ... fphP^c0 f_phP^c1 fphP^c2 ... fphP^c(N-1)' where "
39  "N=num_components and P=num_phases, and it is assumed that "
40  "f_ph^cN=1-sum(f_ph^c,{c,0,N-1}) so that f_ph^cN need not be given. If no "
41  "variables are provided then num_phases=1=num_components.");
42  params.addParam<std::vector<NonlinearVariableName>>(
43  "displacements",
44  "The name of the displacement variables (relevant only for "
45  "mechanically-coupled simulations)");
46  params.addParam<std::string>("thermal_eigenstrain_name",
47  "thermal_eigenstrain",
48  "The eigenstrain_name used in the "
49  "ComputeThermalExpansionEigenstrain. Only needed for "
50  "thermally-coupled simulations with thermal expansion.");
51  params.addParam<bool>(
52  "use_displaced_mesh", false, "Use displaced mesh computations in mechanical kernels");
53  return params;
54 }
55 
56 PorousFlowActionBase::PorousFlowActionBase(const InputParameters & params)
57  : Action(params),
59  _objects_to_add(),
60  _dictator_name(getParam<std::string>("dictator_name")),
61  _gravity(getParam<RealVectorValue>("gravity")),
62  _mass_fraction_vars(getParam<std::vector<VariableName>>("mass_fraction_vars")),
63  _num_mass_fraction_vars(_mass_fraction_vars.size()),
64  _temperature_var(getParam<std::vector<VariableName>>("temperature")),
65  _displacements(getParam<std::vector<NonlinearVariableName>>("displacements")),
66  _ndisp(_displacements.size()),
67  _coupled_displacements(_ndisp)
68 {
69  // convert vector of NonlinearVariableName to vector of VariableName
70  for (unsigned int i = 0; i < _ndisp; ++i)
72 }
73 
74 void
76 {
77  const auto & all_subdomains = _problem->mesh().meshSubdomains();
78  if (all_subdomains.empty())
79  mooseError("No subdomains found");
80  _coord_system = _problem->getCoordSystem(*all_subdomains.begin());
81  for (const auto & subdomain : all_subdomains)
82  if (_problem->getCoordSystem(subdomain) != _coord_system)
83  mooseError(
84  "The PorousFlow Actions require all subdomains to have the same coordinate system.");
85 
86  if (_current_task == "add_user_object")
87  addDictator();
88 }
89 
90 void
92 {
93  std::string phase_str = Moose::stringify(phase);
94 
95  if (_current_task == "add_aux_variable")
96  _problem->addAuxVariable("saturation" + phase_str,
97  FEType(Utility::string_to_enum<Order>("CONSTANT"),
98  Utility::string_to_enum<FEFamily>("MONOMIAL")));
99 
100  if (_current_task == "add_aux_kernel")
101  {
102  std::string aux_kernel_type = "MaterialStdVectorAux";
103  InputParameters params = _factory.getValidParams(aux_kernel_type);
104 
105  std::string aux_kernel_name = "PorousFlowActionBase_SaturationAux" + phase_str;
106  params.set<MaterialPropertyName>("property") = "PorousFlow_saturation_qp";
107  params.set<unsigned>("index") = phase;
108  params.set<AuxVariableName>("variable") = "saturation" + phase_str;
109  params.set<MultiMooseEnum>("execute_on") = "timestep_end";
110  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
111  }
112 }
113 
114 void
115 PorousFlowActionBase::addDarcyAux(const RealVectorValue & gravity)
116 {
117  if (_current_task == "add_aux_variable")
118  {
119  _problem->addAuxVariable("darcy_vel_x",
120  FEType(Utility::string_to_enum<Order>("CONSTANT"),
121  Utility::string_to_enum<FEFamily>("MONOMIAL")));
122  _problem->addAuxVariable("darcy_vel_y",
123  FEType(Utility::string_to_enum<Order>("CONSTANT"),
124  Utility::string_to_enum<FEFamily>("MONOMIAL")));
125  _problem->addAuxVariable("darcy_vel_z",
126  FEType(Utility::string_to_enum<Order>("CONSTANT"),
127  Utility::string_to_enum<FEFamily>("MONOMIAL")));
128  }
129 
130  if (_current_task == "add_aux_kernel")
131  {
132  std::string aux_kernel_type = "PorousFlowDarcyVelocityComponent";
133  InputParameters params = _factory.getValidParams(aux_kernel_type);
134 
135  params.set<RealVectorValue>("gravity") = gravity;
136  params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
137  params.set<MultiMooseEnum>("execute_on") = "timestep_end";
138 
139  std::string aux_kernel_name = "PorousFlowActionBase_Darcy_x_Aux";
140  params.set<MooseEnum>("component") = "x";
141  params.set<AuxVariableName>("variable") = "darcy_vel_x";
142  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
143 
144  aux_kernel_name = "PorousFlowActionBase_Darcy_y_Aux";
145  params.set<MooseEnum>("component") = "y";
146  params.set<AuxVariableName>("variable") = "darcy_vel_y";
147  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
148 
149  aux_kernel_name = "PorousFlowActionBase_Darcy_z_Aux";
150  params.set<MooseEnum>("component") = "z";
151  params.set<AuxVariableName>("variable") = "darcy_vel_z";
152  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
153  }
154 }
155 
156 void
158 {
159  if (_current_task == "add_aux_variable")
160  {
161  _problem->addAuxVariable("stress_xx",
162  FEType(Utility::string_to_enum<Order>("CONSTANT"),
163  Utility::string_to_enum<FEFamily>("MONOMIAL")));
164  _problem->addAuxVariable("stress_xy",
165  FEType(Utility::string_to_enum<Order>("CONSTANT"),
166  Utility::string_to_enum<FEFamily>("MONOMIAL")));
167  _problem->addAuxVariable("stress_xz",
168  FEType(Utility::string_to_enum<Order>("CONSTANT"),
169  Utility::string_to_enum<FEFamily>("MONOMIAL")));
170  _problem->addAuxVariable("stress_yx",
171  FEType(Utility::string_to_enum<Order>("CONSTANT"),
172  Utility::string_to_enum<FEFamily>("MONOMIAL")));
173  _problem->addAuxVariable("stress_yy",
174  FEType(Utility::string_to_enum<Order>("CONSTANT"),
175  Utility::string_to_enum<FEFamily>("MONOMIAL")));
176  _problem->addAuxVariable("stress_yz",
177  FEType(Utility::string_to_enum<Order>("CONSTANT"),
178  Utility::string_to_enum<FEFamily>("MONOMIAL")));
179  _problem->addAuxVariable("stress_zx",
180  FEType(Utility::string_to_enum<Order>("CONSTANT"),
181  Utility::string_to_enum<FEFamily>("MONOMIAL")));
182  _problem->addAuxVariable("stress_zy",
183  FEType(Utility::string_to_enum<Order>("CONSTANT"),
184  Utility::string_to_enum<FEFamily>("MONOMIAL")));
185  _problem->addAuxVariable("stress_zz",
186  FEType(Utility::string_to_enum<Order>("CONSTANT"),
187  Utility::string_to_enum<FEFamily>("MONOMIAL")));
188  }
189 
190  if (_current_task == "add_aux_kernel")
191  {
192  std::string aux_kernel_type = "RankTwoAux";
193  InputParameters params = _factory.getValidParams(aux_kernel_type);
194 
195  params.set<MaterialPropertyName>("rank_two_tensor") = "stress";
196  params.set<MultiMooseEnum>("execute_on") = "timestep_end";
197 
198  std::string aux_kernel_name = "PorousFlowAction_stress_xx";
199  params.set<AuxVariableName>("variable") = "stress_xx";
200  params.set<unsigned>("index_i") = 0;
201  params.set<unsigned>("index_j") = 0;
202  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
203 
204  aux_kernel_name = "PorousFlowAction_stress_xy";
205  params.set<AuxVariableName>("variable") = "stress_xy";
206  params.set<unsigned>("index_i") = 0;
207  params.set<unsigned>("index_j") = 1;
208  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
209 
210  aux_kernel_name = "PorousFlowAction_stress_xz";
211  params.set<AuxVariableName>("variable") = "stress_xz";
212  params.set<unsigned>("index_i") = 0;
213  params.set<unsigned>("index_j") = 2;
214  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
215 
216  aux_kernel_name = "PorousFlowAction_stress_yx";
217  params.set<AuxVariableName>("variable") = "stress_yx";
218  params.set<unsigned>("index_i") = 1;
219  params.set<unsigned>("index_j") = 0;
220  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
221 
222  aux_kernel_name = "PorousFlowAction_stress_yy";
223  params.set<AuxVariableName>("variable") = "stress_yy";
224  params.set<unsigned>("index_i") = 1;
225  params.set<unsigned>("index_j") = 1;
226  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
227 
228  aux_kernel_name = "PorousFlowAction_stress_yz";
229  params.set<AuxVariableName>("variable") = "stress_yz";
230  params.set<unsigned>("index_i") = 1;
231  params.set<unsigned>("index_j") = 2;
232  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
233 
234  aux_kernel_name = "PorousFlowAction_stress_zx";
235  params.set<AuxVariableName>("variable") = "stress_zx";
236  params.set<unsigned>("index_i") = 2;
237  params.set<unsigned>("index_j") = 0;
238  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
239 
240  aux_kernel_name = "PorousFlowAction_stress_zy";
241  params.set<AuxVariableName>("variable") = "stress_zy";
242  params.set<unsigned>("index_i") = 2;
243  params.set<unsigned>("index_j") = 1;
244  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
245 
246  aux_kernel_name = "PorousFlowAction_stress_zz";
247  params.set<AuxVariableName>("variable") = "stress_zz";
248  params.set<unsigned>("index_i") = 2;
249  params.set<unsigned>("index_j") = 2;
250  _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
251  }
252 }
253 
254 void
256 {
257  if (_current_task == "add_material")
258  {
259  if (!parameters().hasDefaultCoupledValue("temperature"))
260  mooseError(
261  "Attempt to add a PorousFlowTemperature material without setting a temperature variable");
262 
263  std::string material_type = "PorousFlowTemperature";
264  InputParameters params = _factory.getValidParams(material_type);
265 
266  params.applySpecificParameters(parameters(), {"temperature"});
267  params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
268 
269  std::string material_name = "PorousFlowActionBase_Temperature_qp";
270  if (at_nodes)
271  material_name = "PorousFlowActionBase_Temperature";
272 
273  params.set<bool>("at_nodes") = at_nodes;
274  _problem->addMaterial(material_type, material_name, params);
275  }
276 }
277 
278 void
280 {
281  if (_current_task == "add_material")
282  {
283  if (!(parameters().hasDefaultCoupledValue("mass_fraction_vars") ||
284  parameters().hasCoupledValue("mass_fraction_vars")))
285  mooseError("Attempt to add a PorousFlowMassFraction material without setting the "
286  "mass_fraction_vars");
287 
288  std::string material_type = "PorousFlowMassFraction";
289  InputParameters params = _factory.getValidParams(material_type);
290 
291  params.applySpecificParameters(parameters(), {"mass_fraction_vars"});
292  params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
293 
294  std::string material_name = "PorousFlowActionBase_MassFraction_qp";
295  if (at_nodes)
296  material_name = "PorousFlowActionBase_MassFraction";
297 
298  params.set<bool>("at_nodes") = at_nodes;
299  _problem->addMaterial(material_type, material_name, params);
300  }
301 }
302 
303 void
305 {
306  if (_current_task == "add_material")
307  {
308  std::string material_type = "PorousFlowEffectiveFluidPressure";
309  InputParameters params = _factory.getValidParams(material_type);
310 
311  params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
312 
313  std::string material_name = "PorousFlowUnsaturated_EffectiveFluidPressure_qp";
314  if (at_nodes)
315  material_name = "PorousFlowUnsaturated_EffectiveFluidPressure";
316 
317  params.set<bool>("at_nodes") = at_nodes;
318  _problem->addMaterial(material_type, material_name, params);
319  }
320 }
321 
322 void
323 PorousFlowActionBase::addVolumetricStrainMaterial(const std::vector<VariableName> & displacements,
324  bool consistent_with_displaced_mesh)
325 {
326  if (_current_task == "add_material")
327  {
328  std::string material_type = "PorousFlowVolumetricStrain";
329  InputParameters params = _factory.getValidParams(material_type);
330 
331  std::string material_name = "PorousFlowActionBase_VolumetricStrain";
332  params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
333  params.set<std::vector<VariableName>>("displacements") = displacements;
334  params.set<bool>("consistent_with_displaced_mesh") = consistent_with_displaced_mesh;
335  _problem->addMaterial(material_type, material_name, params);
336  }
337 }
338 
339 void
341  unsigned phase,
342  bool compute_density_and_viscosity,
343  bool compute_internal_energy,
344  bool compute_enthalpy,
345  const UserObjectName & fp)
346 {
347  if (_current_task == "add_material")
348  {
349  std::string material_type = "PorousFlowSingleComponentFluid";
350  InputParameters params = _factory.getValidParams(material_type);
351 
352  params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
353  params.set<unsigned int>("phase") = phase;
354  params.set<bool>("compute_density_and_viscosity") = compute_density_and_viscosity;
355  params.set<bool>("compute_internal_energy") = compute_internal_energy;
356  params.set<bool>("compute_enthalpy") = compute_enthalpy;
357  params.set<UserObjectName>("fp") = fp;
358 
359  std::string material_name = "PorousFlowActionBase_FluidProperties_qp";
360  if (at_nodes)
361  material_name = "PorousFlowActionBase_FluidProperties";
362 
363  params.set<bool>("at_nodes") = at_nodes;
364  _problem->addMaterial(material_type, material_name, params);
365  }
366 }
367 
368 void
370  bool at_nodes,
371  unsigned phase,
372  bool compute_density_and_viscosity,
373  bool compute_internal_energy,
374  bool compute_enthalpy)
375 {
376  if (_current_task == "add_material")
377  {
378  std::string material_type = "PorousFlowBrine";
379  InputParameters params = _factory.getValidParams(material_type);
380 
381  params.set<std::vector<VariableName>>("xnacl") = {nacl_brine};
382  params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
383  params.set<unsigned int>("phase") = phase;
384  params.set<bool>("compute_density_and_viscosity") = compute_density_and_viscosity;
385  params.set<bool>("compute_internal_energy") = compute_internal_energy;
386  params.set<bool>("compute_enthalpy") = compute_enthalpy;
387 
388  std::string material_name = "PorousFlowActionBase_FluidProperties_qp";
389  if (at_nodes)
390  material_name = "PorousFlowActionBase_FluidProperties";
391 
392  params.set<bool>("at_nodes") = at_nodes;
393  _problem->addMaterial(material_type, material_name, params);
394  }
395 }
396 
397 void
399  bool at_nodes, unsigned phase, Real n, Real s_res, Real sum_s_res)
400 
401 {
402  if (_current_task == "add_material")
403  {
404  std::string material_type = "PorousFlowRelativePermeabilityCorey";
405  InputParameters params = _factory.getValidParams(material_type);
406 
407  params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
408  params.set<Real>("n") = n;
409  params.set<unsigned int>("phase") = phase;
410  params.set<Real>("s_res") = s_res;
411  params.set<Real>("sum_s_res") = sum_s_res;
412 
413  std::string material_name = "PorousFlowActionBase_RelativePermeability_qp";
414  if (at_nodes)
415  material_name = "PorousFlowActionBase_RelativePermeability_nodal";
416 
417  params.set<bool>("at_nodes") = at_nodes;
418  _problem->addMaterial(material_type, material_name, params);
419  }
420 }
421 
422 void
424  bool at_nodes, unsigned phase, Real m, Real s_res, Real sum_s_res)
425 {
426  if (_current_task == "add_material")
427  {
428  std::string material_type = "PorousFlowRelativePermeabilityFLAC";
429  InputParameters params = _factory.getValidParams(material_type);
430 
431  params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
432  params.set<Real>("m") = m;
433  params.set<unsigned int>("phase") = phase;
434  params.set<Real>("s_res") = s_res;
435  params.set<Real>("sum_s_res") = sum_s_res;
436 
437  std::string material_name = "PorousFlowActionBase_RelativePermeability_qp";
438  if (at_nodes)
439  material_name = "PorousFlowActionBase_RelativePermeability_nodal";
440 
441  params.set<bool>("at_nodes") = at_nodes;
442  _problem->addMaterial(material_type, material_name, params);
443  }
444 }
445 
446 void
447 PorousFlowActionBase::addCapillaryPressureVG(Real m, Real alpha, std::string userobject_name)
448 {
449  if (_current_task == "add_user_object")
450  {
451  std::string userobject_type = "PorousFlowCapillaryPressureVG";
452  InputParameters params = _factory.getValidParams(userobject_type);
453  params.set<Real>("m") = m;
454  params.set<Real>("alpha") = alpha;
455  _problem->addUserObject(userobject_type, userobject_name, params);
456  }
457 }
458 
459 void
461  const std::string & material_property,
462  const std::string & output_name)
463 {
464  if (_current_task == "add_material")
465  {
466  std::string material_type = "PorousFlowJoiner";
467  InputParameters params = _factory.getValidParams(material_type);
468  params.set<UserObjectName>("PorousFlowDictator") = _dictator_name;
469  params.set<bool>("at_nodes") = at_nodes;
470  params.set<std::string>("material_property") = material_property;
471  _problem->addMaterial(material_type, output_name, params);
472  }
473 }
474 
475 void
477 {
478  if (at_nodes)
479  addJoiner(at_nodes,
480  "PorousFlow_fluid_phase_density_nodal",
481  "PorousFlowActionBase_fluid_phase_density_all");
482  else
483  addJoiner(at_nodes,
484  "PorousFlow_fluid_phase_density_qp",
485  "PorousFlowActionBase_fluid_phase_density_qp_all");
486 }
487 
488 void
490 {
491  if (at_nodes)
492  addJoiner(at_nodes, "PorousFlow_viscosity_nodal", "PorousFlowActionBase_viscosity_all");
493  else
494  addJoiner(at_nodes, "PorousFlow_viscosity_qp", "PorousFlowActionBase_viscosity_qp_all");
495 }
496 
497 void
499 {
500  if (at_nodes)
501  addJoiner(at_nodes,
502  "PorousFlow_relative_permeability_nodal",
503  "PorousFlowActionBase_relative_permeability_all");
504  else
505  addJoiner(at_nodes,
506  "PorousFlow_relative_permeability_qp",
507  "PorousFlowActionBase_relative_permeability_qp_all");
508 }
509 
510 void
512 {
513  if (at_nodes)
514  addJoiner(at_nodes,
515  "PorousFlow_fluid_phase_internal_energy_nodal",
516  "PorousFlowActionBase_fluid_phase_internal_energy_all");
517  else
518  addJoiner(at_nodes,
519  "PorousFlow_fluid_phase_internal_energy_qp",
520  "PorousFlowActionBase_fluid_phase_internal_energy_qp_all");
521 }
522 
523 void
525 {
526  if (at_nodes)
527  addJoiner(at_nodes,
528  "PorousFlow_fluid_phase_enthalpy_nodal",
529  "PorousFlowActionBase_fluid_phase_enthalpy_all");
530  else
531  addJoiner(at_nodes,
532  "PorousFlow_fluid_phase_enthalpy_qp",
533  "PorousFlowActionBase_fluid_phase_enthalpy_qp_all");
534 }
Moose::CoordinateSystemType _coord_system
Coordinate system of the simulation (eg RZ, XYZ, etc)
void addStressAux()
Add AuxVariables and AuxKernels to compute effective stress.
void addSaturationAux(unsigned phase)
Add an AuxVariable and AuxKernel to calculate saturation.
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.
PorousFlowActionBase(const InputParameters &params)
void joinEnthalpy(bool at_nodes)
Adds a PorousFlowJoiner for the fluid enthalpy.
void addEffectiveFluidPressureMaterial(bool at_nodes)
Adds a nodal and a quadpoint effective fluid pressure material.
std::vector< VariableName > _coupled_displacements
displacement Variable names
void joinInternalEnergy(bool at_nodes)
Adds a PorousFlowJoiner for the fluid internal energy.
InputParameters validParams< PorousFlowActionBase >()
void addCapillaryPressureVG(Real m, Real alpha, std::string userobject_name)
Adds a van Genuchten capillary pressure UserObject.
virtual void addDictator()=0
add the PorousFlowDictator object
virtual void act() override
void joinDensity(bool at_nodes)
Adds a PorousFlowJoiner for the fluid density.
const unsigned _ndisp
number of displacement variables supplied
void addDarcyAux(const RealVectorValue &gravity)
Add AuxVariables and AuxKernels to calculate Darcy velocity.
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 joinRelativePermeability(bool at_nodes)
Adds a PorousFlowJoiner for the fluid relative permeability.
void joinViscosity(bool at_nodes)
Adds a PorousFlowJoiner for the fluid viscosity.
Holds the PorousFlow dependencies of kernels, auxkernels, materials, etc.
const std::string _dictator_name
The name of the PorousFlowDictator object to be added.
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 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.
void addVolumetricStrainMaterial(const std::vector< VariableName > &displacements, bool consistent_with_displaced_mesh)
Adds a quadpoint volumetric strain material.
const std::vector< NonlinearVariableName > & _displacements
displacement NonlinearVariable names (if any)
void addJoiner(bool at_nodes, const std::string &material_property, const std::string &output_name)
Adds a PorousFlowJoiner for the material_property Material.
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.