PorousFlowWaterNCG Class Reference

Specialized class for water and a non-condensable gas (NCG) Includes dissolution of gas in liquid water phase using Henry's law. More...

#include <PorousFlowWaterNCG.h>

Inheritance diagram for PorousFlowWaterNCG:

Public Member Functions
	PorousFlowWaterNCG (const InputParameters &parameters)
virtual std::string	fluidStateName () const override
	Name of FluidState. More...
void	thermophysicalProperties (Real pressure, Real temperature, Real Xnacl, Real Z, unsigned int qp, std::vector< FluidStateProperties > &fsp) const override
	Determines the complete thermophysical state of the system for a given set of primary variables. More...
void	equilibriumMassFractions (Real pressure, Real temperature, Real &Xncg, Real &dXncg_dp, Real &dXncg_dT, Real &Yh2o, Real &dYh2o_dp, Real &dYh2o_dT) const
	Mass fractions of NCG in liquid phase and H2O in gas phase at thermodynamic equilibrium. More...
void	massFractions (Real pressure, Real temperature, Real Z, FluidStatePhaseEnum &phase_state, std::vector< FluidStateProperties > &fsp) const
	Mass fractions of NCG and H2O in both phases, as well as derivatives wrt PorousFlow variables. More...
void	gasProperties (Real pressure, Real temperature, std::vector< FluidStateProperties > &fsp) const
	Gas density. More...
void	liquidProperties (Real pressure, Real temperature, std::vector< FluidStateProperties > &fsp) const
	Liquid density. More...
void	saturationTwoPhase (Real pressure, Real temperature, Real Z, std::vector< FluidStateProperties > &fsp) const
	Gas and liquid saturation in the two-phase region. More...
void	enthalpyOfDissolution (Real temperature, Real &hdis, Real &dhdis_dT) const
	Enthalpy of dissolution of NCG in water calculated using Henry's constant From Himmelblau, Partial molal heats and entropies of solution for gases dissolved in water from the freezing to the near critical point, J. More...
virtual Real	totalMassFraction (Real pressure, Real temperature, Real Xnacl, Real saturation, unsigned int qp) const override
	Total mass fraction of fluid component summed over all phases in the two-phase state for a specified gas saturation. More...
unsigned int	numPhases () const
	The maximum number of phases in this model. More...
unsigned int	numComponents () const
	The maximum number of components in this model. More...
unsigned int	aqueousPhaseIndex () const
	The index of the aqueous phase. More...
unsigned int	gasPhaseIndex () const
	The index of the gas phase. More...
unsigned int	aqueousComponentIndex () const
	The index of the aqueous fluid component. More...
unsigned int	gasComponentIndex () const
	The index of the gas fluid component. More...
unsigned int	saltComponentIndex () const
	The index of the salt component. More...
void	clearFluidStateProperties (std::vector< FluidStateProperties > &fsp) const
	Clears the contents of the FluidStateProperties data structure. More...
void	initialize () final
void	execute () final
void	finalize () final
Real	rachfordRice (Real vf, std::vector< Real > &Zi, std::vector< Real > &Ki) const
	Rachford-Rice equation for vapor fraction. More...
Real	rachfordRiceDeriv (Real vf, std::vector< Real > &Zi, std::vector< Real > &Ki) const
	Derivative of Rachford-Rice equation wrt vapor fraction. More...
Real	vaporMassFraction (Real Z0, Real K0, Real K1) const
	Solves Rachford-Rice equation to provide vapor mass fraction. More...
Real	vaporMassFraction (std::vector< Real > &Zi, std::vector< Real > &Ki) const

Protected Member Functions
Real	moleFractionToMassFraction (Real xmol) const
	Convert mole fraction to mass fraction. More...
void	checkVariables (Real temperature) const
	Check that the temperature is between the triple and critical values. More...
void	phaseState (Real Zi, Real Xi, Real Yi, FluidStatePhaseEnum &phase_state) const
	Determines the phase state gven the total mass fraction and equilibrium mass fractions. More...

Protected Attributes
const SinglePhaseFluidProperties &	_water_fp
	Fluid properties UserObject for water. More...
const SinglePhaseFluidProperties &	_ncg_fp
	Fluid properties UserObject for the NCG. More...
const Real	_Mh2o
	Molar mass of water (kg/mol) More...
const Real	_Mncg
	Molar mass of non-condensable gas (kg/mol) More...
const Real	_water_triple_temperature
	Triple point temperature of water (K) More...
const Real	_water_critical_temperature
	Critical temperature of water (K) More...
unsigned int	_num_phases
	Number of phases. More...
unsigned int	_num_components
	Number of components. More...
const unsigned int	_aqueous_phase_number
	Phase number of the aqueous phase. More...
unsigned int	_gas_phase_number
	Phase number of the gas phase. More...
const unsigned int	_aqueous_fluid_component
	Fluid component number of the aqueous component. More...
unsigned int	_gas_fluid_component
	Fluid component number of the gas phase. More...
const unsigned int	_salt_component
	Salt component index. More...
const Real	_R
	Universal gas constant (J/mol/K) More...
const Real	_T_c2k
	Conversion from C to K. More...
const Real	_nr_max_its
	Maximum number of iterations for the Newton-Raphson iterations. More...
const Real	_nr_tol
	Tolerance for Newton-Raphson iterations. More...
const PorousFlowCapillaryPressure &	_pc
	Capillary pressure UserObject. More...

Detailed Description

Specialized class for water and a non-condensable gas (NCG) Includes dissolution of gas in liquid water phase using Henry's law.

Notation convention Throughout this class, both mole fractions and mass fractions will be used. The following notation will be used: yk: mole fraction of component k in the gas phase xk: mole fraction of component k in the liquid phase Yk: mass fraction of component k in the gas phase Xk: mass fraction of component k in the liquid phase

Definition at line 33 of file PorousFlowWaterNCG.h.

Constructor & Destructor Documentation

PorousFlowWaterNCG()

PorousFlowWaterNCG::PorousFlowWaterNCG

(

const InputParameters &

parameters

)

Definition at line 28 of file PorousFlowWaterNCG.C.

  : PorousFlowFluidStateBase(parameters),
    _water_fp(getUserObject<SinglePhaseFluidProperties>("water_fp")),
    _ncg_fp(getUserObject<SinglePhaseFluidProperties>("gas_fp")),
    _Mh2o(_water_fp.molarMass()),
    _Mncg(_ncg_fp.molarMass()),
    _water_triple_temperature(_water_fp.triplePointTemperature()),
    _water_critical_temperature(_water_fp.criticalTemperature())
{
  // Check that the correct FluidProperties UserObjects have been provided
  if (_water_fp.fluidName() != "water")
    paramError("water_fp", "A valid water FluidProperties UserObject must be provided in water_fp");

  // Set the number of phases and components, and their indexes
  _num_phases = 2;
  _num_components = 2;
  _gas_phase_number = 1 - _aqueous_phase_number;
  _gas_fluid_component = 1 - _aqueous_fluid_component;

  // Check that _aqueous_phase_number is <= total number of phases
  if (_aqueous_phase_number >= _num_phases)
    paramError("liquid_phase_number",
               "This value is larger than the possible number of phases ",
               _num_phases);

  // Check that _aqueous_fluid_component is <= total number of fluid components
  if (_aqueous_fluid_component >= _num_components)
    paramError("liquid_fluid_component",
               "This value is larger than the possible number of fluid components",
               _num_components);
}

