FluidProperties System

Overview

FluidProperties objects define interfaces for computing thermodynamic properties of fluids (liquids and gases). The consistent interface allows different fluids to be used in an input file by simply swapping the name of the Fluid Properties UserObject in a plug-and-play manner.

There are multiple base classes suited to different phase and component combinations, as well as to different applications:

HEMFluidProperties: single component, single phase, HEM formulation
MultiComponentFluidProperties: two components, single phase, $var element = document.getElementById("moose-equation-4907daa5-6253-424f-b152-7fb697ee06ca");katex.render("(p,T)", element, {displayMode:false,throwOnError:false});$ formulation
SinglePhaseFluidProperties: single component, single phase
TwoPhaseFluidProperties: single component, two phases
VaporMixtureFluidProperties: multiple components, single (vapor) phase

Usage

Fluid properties objects are GeneralUserObjects that have empty initialize(), execute() and finalize() methods, so they do nothing during a simulation. Their purpose is to provide convenient access to fluid properties through the existing UserObject interface.

All Fluid Properties UserObjects can be accessed in MOOSE objects through the usual UserObject interface. The following example provides a detailed explanation of the steps involved to use the Fluid Properties UserObjects in other MOOSE objects, and the syntax required in the input file.

This example is for a problem that has energy-volume as the primary variables. A material is provided to calculate fluid properties at the quadrature points.

Source

To access the fluid properties defined in the Fluid Properties module in a MOOSE object, the source code of the object must include the following lines of code.

In the header file of the material, a const reference to the base SinglePhaseFluidProperties object is required:

  const SinglePhaseFluidProperties & _fp;

note

A forward declaration to the SinglePhaseFluidProperties class is required at the beginning of the header file.

class SinglePhaseFluidProperties;

In the source file, the SinglePhaseFluidProperties class must be included

#include "SinglePhaseFluidProperties.h"

The Fluid Properties UserObject is passed to this material in the input file by adding a UserObject name parameters in the input parameters:

  params.addRequiredParam<UserObjectName>("fp", "The name of the user object for fluid properties");

The reference to the UserObject is then initialized in the constructor using

    _fp(getUserObject<SinglePhaseFluidProperties>("fp"))

The properties defined in the Fluid Properties UserObject can now be accessed through the reference. In this material, the computeQpProperties method calculates a number of properties at the quadrature points using the values of _v[_qp] and _e[_qp].

FluidPropertiesMaterialVE::computeQpProperties()
{
  _p[_qp] = _fp.p_from_v_e(_v[_qp], _e[_qp]);
  _T[_qp] = _fp.T_from_v_e(_v[_qp], _e[_qp]);
  _c[_qp] = _fp.c_from_v_e(_v[_qp], _e[_qp]);
  _cp[_qp] = _fp.cp_from_v_e(_v[_qp], _e[_qp]);
  _cv[_qp] = _fp.cv_from_v_e(_v[_qp], _e[_qp]);
  _mu[_qp] = _fp.mu_from_v_e(_v[_qp], _e[_qp]);
  _k[_qp] = _fp.k_from_v_e(_v[_qp], _e[_qp]);
  _s[_qp] = _fp.s_from_v_e(_v[_qp], _e[_qp]);
  _g[_qp] = _fp.g_from_v_e(_v[_qp], _e[_qp]);
}

In a similar fashion, fluid properties can be accessed using the Automatic Differentiation interface using the ADReal version which provides both the value and derivatives


ADReal rho = _fp.p_from_T_v(T, v);

where $var element = document.getElementById("moose-equation-20ece941-bb01-41b9-932b-95779ef57f64");katex.render("T", element, {displayMode:false,throwOnError:false});$ and $var element = document.getElementById("moose-equation-2588f208-2772-488b-9c2d-97e1586f8b36");katex.render("v", element, {displayMode:false,throwOnError:false});$ are ADReal's. The result (density rho in this example) then contains both the value of density and its derivatives with respect to the primary variables T and v.

Input file syntax

The Fluid Properties UserObjects are implemented in an input file in the FluidProperties block. For example, to use the ideal gas formulation for specific volume and energy, the input file syntax would be:

[FluidProperties]
  [./ideal_gas]
    type = IdealGasFluidProperties
    gamma = 1.4
    molar_mass = 1.000536678700361
  [../]
[]

In this example, the user has specified a value for gamma (the ratio of isobaric to isochoric specific heat capacities), and R, the universal gas constant.

The fluid properties can then be accessed by other MOOSE objects through the name given in the input file.

[Materials]
  [./fp_mat]
    type = FluidPropertiesMaterialVE
    e = e
    v = v
    fp = ideal_gas
  [../]
[]

Due to the consistent interface for fluid properties, a different fluid can be substituted in the input file be changing the type of the UserObject. For example, to use a stiffened gas instead of an ideal gas, the only modification required in the input file is

[FluidProperties]
  [./sg]
    type = StiffenedGasFluidProperties
    gamma = 2.35
    q = -1167e3
    q_prime = 0
    p_inf = 1.e9
    cv = 1816

    mu = 0.9
    k = 0.6
  [../]
[]

Creating additional fluids

New fluids can be added to the Fluid Properties module by inheriting from the base class and overriding the methods that describe the fluid properties. These can then be used in an identical manner as all other Fluid Properties UserObjects.

Utilities

Fluid Properties Interrogator

The FluidPropertiesInterrogator is a user object which can be used to query eligible fluid properties objects.

Fluid properties materials

The FluidPropertiesMaterialVE and FluidPropertiesMaterialPT are materials which define many fluid properties as material properties, mainly for visualizing them over the solve domain.

Available Objects

Fluid Properties App
BrineFluidPropertiesFluid properties for brine
CO2FluidPropertiesFluid properties for carbon dioxide (CO2) using the Span & Wagner EOS
CaloricallyImperfectGasFluid properties for an ideal gas with imperfect caloric behavior.
FlibeFluidPropertiesFluid properties for flibe
FlinakFluidPropertiesFluid properties for flinak
HeliumFluidPropertiesFluid properties for helium
HydrogenFluidPropertiesFluid properties for Hydrogen (H2)
IdealGasFluidPropertiesFluid properties for an ideal gas
IdealRealGasMixtureFluidPropertiesClass for fluid properties of an arbitrary vapor mixture
LeadBismuthFluidPropertiesFluid properties for Lead Bismuth eutectic 2LiF-BeF2
LeadFluidPropertiesFluid properties for Lead
MethaneFluidPropertiesFluid properties for methane (CH4)
NaClFluidPropertiesFluid properties for NaCl
NaKFluidPropertiesFluid properties for NaK
NitrogenFluidPropertiesFluid properties for Nitrogen (N2)
SalineMoltenSaltFluidPropertiesTo use this object, you need to have the Saline library installed. Refer to the documentation for guidance on how to enable it. (Original description: Molten salt fluid properties using Saline)
SimpleFluidPropertiesFluid properties for a simple fluid with a constant bulk density
SodiumPropertiesFluid properties for sodium
SodiumSaturationFluidPropertiesFluid properties for liquid sodium at saturation conditions
StiffenedGasFluidPropertiesFluid properties for a stiffened gas
StiffenedGasTwoPhaseFluidPropertiesTwo-phase stiffened gas fluid properties
TabulatedBicubicFluidPropertiesFluid properties using bicubic interpolation on tabulated values provided
TabulatedFluidPropertiesFluid properties using bicubic interpolation on tabulated values provided
TemperaturePressureFunctionFluidPropertiesSingle-phase fluid properties that allows to provide thermal conductivity, density, and viscosity as functions of temperature and pressure.
TwoPhaseFluidPropertiesIndependent2-phase fluid properties for 2 independent single-phase fluid properties
TwoPhaseNCGPartialPressureFluidPropertiesTwo-phase fluid with single NCG using partial pressure mixture model
Water97FluidPropertiesFluid properties for water and steam (H2O) using IAPWS-IF97

Available Actions

Fluid Properties App
AddFluidPropertiesActionAdd a UserObject object to the simulation.

(moose/modules/fluid_properties/include/materials/FluidPropertiesMaterialVE.h)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "Material.h"