Member Function Documentation

aqueousComponentIndex()

unsigned int PorousFlowFluidStateBase::aqueousComponentIndex ( ) const

inlineinherited

The index of the aqueous fluid component.

Returns

aqueous fluid component number

Definition at line 117 of file PorousFlowFluidStateBase.h.

{ return _aqueous_fluid_component; };

aqueousPhaseIndex()

unsigned int PorousFlowFluidStateBase::aqueousPhaseIndex ( ) const

inlineinherited

The index of the aqueous phase.

Returns

aqueous phase number

Definition at line 105 of file PorousFlowFluidStateBase.h.

{ return _aqueous_phase_number; };

checkVariables()

void PorousFlowWaterNCG::checkVariables ( Real  temperature ) const

protected

Check that the temperature is between the triple and critical values.

Parameters

temperature

fluid temperature (K)

Definition at line 517 of file PorousFlowWaterNCG.C.

Referenced by thermophysicalProperties(), and totalMassFraction().

{
  // Check whether the input temperature is within the region of validity of this equation
  // of state (T_triple <= T <= T_critical)
  if (temperature < _water_triple_temperature || temperature > _water_critical_temperature)
    mooseException(name() + ": temperature " + Moose::stringify(temperature) +
                   " is outside range 273.16 K <= T <= 647.096 K");
}

clearFluidStateProperties()

void PorousFlowFluidStateBase::clearFluidStateProperties ( std::vector< FluidStateProperties > &  fsp ) const

inherited

Clears the contents of the FluidStateProperties data structure.

Parameters

[out]

fsp

FluidStateProperties data structure with all data initialized to 0

Definition at line 41 of file PorousFlowFluidStateBase.C.

Referenced by thermophysicalProperties(), and PorousFlowBrineCO2::thermophysicalProperties().

{
  std::fill(fsp.begin(), fsp.end(), FluidStateProperties(_num_components));
}

enthalpyOfDissolution()

void PorousFlowWaterNCG::enthalpyOfDissolution	(	Real	temperature,
		Real &	hdis,
		Real &	dhdis_dT
	)		const

Enthalpy of dissolution of NCG in water calculated using Henry's constant From Himmelblau, Partial molal heats and entropies of solution for gases dissolved in water from the freezing to the near critical point, J.

Phys. Chem. 63 (1959)

Parameters

	temperature	fluid temperature (K)
[out]	hdis	enthalpy of dissolution (J/kg)
[out]	dhdis_dT	derivative of enthalpy of dissolution wrt temperature

Definition at line 527 of file PorousFlowWaterNCG.C.

Referenced by liquidProperties().

{
  // Henry's constant
  Real Kh, dKh_dT;
  _ncg_fp.henryConstant(temperature, Kh, dKh_dT);

  hdis = -_R * temperature * temperature * dKh_dT / Kh / _Mncg;

  // Derivative of enthalpy of dissolution wrt temperature requires the second derivative of
  // Henry's constant wrt temperature. For simplicity, approximate this numerically
  const Real dT = temperature * 1.0e-8;
  const Real t2 = temperature + dT;
  _ncg_fp.henryConstant(t2, Kh, dKh_dT);

  dhdis_dT = (-_R * t2 * t2 * dKh_dT / Kh / _Mncg - hdis) / dT;
}

equilibriumMassFractions()

void PorousFlowWaterNCG::equilibriumMassFractions	(	Real	pressure,
		Real	temperature,
		Real &	Xncg,
		Real &	dXncg_dp,
		Real &	dXncg_dT,
		Real &	Yh2o,
		Real &	dYh2o_dp,
		Real &	dYh2o_dT
	)		const

Mass fractions of NCG in liquid phase and H2O in gas phase at thermodynamic equilibrium.

Calculated using Henry's law (for NCG component), and Raoult's law (for water).

Parameters

	pressure	phase pressure (Pa)
	temperature	phase temperature (C)
[out]	Xncg	mass fraction of NCG in liquid (kg/kg)
[out]	dXncg_dp	derivative of mass fraction of NCG in liquid wrt pressure
[out]	dXncg_dT	derivative of mass fraction of NCG in liqiud wrt temperature
[out]	Yh2o	mass fraction of H2O in gas (kg/kg)
[out]	dYh2o_dp	derivative of mass fraction of NCG in gas wrt pressure
[out]	dYh2o_dT	derivative of mass fraction of NCG in gas wrt temperature

Definition at line 461 of file PorousFlowWaterNCG.C.

Referenced by massFractions(), and totalMassFraction().

{
  // Equilibrium constants for each component (Henry's law for the NCG
  // component, and Raoult's law for water).
  Real Kh, dKh_dT, psat, dpsat_dT;
  _ncg_fp.henryConstant(temperature, Kh, dKh_dT);
  _water_fp.vaporPressure(temperature, psat, dpsat_dT);
  const Real Kncg = Kh / pressure;
  const Real Kh2o = psat / pressure;

  // The mole fractions for the NCG component in the two component
  // case can be expressed in terms of the equilibrium constants only
  const Real xncg = (1.0 - Kh2o) / (Kncg - Kh2o);
  const Real yncg = Kncg * xncg;

  // Convert mole fractions to mass fractions
  Xncg = moleFractionToMassFraction(xncg);
  Yh2o = 1.0 - moleFractionToMassFraction(yncg);

  // Derivatives of mass fractions wrt PorousFlow variables
  const Real dKncg_dp = -Kh / pressure / pressure;
  const Real dKncg_dT = dKh_dT / pressure;

  const Real dKh2o_dp = -psat / pressure / pressure;
  const Real dKh2o_dT = dpsat_dT / pressure;

  Real dxncg_dp = ((Kh2o - 1.0) * dKncg_dp + (1 - Kncg) * dKh2o_dp) / (Kncg - Kh2o) / (Kncg - Kh2o);
  Real dyncg_dp = xncg * dKncg_dp + Kncg * dxncg_dp;
  Real dxncg_dT = ((Kh2o - 1.0) * dKncg_dT + (1 - Kncg) * dKh2o_dT) / (Kncg - Kh2o) / (Kncg - Kh2o);
  Real dyncg_dT = xncg * dKncg_dT + Kncg * dxncg_dT;

  Real dXncg_dxncg =
      _Mncg * _Mh2o / (xncg * _Mncg + (1.0 - xncg) * _Mh2o) / (xncg * _Mncg + (1.0 - xncg) * _Mh2o);
  Real dYncg_dyncg =
      _Mncg * _Mh2o / (yncg * _Mncg + (1.0 - yncg) * _Mh2o) / (yncg * _Mncg + (1.0 - yncg) * _Mh2o);

  dXncg_dp = dXncg_dxncg * dxncg_dp;
  dXncg_dT = dXncg_dxncg * dxncg_dT;
  dYh2o_dp = -dYncg_dyncg * dyncg_dp;
  dYh2o_dT = -dYncg_dyncg * dyncg_dT;
}

execute()

void PorousFlowFluidStateFlash::execute ( )

inlinefinalinherited

Definition at line 37 of file PorousFlowFluidStateFlash.h.

{};

finalize()

void PorousFlowFluidStateFlash::finalize ( )

inlinefinalinherited

Definition at line 38 of file PorousFlowFluidStateFlash.h.

{};

fluidStateName()

std::string PorousFlowWaterNCG::fluidStateName ( ) const

overridevirtual

Name of FluidState.

Implements PorousFlowFluidStateBase.

Definition at line 61 of file PorousFlowWaterNCG.C.

{
  return "water-ncg";
}

gasComponentIndex()

unsigned int PorousFlowFluidStateBase::gasComponentIndex ( ) const

inlineinherited

The index of the gas fluid component.

Returns

gas fluid component number

Definition at line 123 of file PorousFlowFluidStateBase.h.

{ return _gas_fluid_component; };

gasPhaseIndex()

unsigned int PorousFlowFluidStateBase::gasPhaseIndex ( ) const

inlineinherited

The index of the gas phase.

Returns

gas phase number

Definition at line 111 of file PorousFlowFluidStateBase.h.

{ return _gas_phase_number; };

gasProperties()

void PorousFlowWaterNCG::gasProperties	(	Real	pressure,
		Real	temperature,
		std::vector< FluidStateProperties > &	fsp
	)		const

Gas density.

Parameters

	pressure	gas pressure (Pa)
	temperature	temperature (C)
[out]	FluidStateDensity	data structure

Definition at line 223 of file PorousFlowWaterNCG.C.

Referenced by thermophysicalProperties(), and totalMassFraction().

{
  FluidStateProperties & liquid = fsp[_aqueous_phase_number];
  FluidStateProperties & gas = fsp[_gas_phase_number];

  Real psat, dpsat_dT;
  _water_fp.vaporPressure(temperature, psat, dpsat_dT);

  const Real Yncg = gas.mass_fraction[_gas_fluid_component];
  const Real dYncg_dp = gas.dmass_fraction_dp[_gas_fluid_component];
  const Real dYncg_dT = gas.dmass_fraction_dT[_gas_fluid_component];
  const Real dYncg_dZ = gas.dmass_fraction_dZ[_gas_fluid_component];

  const Real Xncg = liquid.mass_fraction[_gas_fluid_component];
  const Real dXncg_dp = liquid.dmass_fraction_dp[_gas_fluid_component];
  const Real dXncg_dT = liquid.dmass_fraction_dT[_gas_fluid_component];
  const Real dXncg_dZ = liquid.dmass_fraction_dZ[_gas_fluid_component];

  // Note: take derivative wrt (Yncg * p) etc, hence the dp0
  Real ncg_density, dncg_density_dp0, dncg_density_dT;
  Real ncg_viscosity, dncg_viscosity_dp0, dncg_viscosity_dT;
  Real ncg_enthalpy, dncg_enthalpy_dp0, dncg_enthalpy_dT;
  Real vapor_density, dvapor_density_dp0, dvapor_density_dT;
  Real vapor_viscosity, dvapor_viscosity_dp0, dvapor_viscosity_dT;
  Real vapor_enthalpy, dvapor_enthalpy_dp0, dvapor_enthalpy_dT;

  // NCG density, viscosity and enthalpy calculated using partial pressure
  // Yncg * gas_poreressure (Dalton's law)
  _ncg_fp.rho_mu_from_p_T(Yncg * pressure,
                          temperature,
                          ncg_density,
                          dncg_density_dp0,
                          dncg_density_dT,
                          ncg_viscosity,
                          dncg_viscosity_dp0,
                          dncg_viscosity_dT);

  _ncg_fp.h_from_p_T(
      Yncg * pressure, temperature, ncg_enthalpy, dncg_enthalpy_dp0, dncg_enthalpy_dT);

  // Vapor density, viscosity and enthalpy calculated using partial pressure
  // X1 * psat (Raoult's law)
  _water_fp.rho_mu_from_p_T((1.0 - Xncg) * psat,
                            temperature,
                            vapor_density,
                            dvapor_density_dp0,
                            dvapor_density_dT,
                            vapor_viscosity,
                            dvapor_viscosity_dp0,
                            dvapor_viscosity_dT);

  _water_fp.h_from_p_T(
      (1.0 - Xncg) * psat, temperature, vapor_enthalpy, dvapor_enthalpy_dp0, dvapor_enthalpy_dT);

  // Derivative wrt Z by the chain rule
  Real dncg_density_dZ = dYncg_dZ * pressure * dncg_density_dp0;
  Real dvapor_density_dZ = -dXncg_dZ * psat * dvapor_density_dp0;
  Real dncg_viscosity_dZ = dYncg_dZ * pressure * dncg_viscosity_dp0;
  Real dvapor_viscosity_dZ = -dXncg_dZ * psat * dvapor_viscosity_dp0;
  Real dncg_enthalpy_dZ = dYncg_dZ * pressure * dncg_enthalpy_dp0;
  Real dvapor_enthalpy_dZ = -dXncg_dZ * psat * dvapor_enthalpy_dp0;

  // The derivatives wrt pressure and temperature above also depend on the derivative
  // of the pressure variable using the chain rule
  Real dncg_density_dp = (Yncg + dYncg_dp * pressure) * dncg_density_dp0;
  dncg_density_dT += dYncg_dT * pressure * dncg_density_dp0;

  Real dvapor_density_dp = -dXncg_dp * psat * dvapor_density_dp0;
  dvapor_density_dT += ((1.0 - Xncg) * dpsat_dT - dXncg_dT * psat) * dvapor_density_dp0;

  Real dncg_viscosity_dp = (Yncg + dYncg_dp * pressure) * dncg_viscosity_dp0;
  dncg_viscosity_dT += dYncg_dT * pressure * dncg_viscosity_dp0;

  Real dvapor_viscosity_dp = -dXncg_dp * psat * dvapor_viscosity_dp0;
  dvapor_viscosity_dT += ((1.0 - Xncg) * dpsat_dT - dXncg_dT * psat) * dvapor_viscosity_dp0;

  Real dncg_enthalpy_dp = (Yncg + dYncg_dp * pressure) * dncg_enthalpy_dp0;
  dncg_enthalpy_dT += dYncg_dT * pressure * dncg_enthalpy_dp0;

  Real dvapor_enthalpy_dp = -dXncg_dp * psat * dvapor_enthalpy_dp0;
  dvapor_enthalpy_dT += ((1.0 - Xncg) * dpsat_dT - dXncg_dT * psat) * dvapor_enthalpy_dp0;

  // Density is just the sum of individual component densities
  gas.density = ncg_density + vapor_density;
  gas.ddensity_dp = dncg_density_dp + dvapor_density_dp;
  gas.ddensity_dT = dncg_density_dT + dvapor_density_dT;
  gas.ddensity_dZ = dncg_density_dZ + dvapor_density_dZ;

  // Viscosity of the gas phase is a weighted sum of the individual viscosities
  gas.viscosity = Yncg * ncg_viscosity + (1.0 - Yncg) * vapor_viscosity;
  gas.dviscosity_dp = dYncg_dp * (ncg_viscosity - vapor_viscosity) + Yncg * dncg_viscosity_dp +
                      (1.0 - Yncg) * dvapor_viscosity_dp;
  gas.dviscosity_dT = dYncg_dT * (ncg_viscosity - vapor_viscosity) + Yncg * dncg_viscosity_dT +
                      (1.0 - Yncg) * dvapor_viscosity_dT;
  gas.dviscosity_dZ = dYncg_dZ * (ncg_viscosity - vapor_viscosity) + Yncg * dncg_viscosity_dZ +
                      (1.0 - Yncg) * dvapor_viscosity_dZ;

  // Enthalpy of the gas phase is a weighted sum of the individual enthalpies
  gas.enthalpy = Yncg * ncg_enthalpy + (1.0 - Yncg) * vapor_enthalpy;
  gas.denthalpy_dp = dYncg_dp * (ncg_enthalpy - vapor_enthalpy) + Yncg * dncg_enthalpy_dp +
                     (1.0 - Yncg) * dvapor_enthalpy_dp;
  gas.denthalpy_dT = dYncg_dT * (ncg_enthalpy - vapor_enthalpy) + Yncg * dncg_enthalpy_dT +
                     (1.0 - Yncg) * dvapor_enthalpy_dT;
  gas.denthalpy_dZ = dYncg_dZ * (ncg_enthalpy - vapor_enthalpy) + Yncg * dncg_enthalpy_dZ +
                     (1.0 - Yncg) * dvapor_enthalpy_dZ;
}