class SinglePhaseFluidProperties;

/**
 * Computes fluid properties using (specific energy, specific volume) formulation
 */
class FluidPropertiesMaterialVE : public Material
{
public:
  static InputParameters validParams();

  FluidPropertiesMaterialVE(const InputParameters & parameters);
  virtual ~FluidPropertiesMaterialVE();

protected:
  void computeQpProperties() override;

  /// Specific internal energy (J/kg)
  const VariableValue & _e;
  /// Specific volume (1/m^3)
  const VariableValue & _v;
  /// Pressure (Pa)
  MaterialProperty<Real> & _p;
  /// Temperature (K)
  MaterialProperty<Real> & _T;
  /// Speed of sound (m/s)
  MaterialProperty<Real> & _c;
  /// Isobaric specific heat capacity (J/kg/K)
  MaterialProperty<Real> & _cp;
  /// Isochoric specific heat capacity (J/kg/K)
  MaterialProperty<Real> & _cv;
  /// Dynamic viscosity (Pa.s)
  MaterialProperty<Real> & _mu;
  /// Thermal conductivity (W/m/K)
  MaterialProperty<Real> & _k;
  /// Specific entropy (J/kg/K)
  MaterialProperty<Real> & _s;
  /// Gibbs free energy
  MaterialProperty<Real> & _g;

  /// Fluid properties
  const SinglePhaseFluidProperties & _fp;
};

(moose/modules/fluid_properties/include/materials/FluidPropertiesMaterialVE.h)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "Material.h"

class SinglePhaseFluidProperties;

/**
 * Computes fluid properties using (specific energy, specific volume) formulation
 */
class FluidPropertiesMaterialVE : public Material
{
public:
  static InputParameters validParams();

  FluidPropertiesMaterialVE(const InputParameters & parameters);
  virtual ~FluidPropertiesMaterialVE();

protected:
  void computeQpProperties() override;

  /// Specific internal energy (J/kg)
  const VariableValue & _e;
  /// Specific volume (1/m^3)
  const VariableValue & _v;
  /// Pressure (Pa)
  MaterialProperty<Real> & _p;
  /// Temperature (K)
  MaterialProperty<Real> & _T;
  /// Speed of sound (m/s)
  MaterialProperty<Real> & _c;
  /// Isobaric specific heat capacity (J/kg/K)
  MaterialProperty<Real> & _cp;
  /// Isochoric specific heat capacity (J/kg/K)
  MaterialProperty<Real> & _cv;
  /// Dynamic viscosity (Pa.s)
  MaterialProperty<Real> & _mu;
  /// Thermal conductivity (W/m/K)
  MaterialProperty<Real> & _k;
  /// Specific entropy (J/kg/K)
  MaterialProperty<Real> & _s;
  /// Gibbs free energy
  MaterialProperty<Real> & _g;

  /// Fluid properties
  const SinglePhaseFluidProperties & _fp;
};