initialize()

void PorousFlowFluidStateFlash::initialize ( )

inlinefinalinherited

Definition at line 36 of file PorousFlowFluidStateFlash.h.

{};

liquidProperties()

void PorousFlowWaterNCG::liquidProperties	(	Real	pressure,
		Real	temperature,
		std::vector< FluidStateProperties > &	fsp
	)		const

Liquid density.

Parameters

	pressure	liquid pressure (Pa)
	temperature	temperature (C)
[out]	FluidStateDensity	data structure

Definition at line 333 of file PorousFlowWaterNCG.C.

Referenced by thermophysicalProperties(), and totalMassFraction().

{
  FluidStateProperties & liquid = fsp[_aqueous_phase_number];

  // Calculate liquid density and viscosity if in the two phase or single phase
  // liquid region, assuming they are not affected by the presence of dissolved
  // NCG. Note: the (small) contribution due to derivative of capillary pressure
  // wrt pressure (using the chain rule) is not implemented.
  Real liquid_density, dliquid_density_dp, dliquid_density_dT;
  Real liquid_viscosity, dliquid_viscosity_dp, dliquid_viscosity_dT;
  _water_fp.rho_mu_from_p_T(pressure,
                            temperature,
                            liquid_density,
                            dliquid_density_dp,
                            dliquid_density_dT,
                            liquid_viscosity,
                            dliquid_viscosity_dp,
                            dliquid_viscosity_dT);

  liquid.density = liquid_density;
  liquid.ddensity_dp = dliquid_density_dp;
  liquid.ddensity_dT = dliquid_density_dT;
  liquid.ddensity_dZ = 0.0;

  liquid.viscosity = liquid_viscosity;
  liquid.dviscosity_dp = dliquid_viscosity_dp;
  liquid.dviscosity_dT = dliquid_viscosity_dT;
  liquid.dviscosity_dZ = 0.0;

  // Enthalpy does include a contribution due to the enthalpy of dissolution
  Real hdis, dhdis_dT;
  enthalpyOfDissolution(temperature, hdis, dhdis_dT);

  Real water_enthalpy, dwater_enthalpy_dp, dwater_enthalpy_dT;
  _water_fp.h_from_p_T(
      pressure, temperature, water_enthalpy, dwater_enthalpy_dp, dwater_enthalpy_dT);

  // Enthalpy of gaseous CO2
  Real ncg_enthalpy, dncg_enthalpy_dp, dncg_enthalpy_dT;
  _ncg_fp.h_from_p_T(pressure, temperature, ncg_enthalpy, dncg_enthalpy_dp, dncg_enthalpy_dT);

  const Real Xncg = liquid.mass_fraction[_gas_fluid_component];
  const Real dXncg_dp = liquid.dmass_fraction_dp[_gas_fluid_component];
  const Real dXncg_dT = liquid.dmass_fraction_dT[_gas_fluid_component];
  const Real dXncg_dZ = liquid.dmass_fraction_dZ[_gas_fluid_component];

  liquid.enthalpy = (1.0 - Xncg) * water_enthalpy + Xncg * (ncg_enthalpy + hdis);
  liquid.denthalpy_dp = (1.0 - Xncg) * dwater_enthalpy_dp - dXncg_dp * water_enthalpy +
                        Xncg * dncg_enthalpy_dp + dXncg_dp * (ncg_enthalpy + hdis);
  liquid.denthalpy_dT = (1.0 - Xncg) * dwater_enthalpy_dT - dXncg_dT * water_enthalpy +
                        Xncg * dncg_enthalpy_dT + dXncg_dT * (ncg_enthalpy + hdis) +
                        Xncg * dhdis_dT;
  liquid.denthalpy_dZ = dXncg_dZ * (ncg_enthalpy + hdis - water_enthalpy);
}

massFractions()

void PorousFlowWaterNCG::massFractions	(	Real	pressure,
		Real	temperature,
		Real	Z,
		FluidStatePhaseEnum &	phase_state,
		std::vector< FluidStateProperties > &	fsp
	)		const

Mass fractions of NCG and H2O in both phases, as well as derivatives wrt PorousFlow variables.

Values depend on the phase state (liquid, gas or two phase)

Parameters

	pressure	phase pressure (Pa)
	temperature	phase temperature (C)
	Z	total mass fraction of NCG component
[out]	PhaseStateEnum	current phase state
[out]	FluidStateMassFractions	data structure

Definition at line 136 of file PorousFlowWaterNCG.C.

Referenced by thermophysicalProperties().

{
  FluidStateProperties & liquid = fsp[_aqueous_phase_number];
  FluidStateProperties & gas = fsp[_gas_phase_number];

  // Equilibrium mass fraction of NCG in liquid and H2O in gas phases
  Real Xncg, dXncg_dp, dXncg_dT, Yh2o, dYh2o_dp, dYh2o_dT;
  equilibriumMassFractions(
      pressure, temperature, Xncg, dXncg_dp, dXncg_dT, Yh2o, dYh2o_dp, dYh2o_dT);

  Real Yncg = 1.0 - Yh2o;
  Real dYncg_dp = -dYh2o_dp;
  Real dYncg_dT = -dYh2o_dT;

  // Determine which phases are present based on the value of Z
  phaseState(Z, Xncg, Yncg, phase_state);

  // The equilibrium mass fractions calculated above are only correct in the two phase
  // state. If only liquid or gas phases are present, the mass fractions are given by
  // the total mass fraction Z.
  Real Xh2o = 0.0;
  Real dXncg_dZ = 0.0, dYncg_dZ = 0.0;

  switch (phase_state)
  {
    case FluidStatePhaseEnum::LIQUID:
    {
      Xncg = Z;
      Yncg = 0.0;
      Xh2o = 1.0 - Z;
      Yh2o = 0.0;
      dXncg_dp = 0.0;
      dXncg_dT = 0.0;
      dXncg_dZ = 1.0;
      dYncg_dp = 0.0;
      dYncg_dT = 0.0;
      break;
    }

    case FluidStatePhaseEnum::GAS:
    {
      Xncg = 0.0;
      Yncg = Z;
      Yh2o = 1.0 - Z;
      dXncg_dp = 0.0;
      dXncg_dT = 0.0;
      dYncg_dZ = 1.0;
      dYncg_dp = 0.0;
      dYncg_dT = 0.0;
      break;
    }

    case FluidStatePhaseEnum::TWOPHASE:
    {
      // Keep equilibrium mass fractions
      Xh2o = 1.0 - Xncg;
      break;
    }
  }

  // Save the mass fractions in the FluidStateMassFractions object
  liquid.mass_fraction[_aqueous_fluid_component] = Xh2o;
  liquid.mass_fraction[_gas_fluid_component] = Xncg;
  gas.mass_fraction[_aqueous_fluid_component] = Yh2o;
  gas.mass_fraction[_gas_fluid_component] = Yncg;

  // Save the derivatives wrt PorousFlow variables
  liquid.dmass_fraction_dp[_aqueous_fluid_component] = -dXncg_dp;
  liquid.dmass_fraction_dp[_gas_fluid_component] = dXncg_dp;
  liquid.dmass_fraction_dT[_aqueous_fluid_component] = -dXncg_dT;
  liquid.dmass_fraction_dT[_gas_fluid_component] = dXncg_dT;
  liquid.dmass_fraction_dZ[_aqueous_fluid_component] = -dXncg_dZ;
  liquid.dmass_fraction_dZ[_gas_fluid_component] = dXncg_dZ;

  gas.dmass_fraction_dp[_aqueous_fluid_component] = -dYncg_dp;
  gas.dmass_fraction_dp[_gas_fluid_component] = dYncg_dp;
  gas.dmass_fraction_dT[_aqueous_fluid_component] = -dYncg_dT;
  gas.dmass_fraction_dT[_gas_fluid_component] = dYncg_dT;
  gas.dmass_fraction_dZ[_aqueous_fluid_component] = -dYncg_dZ;
  gas.dmass_fraction_dZ[_gas_fluid_component] = dYncg_dZ;
}

moleFractionToMassFraction()

Real PorousFlowWaterNCG::moleFractionToMassFraction ( Real  xmol ) const

protected

Convert mole fraction to mass fraction.

Parameters

xmol	mole fraction

Returns

mass fraction

Definition at line 511 of file PorousFlowWaterNCG.C.

Referenced by equilibriumMassFractions().

{
  return xmol * _Mncg / (xmol * _Mncg + (1.0 - xmol) * _Mh2o);
}

numComponents()

unsigned int PorousFlowFluidStateBase::numComponents ( ) const

inlineinherited

The maximum number of components in this model.

Returns

number of components

Definition at line 99 of file PorousFlowFluidStateBase.h.

{ return _num_components; };

numPhases()

unsigned int PorousFlowFluidStateBase::numPhases ( ) const

inlineinherited

The maximum number of phases in this model.

Returns

number of phases

Definition at line 93 of file PorousFlowFluidStateBase.h.

Referenced by PorousFlowFluidState::PorousFlowFluidState().

{ return _num_phases; };

phaseState()

void PorousFlowFluidStateFlash::phaseState ( Real  Zi, Real  Xi, Real  Yi, FluidStatePhaseEnum &  phase_state  ) const

protectedinherited

Determines the phase state gven the total mass fraction and equilibrium mass fractions.

Parameters

	Zi	total mass fraction
	Xi	equilibrium mass fraction in liquid
	Yi	equilibrium mass fraction in gas
[out]	phase_state	the phase state (gas, liquid, two phase)

Definition at line 29 of file PorousFlowFluidStateFlash.C.

Referenced by massFractions(), and PorousFlowBrineCO2::massFractions().

{
  if (Zi <= Xi)
  {
    // In this case, there is not enough component i to form a gas phase,
    // so only a liquid phase is present
    phase_state = FluidStatePhaseEnum::LIQUID;
  }
  else if (Zi > Xi && Zi < Yi)
  {
    // Two phases are present
    phase_state = FluidStatePhaseEnum::TWOPHASE;
  }
  else // (Zi >= Yi)
  {
    // In this case, there is not enough water to form a liquid
    // phase, so only a gas phase is present
    phase_state = FluidStatePhaseEnum::GAS;
  }
}

rachfordRice()

Real PorousFlowFluidStateFlash::rachfordRice ( Real  vf, std::vector< Real > &  Zi, std::vector< Real > &  Ki  ) const

inherited

Rachford-Rice equation for vapor fraction.

Can be solved analytically for two components in two phases, but must be solved iteratively using a root finding algorithm for more components. This equation has the nice property that it is monotonic in the interval [0,1], so that only a small number of iterations are typically required to find the root.

The Rachford-Rice equation can also be used to check whether the phase state is two phase, single phase gas, or single phase liquid. Evaluate f(v), the Rachford-Rice equation evaluated at the vapor mass fraction.

If f(0) < 0, then the mixture is below the bubble point, and only a single phase liquid can exist

If f(1) > 0, then the mixture is above the dew point, and only a single phase gas exists.

If f(0) >= 0 and f(1) <= 0, the mixture is between the bubble and dew points, and both gas and liquid phases exist.

Parameters

vf	vapor fraction
Zi	mass fractions
Ki	equilibrium constants

Returns

f(x)

Definition at line 54 of file PorousFlowFluidStateFlash.C.

Referenced by PorousFlowFluidStateFlash::vaporMassFraction().