(moose/modules/fluid_properties/src/materials/FluidPropertiesMaterialVE.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "FluidPropertiesMaterialVE.h"
#include "SinglePhaseFluidProperties.h"

registerMooseObject("FluidPropertiesApp", FluidPropertiesMaterialVE);
registerMooseObjectRenamed("FluidPropertiesApp",
                           FluidPropertiesMaterial,
                           "01/01/2023 00:00",
                           FluidPropertiesMaterialVE);

InputParameters
FluidPropertiesMaterialVE::validParams()
{
  InputParameters params = Material::validParams();
  params.addRequiredCoupledVar("e", "Specific internal energy");
  params.addRequiredCoupledVar("v", "Specific volume");
  params.addRequiredParam<UserObjectName>("fp", "The name of the user object for fluid properties");
  params.addClassDescription(
      "Computes fluid properties using (specific internal energy, specific volume) formulation");
  return params;
}

FluidPropertiesMaterialVE::FluidPropertiesMaterialVE(const InputParameters & parameters)
  : Material(parameters),
    _e(coupledValue("e")),
    _v(coupledValue("v")),

    _p(declareProperty<Real>("pressure")),
    _T(declareProperty<Real>("temperature")),
    _c(declareProperty<Real>("c")),
    _cp(declareProperty<Real>("cp")),
    _cv(declareProperty<Real>("cv")),
    _mu(declareProperty<Real>("mu")),
    _k(declareProperty<Real>("k")),
    _s(declareProperty<Real>("s")),
    _g(declareProperty<Real>("g")),

    _fp(getUserObject<SinglePhaseFluidProperties>("fp"))
{
}

FluidPropertiesMaterialVE::~FluidPropertiesMaterialVE() {}

void
FluidPropertiesMaterialVE::computeQpProperties()
{
  _p[_qp] = _fp.p_from_v_e(_v[_qp], _e[_qp]);
  _T[_qp] = _fp.T_from_v_e(_v[_qp], _e[_qp]);
  _c[_qp] = _fp.c_from_v_e(_v[_qp], _e[_qp]);
  _cp[_qp] = _fp.cp_from_v_e(_v[_qp], _e[_qp]);
  _cv[_qp] = _fp.cv_from_v_e(_v[_qp], _e[_qp]);
  _mu[_qp] = _fp.mu_from_v_e(_v[_qp], _e[_qp]);
  _k[_qp] = _fp.k_from_v_e(_v[_qp], _e[_qp]);
  _s[_qp] = _fp.s_from_v_e(_v[_qp], _e[_qp]);
  _g[_qp] = _fp.g_from_v_e(_v[_qp], _e[_qp]);
}

(moose/modules/fluid_properties/src/materials/FluidPropertiesMaterialVE.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "FluidPropertiesMaterialVE.h"
#include "SinglePhaseFluidProperties.h"

registerMooseObject("FluidPropertiesApp", FluidPropertiesMaterialVE);
registerMooseObjectRenamed("FluidPropertiesApp",
                           FluidPropertiesMaterial,
                           "01/01/2023 00:00",
                           FluidPropertiesMaterialVE);

InputParameters
FluidPropertiesMaterialVE::validParams()
{
  InputParameters params = Material::validParams();
  params.addRequiredCoupledVar("e", "Specific internal energy");
  params.addRequiredCoupledVar("v", "Specific volume");
  params.addRequiredParam<UserObjectName>("fp", "The name of the user object for fluid properties");
  params.addClassDescription(
      "Computes fluid properties using (specific internal energy, specific volume) formulation");
  return params;
}

FluidPropertiesMaterialVE::FluidPropertiesMaterialVE(const InputParameters & parameters)
  : Material(parameters),
    _e(coupledValue("e")),
    _v(coupledValue("v")),

    _p(declareProperty<Real>("pressure")),
    _T(declareProperty<Real>("temperature")),
    _c(declareProperty<Real>("c")),
    _cp(declareProperty<Real>("cp")),
    _cv(declareProperty<Real>("cv")),
    _mu(declareProperty<Real>("mu")),
    _k(declareProperty<Real>("k")),
    _s(declareProperty<Real>("s")),
    _g(declareProperty<Real>("g")),

    _fp(getUserObject<SinglePhaseFluidProperties>("fp"))
{
}

FluidPropertiesMaterialVE::~FluidPropertiesMaterialVE() {}

void
FluidPropertiesMaterialVE::computeQpProperties()
{
  _p[_qp] = _fp.p_from_v_e(_v[_qp], _e[_qp]);
  _T[_qp] = _fp.T_from_v_e(_v[_qp], _e[_qp]);
  _c[_qp] = _fp.c_from_v_e(_v[_qp], _e[_qp]);
  _cp[_qp] = _fp.cp_from_v_e(_v[_qp], _e[_qp]);
  _cv[_qp] = _fp.cv_from_v_e(_v[_qp], _e[_qp]);
  _mu[_qp] = _fp.mu_from_v_e(_v[_qp], _e[_qp]);
  _k[_qp] = _fp.k_from_v_e(_v[_qp], _e[_qp]);
  _s[_qp] = _fp.s_from_v_e(_v[_qp], _e[_qp]);
  _g[_qp] = _fp.g_from_v_e(_v[_qp], _e[_qp]);
}

(moose/modules/fluid_properties/src/materials/FluidPropertiesMaterialVE.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "FluidPropertiesMaterialVE.h"
#include "SinglePhaseFluidProperties.h"

registerMooseObject("FluidPropertiesApp", FluidPropertiesMaterialVE);
registerMooseObjectRenamed("FluidPropertiesApp",
                           FluidPropertiesMaterial,
                           "01/01/2023 00:00",
                           FluidPropertiesMaterialVE);

InputParameters
FluidPropertiesMaterialVE::validParams()
{
  InputParameters params = Material::validParams();
  params.addRequiredCoupledVar("e", "Specific internal energy");
  params.addRequiredCoupledVar("v", "Specific volume");
  params.addRequiredParam<UserObjectName>("fp", "The name of the user object for fluid properties");
  params.addClassDescription(
      "Computes fluid properties using (specific internal energy, specific volume) formulation");
  return params;
}

FluidPropertiesMaterialVE::FluidPropertiesMaterialVE(const InputParameters & parameters)
  : Material(parameters),
    _e(coupledValue("e")),
    _v(coupledValue("v")),

    _p(declareProperty<Real>("pressure")),
    _T(declareProperty<Real>("temperature")),
    _c(declareProperty<Real>("c")),
    _cp(declareProperty<Real>("cp")),
    _cv(declareProperty<Real>("cv")),
    _mu(declareProperty<Real>("mu")),
    _k(declareProperty<Real>("k")),
    _s(declareProperty<Real>("s")),
    _g(declareProperty<Real>("g")),

    _fp(getUserObject<SinglePhaseFluidProperties>("fp"))
{
}

FluidPropertiesMaterialVE::~FluidPropertiesMaterialVE() {}

void
FluidPropertiesMaterialVE::computeQpProperties()
{
  _p[_qp] = _fp.p_from_v_e(_v[_qp], _e[_qp]);
  _T[_qp] = _fp.T_from_v_e(_v[_qp], _e[_qp]);
  _c[_qp] = _fp.c_from_v_e(_v[_qp], _e[_qp]);
  _cp[_qp] = _fp.cp_from_v_e(_v[_qp], _e[_qp]);
  _cv[_qp] = _fp.cv_from_v_e(_v[_qp], _e[_qp]);
  _mu[_qp] = _fp.mu_from_v_e(_v[_qp], _e[_qp]);
  _k[_qp] = _fp.k_from_v_e(_v[_qp], _e[_qp]);
  _s[_qp] = _fp.s_from_v_e(_v[_qp], _e[_qp]);
  _g[_qp] = _fp.g_from_v_e(_v[_qp], _e[_qp]);
}

(moose/modules/fluid_properties/src/materials/FluidPropertiesMaterialVE.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "FluidPropertiesMaterialVE.h"
#include "SinglePhaseFluidProperties.h"

registerMooseObject("FluidPropertiesApp", FluidPropertiesMaterialVE);
registerMooseObjectRenamed("FluidPropertiesApp",
                           FluidPropertiesMaterial,
                           "01/01/2023 00:00",
                           FluidPropertiesMaterialVE);

InputParameters
FluidPropertiesMaterialVE::validParams()
{
  InputParameters params = Material::validParams();
  params.addRequiredCoupledVar("e", "Specific internal energy");
  params.addRequiredCoupledVar("v", "Specific volume");
  params.addRequiredParam<UserObjectName>("fp", "The name of the user object for fluid properties");
  params.addClassDescription(
      "Computes fluid properties using (specific internal energy, specific volume) formulation");
  return params;
}

FluidPropertiesMaterialVE::FluidPropertiesMaterialVE(const InputParameters & parameters)
  : Material(parameters),
    _e(coupledValue("e")),
    _v(coupledValue("v")),

    _p(declareProperty<Real>("pressure")),
    _T(declareProperty<Real>("temperature")),
    _c(declareProperty<Real>("c")),
    _cp(declareProperty<Real>("cp")),
    _cv(declareProperty<Real>("cv")),
    _mu(declareProperty<Real>("mu")),
    _k(declareProperty<Real>("k")),
    _s(declareProperty<Real>("s")),
    _g(declareProperty<Real>("g")),

    _fp(getUserObject<SinglePhaseFluidProperties>("fp"))
{
}

FluidPropertiesMaterialVE::~FluidPropertiesMaterialVE() {}

void
FluidPropertiesMaterialVE::computeQpProperties()
{
  _p[_qp] = _fp.p_from_v_e(_v[_qp], _e[_qp]);
  _T[_qp] = _fp.T_from_v_e(_v[_qp], _e[_qp]);
  _c[_qp] = _fp.c_from_v_e(_v[_qp], _e[_qp]);
  _cp[_qp] = _fp.cp_from_v_e(_v[_qp], _e[_qp]);
  _cv[_qp] = _fp.cv_from_v_e(_v[_qp], _e[_qp]);
  _mu[_qp] = _fp.mu_from_v_e(_v[_qp], _e[_qp]);
  _k[_qp] = _fp.k_from_v_e(_v[_qp], _e[_qp]);
  _s[_qp] = _fp.s_from_v_e(_v[_qp], _e[_qp]);
  _g[_qp] = _fp.g_from_v_e(_v[_qp], _e[_qp]);
}

(moose/modules/fluid_properties/test/tests/ideal_gas/test.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 2
  ny = 2
  elem_type = QUAD4
[]

[Functions]
  [./f_fn]
    type = ParsedFunction
    expression = -4
  [../]
  [./bc_fn]
    type = ParsedFunction
    expression = 'x*x+y*y'
  [../]
[]

[Variables]
  [./u]
  [../]
[]

[AuxVariables]
  [./e]
    initial_condition = 6232.5
  [../]
  [./v]
    initial_condition = 0.02493
  [../]

  [./p]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./T]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./cp]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./cv]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./c]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./mu]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./k]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./g]
    family = MONOMIAL
    order = CONSTANT
  [../]