{
  const std::size_t num_z = Zi.size();
  // Check that the sizes of the mass fractions and equilibrium constant vectors are correct
  if (Ki.size() != num_z + 1)
    mooseError("The number of mass fractions or equilibrium components passed to rachfordRice is "
               "not correct");

  Real f = 0.0;
  Real Z_total = 0.0;

  for (std::size_t i = 0; i < num_z; ++i)
  {
    f += Zi[i] * (Ki[i] - 1.0) / (1.0 + x * (Ki[i] - 1.0));
    Z_total += Zi[i];
  }

  // Add the last component (with total mass fraction = 1 - z_total)
  f += (1.0 - Z_total) * (Ki[num_z] - 1.0) / (1.0 + x * (Ki[num_z] - 1.0));

  return f;
}

rachfordRiceDeriv()

Real PorousFlowFluidStateFlash::rachfordRiceDeriv ( Real  vf, std::vector< Real > &  Zi, std::vector< Real > &  Ki  ) const

inherited

Derivative of Rachford-Rice equation wrt vapor fraction.

Has the nice property that it is strictly negative in the interval [0,1]

Parameters

vf	vapor fraction
Zi	mass fractions
Ki	equilibrium constants

Returns

f'(x)

Definition at line 80 of file PorousFlowFluidStateFlash.C.

Referenced by PorousFlowFluidStateFlash::vaporMassFraction().

{
  const std::size_t num_Z = Zi.size();
  // Check that the sizes of the mass fractions and equilibrium constant vectors are correct
  if (Ki.size() != num_Z + 1)
    mooseError("The number of mass fractions or equilibrium components passed to rachfordRice is "
               "not correct");

  Real df = 0.0;
  Real Z_total = 0.0;

  for (std::size_t i = 0; i < num_Z; ++i)
  {
    df -= Zi[i] * (Ki[i] - 1.0) * (Ki[i] - 1.0) / (1.0 + x * (Ki[i] - 1.0)) /
          (1.0 + x * (Ki[i] - 1.0));
    Z_total += Zi[i];
  }

  // Add the last component (with total mass fraction = 1 - z_total)
  df -= (1.0 - Z_total) * (Ki[num_Z] - 1.0) * (Ki[num_Z] - 1.0) / (1.0 + x * (Ki[num_Z] - 1.0)) /
        (1.0 + x * (Ki[num_Z] - 1.0));

  return df;
}

saltComponentIndex()

unsigned int PorousFlowFluidStateBase::saltComponentIndex ( ) const

inlineinherited

The index of the salt component.

Returns

salt component number

Definition at line 129 of file PorousFlowFluidStateBase.h.

{ return _salt_component; };

saturationTwoPhase()

void PorousFlowWaterNCG::saturationTwoPhase	(	Real	pressure,
		Real	temperature,
		Real	Z,
		std::vector< FluidStateProperties > &	fsp
	)		const

Gas and liquid saturation in the two-phase region.

Parameters

	pressure	gas pressure (Pa)
	temperature	phase temperature (C)
	Z	total mass fraction of NCG component
[out]	FluidStateSaturation	data structure

Definition at line 391 of file PorousFlowWaterNCG.C.

Referenced by thermophysicalProperties().

{
  FluidStateProperties & liquid = fsp[_aqueous_phase_number];
  FluidStateProperties & gas = fsp[_gas_phase_number];

  // Mass fractions
  const Real Xncg = liquid.mass_fraction[_gas_fluid_component];
  const Real dXncg_dp = liquid.dmass_fraction_dp[_gas_fluid_component];
  const Real dXncg_dT = liquid.dmass_fraction_dT[_gas_fluid_component];

  const Real Yncg = gas.mass_fraction[_gas_fluid_component];
  const Real dYncg_dp = gas.dmass_fraction_dp[_gas_fluid_component];
  const Real dYncg_dT = gas.dmass_fraction_dT[_gas_fluid_component];

  // Calculate the vapor mass fraction
  const Real K0 = Yncg / Xncg;
  const Real K1 = (1.0 - Yncg) / (1.0 - Xncg);
  const Real vapor_mass_fraction = vaporMassFraction(Z, K0, K1);

  // Liquid density is a function of gas saturation through the capillary pressure
  // curve, so approximate liquid pressure as gas pressure
  const Real liquid_pressure = pressure;

  Real liquid_density, liquid_ddensity_dp, liquid_ddensity_dT;
  _water_fp.rho_from_p_T(
      liquid_pressure, temperature, liquid_density, liquid_ddensity_dp, liquid_ddensity_dT);

  // The gas saturation in the two phase case
  gas.saturation = vapor_mass_fraction * liquid_density /
                   (gas.density + vapor_mass_fraction * (liquid_density - gas.density));

  const Real dv_dZ = (K1 - K0) / ((K0 - 1.0) * (K1 - 1.0));
  const Real denominator = (gas.density + vapor_mass_fraction * (liquid_density - gas.density)) *
                           (gas.density + vapor_mass_fraction * (liquid_density - gas.density));

  const Real ds_dZ = gas.density * liquid_density * dv_dZ / denominator;

  const Real dK0_dp = (Xncg * dYncg_dp - Yncg * dXncg_dp) / Xncg / Xncg;
  const Real dK0_dT = (Xncg * dYncg_dT - Yncg * dXncg_dT) / Xncg / Xncg;

  const Real dK1_dp =
      ((1.0 - Yncg) * dXncg_dp - (1.0 - Xncg) * dYncg_dp) / (1.0 - Xncg) / (1.0 - Xncg);
  const Real dK1_dT =
      ((1.0 - Yncg) * dXncg_dT - (1.0 - Xncg) * dYncg_dT) / (1.0 - Xncg) / (1.0 - Xncg);

  const Real dv_dp =
      Z * dK1_dp / (K1 - 1.0) / (K1 - 1.0) + (1.0 - Z) * dK0_dp / (K0 - 1.0) / (K0 - 1.0);

  Real ds_dp = gas.density * liquid_density * dv_dp +
               vapor_mass_fraction * (1.0 - vapor_mass_fraction) *
                   (gas.density * liquid_ddensity_dp - gas.ddensity_dp * liquid_density);
  ds_dp /= denominator;

  const Real dv_dT =
      Z * dK1_dT / (K1 - 1.0) / (K1 - 1.0) + (1.0 - Z) * dK0_dT / (K0 - 1.0) / (K0 - 1.0);

  Real ds_dT = gas.density * liquid_density * dv_dT +
               vapor_mass_fraction * (1.0 - vapor_mass_fraction) *
                   (gas.density * liquid_ddensity_dT - gas.ddensity_dT * liquid_density);
  ds_dT /= denominator;

  gas.dsaturation_dp = ds_dp;
  gas.dsaturation_dT = ds_dT;
  gas.dsaturation_dZ = ds_dZ;
}

thermophysicalProperties()

void PorousFlowWaterNCG::thermophysicalProperties ( Real  pressure, Real  temperature, Real  Xnacl, Real  Z, unsigned int  qp, std::vector< FluidStateProperties > &  fsp  ) const

overridevirtual

Determines the complete thermophysical state of the system for a given set of primary variables.

Parameters

	pressure	gas phase pressure (Pa)
	temperature	fluid temperature (K)
	Xnacl	mass fraction of NaCl
	Z	total mass fraction of fluid component
	qp	quadpoint index
[out]	fsp	the FluidStateProperties struct containing all properties

Implements PorousFlowFluidStateBase.

Definition at line 67 of file PorousFlowWaterNCG.C.

{
  FluidStateProperties & liquid = fsp[_aqueous_phase_number];
  FluidStateProperties & gas = fsp[_gas_phase_number];

  // Check whether the input temperature is within the region of validity
  checkVariables(temperature);

  // Clear all of the FluidStateProperties data
  clearFluidStateProperties(fsp);

  FluidStatePhaseEnum phase_state;
  massFractions(pressure, temperature, Z, phase_state, fsp);

  switch (phase_state)
  {
    case FluidStatePhaseEnum::GAS:
    {
      // Set the gas saturations
      gas.saturation = 1.0;

      // Calculate gas properties
      gasProperties(pressure, temperature, fsp);

      break;
    }

    case FluidStatePhaseEnum::LIQUID:
    {
      // Calculate the liquid properties
      Real liquid_pressure = pressure - _pc.capillaryPressure(1.0, qp);
      liquidProperties(liquid_pressure, temperature, fsp);

      break;
    }

    case FluidStatePhaseEnum::TWOPHASE:
    {
      // Calculate the gas properties
      gasProperties(pressure, temperature, fsp);

      // Calculate the saturation
      saturationTwoPhase(pressure, temperature, Z, fsp);

      // Calculate the liquid properties
      Real liquid_pressure = pressure - _pc.capillaryPressure(1.0 - gas.saturation, qp);
      liquidProperties(liquid_pressure, temperature, fsp);

      break;
    }
  }

  // Liquid saturations can now be set
  liquid.saturation = 1.0 - gas.saturation;
  liquid.dsaturation_dp = -gas.dsaturation_dp;
  liquid.dsaturation_dT = -gas.dsaturation_dT;
  liquid.dsaturation_dZ = -gas.dsaturation_dZ;

  // Save pressures to FluidStateProperties object
  gas.pressure = pressure;
  liquid.pressure = pressure - _pc.capillaryPressure(liquid.saturation, qp);
}

totalMassFraction()

Real PorousFlowWaterNCG::totalMassFraction ( Real  pressure, Real  temperature, Real  Xnacl, Real  saturation, unsigned int  qp  ) const

overridevirtual

Total mass fraction of fluid component summed over all phases in the two-phase state for a specified gas saturation.

Parameters

pressure	gas pressure (Pa)
temperature	temperature (K)
Xnacl	NaCl mass fraction (kg/kg)
saturation	gas saturation (-)
qp	quadpoint index

Returns

total mass fraction Z (-)

Implements PorousFlowFluidStateBase.

Definition at line 545 of file PorousFlowWaterNCG.C.

{
  // Check whether the input temperature is within the region of validity
  checkVariables(temperature);

  // FluidStateProperties data structure
  std::vector<FluidStateProperties> fsp(_num_phases, FluidStateProperties(_num_components));
  FluidStateProperties & liquid = fsp[_aqueous_phase_number];
  FluidStateProperties & gas = fsp[_gas_phase_number];

  // Calculate equilibrium mass fractions in the two-phase state
  Real Xncg, dXncg_dp, dXncg_dT, Yh2o, dYh2o_dp, dYh2o_dT;
  equilibriumMassFractions(
      pressure, temperature, Xncg, dXncg_dp, dXncg_dT, Yh2o, dYh2o_dp, dYh2o_dT);

  // Save the mass fractions in the FluidStateMassFractions object
  const Real Yncg = 1.0 - Yh2o;
  liquid.mass_fraction[_aqueous_fluid_component] = 1.0 - Xncg;
  liquid.mass_fraction[_gas_fluid_component] = Xncg;
  gas.mass_fraction[_aqueous_fluid_component] = Yh2o;
  gas.mass_fraction[_gas_fluid_component] = Yncg;

  // Gas properties
  gasProperties(pressure, temperature, fsp);

  // Liquid properties
  const Real liquid_saturation = 1.0 - saturation;
  const Real liquid_pressure = pressure - _pc.capillaryPressure(liquid_saturation, qp);
  liquidProperties(liquid_pressure, temperature, fsp);

  // The total mass fraction of ncg (Z) can now be calculated
  const Real Z = (saturation * gas.density * Yncg + liquid_saturation * liquid.density * Xncg) /
                 (saturation * gas.density + liquid_saturation * liquid.density);

  return Z;
}

vaporMassFraction() [1/2]

Real PorousFlowFluidStateFlash::vaporMassFraction ( Real  Z0, Real  K0, Real  K1  ) const

inherited

Solves Rachford-Rice equation to provide vapor mass fraction.

For two components, the analytical solution is used, while for cases with more than two components, a Newton-Raphson iterative solution is calculated.

Parameters

Zi	total mass fraction(s)
Ki	equilibrium constant(s)

Returns

vapor mass fraction

Definition at line 108 of file PorousFlowFluidStateFlash.C.

Referenced by saturationTwoPhase(), PorousFlowBrineCO2::saturationTwoPhase(), and PorousFlowFluidStateFlash::vaporMassFraction().

{
  return (Z0 * (K1 - K0) - (K1 - 1.0)) / ((K0 - 1.0) * (K1 - 1.0));
}

vaporMassFraction() [2/2]

Real PorousFlowFluidStateFlash::vaporMassFraction ( std::vector< Real > &  Zi, std::vector< Real > &  Ki  ) const

inherited

Definition at line 114 of file PorousFlowFluidStateFlash.C.

{
  // Check that the sizes of the mass fractions and equilibrium constant vectors are correct
  if (Ki.size() != Zi.size() + 1)
    mooseError("The number of mass fractions or equilibrium components passed to rachfordRice is "
               "not correct");
  Real v;

  // If there are only two components, an analytical solution is possible
  if (Ki.size() == 2)
    v = vaporMassFraction(Zi[0], Ki[0], Ki[1]);
  else
  {
    // More than two components - solve the Rachford-Rice equation using
    // Newton-Raphson method
    // Initial guess for vapor mass fraction
    Real v0 = 0.5;
    unsigned int iter = 0;

    while (std::abs(rachfordRice(v0, Zi, Ki)) > _nr_tol)
    {
      v0 = v0 - rachfordRice(v0, Zi, Ki) / rachfordRiceDeriv(v0, Zi, Ki);
      iter++;

      if (iter > _nr_max_its)
        break;
    }
    v = v0;
  }
  return v;
}

Member Data Documentation

_aqueous_fluid_component

const unsigned int PorousFlowFluidStateBase::_aqueous_fluid_component

protectedinherited

Fluid component number of the aqueous component.

Definition at line 184 of file PorousFlowFluidStateBase.h.

Referenced by PorousFlowFluidStateBase::aqueousComponentIndex(), massFractions(), PorousFlowBrineCO2::massFractions(), PorousFlowBrineCO2::PorousFlowBrineCO2(), PorousFlowWaterNCG(), totalMassFraction(), and PorousFlowBrineCO2::totalMassFraction().