[]

[AuxKernels]
  [./p]
    type = MaterialRealAux
     variable = p
     property = pressure
  [../]
  [./T]
    type = MaterialRealAux
     variable = T
     property = temperature
  [../]
  [./cp]
    type = MaterialRealAux
     variable = cp
     property = cp
  [../]
  [./cv]
    type = MaterialRealAux
     variable = cv
     property = cv
  [../]
  [./c]
    type = MaterialRealAux
     variable = c
     property = c
  [../]
  [./mu]
    type = MaterialRealAux
     variable = mu
     property = mu
  [../]
  [./k]
    type = MaterialRealAux
     variable = k
     property = k
  [../]
  [./g]
    type = MaterialRealAux
     variable = g
     property = g
  [../]
[]

[FluidProperties]
  [./ideal_gas]
    type = IdealGasFluidProperties
    gamma = 1.4
    molar_mass = 1.000536678700361
  [../]
[]

[Materials]
  [./fp_mat]
    type = FluidPropertiesMaterialVE
    e = e
    v = v
    fp = ideal_gas
  [../]
[]

[Kernels]
  [./diff]
    type = Diffusion
    variable = u
  [../]
  [./ffn]
    type = BodyForce
    variable = u
    function = f_fn
  [../]
[]

[BCs]
  [./all]
    type = FunctionDirichletBC
    variable = u
    boundary = 'left right top bottom'
    function = bc_fn
  [../]
[]

[Executioner]
  type = Steady
  solve_type = NEWTON
[]

[Outputs]
  exodus = true
[]

(moose/modules/fluid_properties/test/tests/ideal_gas/test.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 2
  ny = 2
  elem_type = QUAD4
[]

[Functions]
  [./f_fn]
    type = ParsedFunction
    expression = -4
  [../]
  [./bc_fn]
    type = ParsedFunction
    expression = 'x*x+y*y'
  [../]
[]

[Variables]
  [./u]
  [../]
[]

[AuxVariables]
  [./e]
    initial_condition = 6232.5
  [../]
  [./v]
    initial_condition = 0.02493
  [../]

  [./p]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./T]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./cp]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./cv]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./c]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./mu]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./k]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./g]
    family = MONOMIAL
    order = CONSTANT
  [../]
[]

[AuxKernels]
  [./p]
    type = MaterialRealAux
     variable = p
     property = pressure
  [../]
  [./T]
    type = MaterialRealAux
     variable = T
     property = temperature
  [../]
  [./cp]
    type = MaterialRealAux
     variable = cp
     property = cp
  [../]
  [./cv]
    type = MaterialRealAux
     variable = cv
     property = cv
  [../]
  [./c]
    type = MaterialRealAux
     variable = c
     property = c
  [../]
  [./mu]
    type = MaterialRealAux
     variable = mu
     property = mu
  [../]
  [./k]
    type = MaterialRealAux
     variable = k
     property = k
  [../]
  [./g]
    type = MaterialRealAux
     variable = g
     property = g
  [../]