_aqueous_phase_number

const unsigned int PorousFlowFluidStateBase::_aqueous_phase_number

protectedinherited

Phase number of the aqueous phase.

Definition at line 180 of file PorousFlowFluidStateBase.h.

Referenced by PorousFlowFluidStateBase::aqueousPhaseIndex(), gasProperties(), liquidProperties(), PorousFlowBrineCO2::liquidProperties(), massFractions(), PorousFlowBrineCO2::massFractions(), PorousFlowBrineCO2::PorousFlowBrineCO2(), PorousFlowWaterNCG(), saturationTwoPhase(), PorousFlowBrineCO2::saturationTwoPhase(), thermophysicalProperties(), PorousFlowBrineCO2::thermophysicalProperties(), totalMassFraction(), and PorousFlowBrineCO2::totalMassFraction().

_gas_fluid_component

unsigned int PorousFlowFluidStateBase::_gas_fluid_component

protectedinherited

Fluid component number of the gas phase.

Definition at line 186 of file PorousFlowFluidStateBase.h.

Referenced by PorousFlowFluidStateBase::gasComponentIndex(), gasProperties(), liquidProperties(), PorousFlowBrineCO2::liquidProperties(), massFractions(), PorousFlowBrineCO2::massFractions(), PorousFlowBrineCO2::PorousFlowBrineCO2(), PorousFlowWaterNCG(), saturationTwoPhase(), PorousFlowBrineCO2::saturationTwoPhase(), totalMassFraction(), and PorousFlowBrineCO2::totalMassFraction().

_gas_phase_number

unsigned int PorousFlowFluidStateBase::_gas_phase_number

protectedinherited

Phase number of the gas phase.

Definition at line 182 of file PorousFlowFluidStateBase.h.

Referenced by PorousFlowFluidStateBase::gasPhaseIndex(), gasProperties(), PorousFlowBrineCO2::gasProperties(), massFractions(), PorousFlowBrineCO2::massFractions(), PorousFlowBrineCO2::PorousFlowBrineCO2(), PorousFlowWaterNCG(), saturationTwoPhase(), PorousFlowBrineCO2::saturationTwoPhase(), thermophysicalProperties(), PorousFlowBrineCO2::thermophysicalProperties(), totalMassFraction(), and PorousFlowBrineCO2::totalMassFraction().

_Mh2o

const Real PorousFlowWaterNCG::_Mh2o

protected

Molar mass of water (kg/mol)

Definition at line 151 of file PorousFlowWaterNCG.h.

Referenced by equilibriumMassFractions(), and moleFractionToMassFraction().

_Mncg

const Real PorousFlowWaterNCG::_Mncg

protected

Molar mass of non-condensable gas (kg/mol)

Definition at line 153 of file PorousFlowWaterNCG.h.

Referenced by enthalpyOfDissolution(), equilibriumMassFractions(), and moleFractionToMassFraction().

_ncg_fp

const SinglePhaseFluidProperties& PorousFlowWaterNCG::_ncg_fp

protected

Fluid properties UserObject for the NCG.

Definition at line 149 of file PorousFlowWaterNCG.h.

Referenced by enthalpyOfDissolution(), equilibriumMassFractions(), gasProperties(), and liquidProperties().

_nr_max_its

const Real PorousFlowFluidStateBase::_nr_max_its

protectedinherited

Maximum number of iterations for the Newton-Raphson iterations.

Definition at line 194 of file PorousFlowFluidStateBase.h.

_nr_tol

const Real PorousFlowFluidStateBase::_nr_tol

protectedinherited

Tolerance for Newton-Raphson iterations.

Definition at line 196 of file PorousFlowFluidStateBase.h.

_num_components

unsigned int PorousFlowFluidStateBase::_num_components

protectedinherited

Number of components.

Definition at line 178 of file PorousFlowFluidStateBase.h.

Referenced by PorousFlowFluidStateBase::clearFluidStateProperties(), PorousFlowFluidStateBase::numComponents(), PorousFlowBrineCO2::PorousFlowBrineCO2(), PorousFlowWaterNCG(), totalMassFraction(), and PorousFlowBrineCO2::totalMassFraction().

_num_phases

unsigned int PorousFlowFluidStateBase::_num_phases

protectedinherited

Number of phases.

Definition at line 176 of file PorousFlowFluidStateBase.h.

Referenced by PorousFlowFluidStateBase::numPhases(), PorousFlowBrineCO2::PorousFlowBrineCO2(), PorousFlowWaterNCG(), totalMassFraction(), and PorousFlowBrineCO2::totalMassFraction().

_pc

const PorousFlowCapillaryPressure& PorousFlowFluidStateBase::_pc

protectedinherited

Capillary pressure UserObject.

Definition at line 198 of file PorousFlowFluidStateBase.h.

Referenced by thermophysicalProperties(), PorousFlowBrineCO2::thermophysicalProperties(), totalMassFraction(), and PorousFlowBrineCO2::totalMassFraction().

_R

const Real PorousFlowFluidStateBase::_R

protectedinherited

Universal gas constant (J/mol/K)

Definition at line 190 of file PorousFlowFluidStateBase.h.

Referenced by enthalpyOfDissolution(), and PorousFlowBrineCO2::enthalpyOfDissolutionGas().

_salt_component

const unsigned int PorousFlowFluidStateBase::_salt_component

protectedinherited

Salt component index.

Definition at line 188 of file PorousFlowFluidStateBase.h.

Referenced by PorousFlowFluidStateBase::saltComponentIndex().

_T_c2k

const Real PorousFlowFluidStateBase::_T_c2k

protectedinherited

Conversion from C to K.

Definition at line 192 of file PorousFlowFluidStateBase.h.

Referenced by PorousFlowBrineCO2::equilibriumConstantCO2(), PorousFlowBrineCO2::equilibriumConstantH2O(), PorousFlowBrineCO2::funcABHighTemp(), PorousFlowBrineCO2::henryConstant(), and PorousFlowBrineCO2::partialDensityCO2().

_water_critical_temperature

const Real PorousFlowWaterNCG::_water_critical_temperature

protected

Critical temperature of water (K)

Definition at line 157 of file PorousFlowWaterNCG.h.

Referenced by checkVariables().

_water_fp

const SinglePhaseFluidProperties& PorousFlowWaterNCG::_water_fp

protected

Fluid properties UserObject for water.

Definition at line 147 of file PorousFlowWaterNCG.h.

Referenced by equilibriumMassFractions(), gasProperties(), liquidProperties(), PorousFlowWaterNCG(), and saturationTwoPhase().

_water_triple_temperature

const Real PorousFlowWaterNCG::_water_triple_temperature

protected

Triple point temperature of water (K)

Definition at line 155 of file PorousFlowWaterNCG.h.

---

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

• porous_flow/include/userobjects/PorousFlowWaterNCG.h
• porous_flow/src/userobjects/PorousFlowWaterNCG.C