[]

[FluidProperties]
  [./ideal_gas]
    type = IdealGasFluidProperties
    gamma = 1.4
    molar_mass = 1.000536678700361
  [../]
[]

[Materials]
  [./fp_mat]
    type = FluidPropertiesMaterialVE
    e = e
    v = v
    fp = ideal_gas
  [../]
[]

[Kernels]
  [./diff]
    type = Diffusion
    variable = u
  [../]
  [./ffn]
    type = BodyForce
    variable = u
    function = f_fn
  [../]
[]

[BCs]
  [./all]
    type = FunctionDirichletBC
    variable = u
    boundary = 'left right top bottom'
    function = bc_fn
  [../]
[]

[Executioner]
  type = Steady
  solve_type = NEWTON
[]

[Outputs]
  exodus = true
[]

(moose/modules/fluid_properties/test/tests/stiffened_gas/test.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 2
  ny = 2
  elem_type = QUAD4
[]

[Functions]
  [./f_fn]
    type = ParsedFunction
    expression = -4
  [../]
  [./bc_fn]
    type = ParsedFunction
    expression = 'x*x+y*y'
  [../]
[]

[Variables]
  [./u]
  [../]
[]

[AuxVariables]
  [./e]
    initial_condition = 113206.45935406466
  [../]
  [./v]
    initial_condition = 0.0007354064593540647
  [../]

  [./p]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./T]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./cp]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./cv]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./c]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./mu]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./k]
    family = MONOMIAL
    order = CONSTANT
  [../]
  [./g]
    family = MONOMIAL
    order = CONSTANT
  [../]
[]

[AuxKernels]
  [./p]
    type = MaterialRealAux
     variable = p
     property = pressure
  [../]
  [./T]
    type = MaterialRealAux
     variable = T
     property = temperature
  [../]
  [./cp]
    type = MaterialRealAux
     variable = cp
     property = cp
  [../]
  [./cv]
    type = MaterialRealAux
     variable = cv
     property = cv
  [../]
  [./c]
    type = MaterialRealAux
     variable = c
     property = c
  [../]
  [./mu]
    type = MaterialRealAux
     variable = mu
     property = mu
  [../]
  [./k]
    type = MaterialRealAux
     variable = k
     property = k
  [../]
  [./g]
    type = MaterialRealAux
     variable = g
     property = g
  [../]
[]

[FluidProperties]
  [./sg]
    type = StiffenedGasFluidProperties
    gamma = 2.35
    q = -1167e3
    q_prime = 0
    p_inf = 1.e9
    cv = 1816

    mu = 0.9
    k = 0.6
  [../]
[]

[Materials]
  [./fp_mat]
    type = FluidPropertiesMaterialVE
    e = e
    v = v
    fp = sg
  [../]
[]

[Kernels]
  [./diff]
    type = Diffusion
    variable = u
  [../]
  [./ffn]
    type = BodyForce
    variable = u
    function = f_fn
  [../]
[]

[BCs]
  [./all]
    type = FunctionDirichletBC
    variable = u
    boundary = 'left right top bottom'
    function = bc_fn
  [../]
[]

[Executioner]
  type = Steady
  solve_type = NEWTON
[]

[Outputs]
  exodus = true
[]

Overview
Usage
Creating additional fluids
Utilities
Available Objects
Available Actions