Loading...
Searching...
No Matches
H2ON2FluidSystem.hpp
Go to the documentation of this file.
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
Consult the COPYING file in the top-level source directory of this
module for the precise wording of the license and the list of
copyright holders.
*/
#ifndef OPM_H2O_N2_FLUID_SYSTEM_HPP
#define OPM_H2O_N2_FLUID_SYSTEM_HPP
#include "BaseFluidSystem.hpp"
#include "NullParameterCache.hpp"
#include <opm/material/IdealGas.hpp>
#include <opm/material/components/N2.hpp>
#include <opm/material/components/H2O.hpp>
#include <opm/material/components/SimpleH2O.hpp>
#include <opm/material/components/TabulatedComponent.hpp>
#include <opm/material/binarycoefficients/H2O_N2.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <cassert>
#include <string_view>
namespace Opm {
template <class Scalar>
class H2ON2FluidSystem
: public BaseFluidSystem<Scalar, H2ON2FluidSystem<Scalar> >
{
typedef H2ON2FluidSystem<Scalar> ThisType;
typedef BaseFluidSystem<Scalar, ThisType> Base;
// convenience typedefs
typedef ::Opm::IdealGas<Scalar> IdealGas;
typedef ::Opm::H2O<Scalar> IapwsH2O;
typedef TabulatedComponent<Scalar, IapwsH2O > TabulatedH2O;
typedef ::Opm::N2<Scalar> SimpleN2;
public:
template <class Evaluation>
using ParameterCache = NullParameterCache<Evaluation>;
/****************************************
* Fluid phase related static parameters
****************************************/
static const int numPhases = 2;
static const int liquidPhaseIdx = 0;
static const int gasPhaseIdx = 1;
static std::string_view phaseName(unsigned phaseIdx)
{
static const std::string_view name[] = {
"liquid",
"gas"
};
assert(phaseIdx < numPhases);
return name[phaseIdx];
}
static bool isLiquid(unsigned phaseIdx)
{
//assert(0 <= phaseIdx && phaseIdx < numPhases);
return phaseIdx != gasPhaseIdx;
}
static bool isCompressible(unsigned phaseIdx)
{
//assert(0 <= phaseIdx && phaseIdx < numPhases);
// gases are always compressible
return
(phaseIdx == gasPhaseIdx)
? true
:H2O::liquidIsCompressible();// the water component decides for the liquid phase...
}
static bool isIdealGas(unsigned phaseIdx)
{
//assert(0 <= phaseIdx && phaseIdx < numPhases);
return
(phaseIdx == gasPhaseIdx)
? H2O::gasIsIdeal() && N2::gasIsIdeal() // let the components decide
: false; // not a gas
}
static bool isIdealMixture(unsigned /*phaseIdx*/)
{
//assert(0 <= phaseIdx && phaseIdx < numPhases);
// we assume Henry's and Rault's laws for the water phase and
// and no interaction between gas molecules of different
// components, so all phases are ideal mixtures!
return true;
}
/****************************************
* Component related static parameters
****************************************/
static const int numComponents = 2;
static const int H2OIdx = 0;
static const int N2Idx = 1;
typedef TabulatedH2O H2O;
//typedef SimpleH2O H2O;
//typedef IapwsH2O H2O;
typedef SimpleN2 N2;
static std::string_view componentName(unsigned compIdx)
{
static const std::string_view name[] = {
H2O::name(),
N2::name()
};
assert(compIdx < numComponents);
return name[compIdx];
}
static Scalar molarMass(unsigned compIdx)
{
//assert(0 <= compIdx && compIdx < numComponents);
return (compIdx == H2OIdx)
? H2O::molarMass()
: (compIdx == N2Idx)
? N2::molarMass()
: 1e30;
}
static Scalar criticalTemperature(unsigned compIdx)
{
return (compIdx == H2OIdx)
? H2O::criticalTemperature()
: (compIdx == N2Idx)
? N2::criticalTemperature()
: 1e30;
}
static Scalar criticalPressure(unsigned compIdx)
{
return (compIdx == H2OIdx)
? H2O::criticalPressure()
: (compIdx == N2Idx)
? N2::criticalPressure()
: 1e30;
}
static Scalar acentricFactor(unsigned compIdx)
{
return (compIdx == H2OIdx)
? H2O::acentricFactor()
: (compIdx == N2Idx)
? N2::acentricFactor()
: 1e30;
}
/****************************************
* thermodynamic relations
****************************************/
static void init()
{
init(/*tempMin=*/273.15,
/*tempMax=*/623.15,
/*numTemp=*/50,
/*pMin=*/0.0,
/*pMax=*/20e6,
/*numP=*/50);
}
static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp,
Scalar pressMin, Scalar pressMax, unsigned nPress)
{
if (H2O::isTabulated) {
TabulatedH2O::init(tempMin, tempMax, nTemp,
pressMin, pressMax, nPress);
}
}
template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
static LhsEval density(const FluidState& fluidState,
const ParameterCache<ParamCacheEval>& /*paramCache*/,
unsigned phaseIdx)
{
assert(phaseIdx < numPhases);
const auto& T = decay<LhsEval>(fluidState.temperature(phaseIdx));
const auto& p = decay<LhsEval>(fluidState.pressure(phaseIdx));
LhsEval sumMoleFrac = 0;
for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
sumMoleFrac += decay<LhsEval>(fluidState.moleFraction(phaseIdx, compIdx));
// liquid phase
if (phaseIdx == liquidPhaseIdx) {
// assume ideal mixture where each molecule occupies the same volume regardless
// of whether it is water or nitrogen.
const LhsEval& clH2O = H2O::liquidDensity(T, p)/H2O::molarMass();
const auto& xlH2O = decay<LhsEval>(fluidState.moleFraction(liquidPhaseIdx, H2OIdx));
const auto& xlN2 = decay<LhsEval>(fluidState.moleFraction(liquidPhaseIdx, N2Idx));
return clH2O*(H2O::molarMass()*xlH2O + N2::molarMass()*xlN2)/sumMoleFrac;
}
// gas phase
assert(phaseIdx == gasPhaseIdx);
// assume ideal mixture: steam and nitrogen don't "distinguish" each other
const auto& xgH2O = decay<LhsEval>(fluidState.moleFraction(gasPhaseIdx, H2OIdx));
const auto& xgN2 = decay<LhsEval>(fluidState.moleFraction(gasPhaseIdx, N2Idx));
const auto& rho_gH2O = H2O::gasDensity(T, p*xgH2O);
const auto& rho_gN2 = N2::gasDensity(T, p*xgN2);
return (rho_gH2O + rho_gN2)/max(1e-5, sumMoleFrac);
}
template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
static LhsEval viscosity(const FluidState& fluidState,
const ParameterCache<ParamCacheEval>& /*paramCache*/,
unsigned phaseIdx)
{
assert(phaseIdx < numPhases);
const auto& T = decay<LhsEval>(fluidState.temperature(phaseIdx));
const auto& p = decay<LhsEval>(fluidState.pressure(phaseIdx));
// liquid phase
if (phaseIdx == liquidPhaseIdx)
// assume pure water for the liquid phase
return H2O::liquidViscosity(T, p);
// gas phase
assert(phaseIdx == gasPhaseIdx);
/* Wilke method. See:
*
* See: R. Reid, et al.: The Properties of Gases and Liquids,
* 4th edition, McGraw-Hill, 1987, 407-410
* 5th edition, McGraw-Hill, 20001, p. 9.21/22
*/
LhsEval muResult = 0;
const LhsEval mu[numComponents] = {
H2O::gasViscosity(T, H2O::vaporPressure(T)),
N2::gasViscosity(T, p)
};
LhsEval sumx = 0.0;
for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx)
sumx += decay<LhsEval>(fluidState.moleFraction(phaseIdx, compIdx));
sumx = max(1e-10, sumx);
for (unsigned i = 0; i < numComponents; ++i) {
LhsEval divisor = 0;
for (unsigned j = 0; j < numComponents; ++j) {
LhsEval phiIJ = 1 + sqrt(mu[i]/mu[j]) * std::pow(molarMass(j)/molarMass(i), 1/4.0);
phiIJ *= phiIJ;
phiIJ /= std::sqrt(8*(1 + molarMass(i)/molarMass(j)));
divisor +=
decay<LhsEval>(fluidState.moleFraction(phaseIdx, j))
/sumx*phiIJ;
}
muResult +=
decay<LhsEval>(fluidState.moleFraction(phaseIdx, i))
/sumx*mu[i]/divisor;
}
return muResult;
}
template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
static LhsEval fugacityCoefficient(const FluidState& fluidState,
const ParameterCache<ParamCacheEval>& /*paramCache*/,
unsigned phaseIdx,
unsigned compIdx)
{
assert(phaseIdx < numPhases);
assert(compIdx < numComponents);
const auto& T = decay<LhsEval>(fluidState.temperature(phaseIdx));
const auto& p = decay<LhsEval>(fluidState.pressure(phaseIdx));
// liquid phase
if (phaseIdx == liquidPhaseIdx) {
if (compIdx == H2OIdx)
return H2O::vaporPressure(T)/p;
return BinaryCoeff::H2O_N2::henry(T)/p;
}
assert(phaseIdx == gasPhaseIdx);
// for the gas phase, assume an ideal gas when it comes to
// fugacity (-> fugacity == partial pressure)
return 1.0;
}
template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
static LhsEval diffusionCoefficient(const FluidState& fluidState,
const ParameterCache<ParamCacheEval>& /*paramCache*/,
unsigned phaseIdx,
unsigned /*compIdx*/)
{
const auto& T = decay<LhsEval>(fluidState.temperature(phaseIdx));
const auto& p = decay<LhsEval>(fluidState.pressure(phaseIdx));
// liquid phase
if (phaseIdx == liquidPhaseIdx)
return BinaryCoeff::H2O_N2::liquidDiffCoeff(T, p);
// gas phase
assert(phaseIdx == gasPhaseIdx);
return BinaryCoeff::H2O_N2::gasDiffCoeff(T, p);
}
template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
static LhsEval enthalpy(const FluidState& fluidState,
const ParameterCache<ParamCacheEval>& /*paramCache*/,
unsigned phaseIdx)
{
const auto& T = decay<LhsEval>(fluidState.temperature(phaseIdx));
const auto& p = decay<LhsEval>(fluidState.pressure(phaseIdx));
Valgrind::CheckDefined(T);
Valgrind::CheckDefined(p);
// liquid phase
if (phaseIdx == liquidPhaseIdx) {
// TODO: correct way to deal with the solutes???
return H2O::liquidEnthalpy(T, p);
}
// gas phase
assert(phaseIdx == gasPhaseIdx);
// assume ideal mixture: Molecules of one component don't discriminate between
// their own kind and molecules of the other component.
const auto& XgH2O = decay<LhsEval>(fluidState.massFraction(gasPhaseIdx, H2OIdx));
const auto& XgN2 = decay<LhsEval>(fluidState.massFraction(gasPhaseIdx, N2Idx));
LhsEval hH2O = XgH2O*H2O::gasEnthalpy(T, p);
LhsEval hN2 = XgN2*N2::gasEnthalpy(T, p);
return hH2O + hN2;
}
template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
static LhsEval thermalConductivity(const FluidState& fluidState,
const ParameterCache<ParamCacheEval>& /*paramCache*/,
unsigned phaseIdx)
{
assert(phaseIdx < numPhases);
const auto& T = decay<LhsEval>(fluidState.temperature(phaseIdx));
const auto& p = decay<LhsEval>(fluidState.pressure(phaseIdx));
if (phaseIdx == liquidPhaseIdx) // liquid phase
return H2O::liquidThermalConductivity(T, p);
// gas phase
assert(phaseIdx == gasPhaseIdx);
// return the sum of the partial conductivity of Nitrogen and Steam
const auto& xH2O = decay<LhsEval>(fluidState.moleFraction(phaseIdx, H2OIdx));
const auto& xN2 = decay<LhsEval>(fluidState.moleFraction(phaseIdx, N2Idx));
// Assuming Raoult's, Daltons law and ideal gas in order to obtain the
// partial pressures in the gas phase
const auto& lambdaN2 = N2::gasThermalConductivity(T, p*xN2);
const auto& lambdaH2O = H2O::gasThermalConductivity(T, p*xH2O);
return lambdaN2 + lambdaH2O;
}
template <class FluidState, class LhsEval = typename FluidState::Scalar, class ParamCacheEval = LhsEval>
static LhsEval heatCapacity(const FluidState& fluidState,
const ParameterCache<ParamCacheEval>& /*paramCache*/,
unsigned phaseIdx)
{
const auto& T = decay<LhsEval>(fluidState.temperature(phaseIdx));
const auto& p = decay<LhsEval>(fluidState.pressure(phaseIdx));
const auto& xAlphaH2O = decay<LhsEval>(fluidState.moleFraction(phaseIdx, H2OIdx));
const auto& xAlphaN2 = decay<LhsEval>(fluidState.moleFraction(phaseIdx, N2Idx));
const auto& XAlphaH2O = decay<LhsEval>(fluidState.massFraction(phaseIdx, H2OIdx));
const auto& XAlphaN2 = decay<LhsEval>(fluidState.massFraction(phaseIdx, N2Idx));
if (phaseIdx == liquidPhaseIdx)
return H2O::liquidHeatCapacity(T, p);
assert(phaseIdx == gasPhaseIdx);
// for the gas phase, assume ideal mixture
LhsEval c_pN2;
LhsEval c_pH2O;
c_pN2 = N2::gasHeatCapacity(T, p*xAlphaN2);
c_pH2O = H2O::gasHeatCapacity(T, p*xAlphaH2O);
// mingle both components together. this assumes that there is no "cross
// interaction" between both flavors of molecules.
return XAlphaH2O*c_pH2O + XAlphaN2*c_pN2;
}
};
} // namespace Opm
#endif
BaseFluidSystem.hpp
The base class for all fluid systems.
H2O.hpp
Material properties of pure water .
H2O_N2.hpp
Binary coefficients for water and nitrogen.
IdealGas.hpp
Relations valid for an ideal gas.
N2.hpp
Properties of pure molecular nitrogen .
NullParameterCache.hpp
A parameter cache which does nothing.
SimpleH2O.hpp
A simple version of pure water.
TabulatedComponent.hpp
A generic class which tabulates all thermodynamic properties of a given component.
Valgrind.hpp
Some templates to wrap the valgrind client request macros.
Opm::Valgrind::CheckDefined
OPM_HOST_DEVICE bool CheckDefined(const T &value)
Make valgrind complain if any of the memory occupied by an object is undefined.
Definition Valgrind.hpp:76
Opm::BaseFluidSystem
The base class for all fluid systems.
Definition BaseFluidSystem.hpp:43
Opm::BaseFluidSystem< Scalar, H2ON2FluidSystem< Scalar > >::Scalar
Scalar Scalar
Definition BaseFluidSystem.hpp:48
Opm::BinaryCoeff::H2O_N2::liquidDiffCoeff
static Evaluation liquidDiffCoeff(const Evaluation &temperature, const Evaluation &)
Diffusion coefficent for molecular nitrogen in liquid water.
Definition H2O_N2.hpp:102
Opm::BinaryCoeff::H2O_N2::gasDiffCoeff
static Evaluation gasDiffCoeff(const Evaluation &temperature, const Evaluation &pressure)
Binary diffusion coefficent for molecular water and nitrogen.
Definition H2O_N2.hpp:70
Opm::BinaryCoeff::H2O_N2::henry
static Evaluation henry(const Evaluation &temperature)
Henry coefficent for molecular nitrogen in liquid water.
Definition H2O_N2.hpp:52
Opm::H2ON2FluidSystem
A two-phase fluid system with water and nitrogen as components.
Definition H2ON2FluidSystem.hpp:54
Opm::H2ON2FluidSystem::phaseName
static std::string_view phaseName(unsigned phaseIdx)
Return the human readable name of a fluid phase.
Definition H2ON2FluidSystem.hpp:82
Opm::H2ON2FluidSystem::H2OIdx
static const int H2OIdx
The component index of water.
Definition H2ON2FluidSystem.hpp:140
Opm::H2ON2FluidSystem::acentricFactor
static Scalar acentricFactor(unsigned compIdx)
The acentric factor of a component [].
Definition H2ON2FluidSystem.hpp:208
Opm::H2ON2FluidSystem::thermalConductivity
static LhsEval thermalConductivity(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Thermal conductivity of a fluid phase [W/(m K)].
Definition H2ON2FluidSystem.hpp:429
Opm::H2ON2FluidSystem::criticalTemperature
static Scalar criticalTemperature(unsigned compIdx)
Critical temperature of a component [K].
Definition H2ON2FluidSystem.hpp:180
Opm::H2ON2FluidSystem::H2O
TabulatedH2O H2O
The component for pure water.
Definition H2ON2FluidSystem.hpp:145
Opm::H2ON2FluidSystem::init
static void init()
Initialize the fluid system's static parameters.
Definition H2ON2FluidSystem.hpp:227
Opm::H2ON2FluidSystem::init
static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp, Scalar pressMin, Scalar pressMax, unsigned nPress)
Initialize the fluid system's static parameters using problem specific temperature and pressure range...
Definition H2ON2FluidSystem.hpp:248
Opm::H2ON2FluidSystem::density
static LhsEval density(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Calculate the density [kg/m^3] of a fluid phase.
Definition H2ON2FluidSystem.hpp:261
Opm::H2ON2FluidSystem::isIdealMixture
static bool isIdealMixture(unsigned)
Returns true if and only if a fluid phase is assumed to be an ideal mixture.
Definition H2ON2FluidSystem.hpp:123
Opm::H2ON2FluidSystem::isLiquid
static bool isLiquid(unsigned phaseIdx)
Return whether a phase is liquid.
Definition H2ON2FluidSystem.hpp:94
Opm::H2ON2FluidSystem::liquidPhaseIdx
static const int liquidPhaseIdx
Index of the liquid phase.
Definition H2ON2FluidSystem.hpp:77
Opm::H2ON2FluidSystem::numPhases
static const int numPhases
Number of fluid phases in the fluid system.
Definition H2ON2FluidSystem.hpp:74
Opm::H2ON2FluidSystem::gasPhaseIdx
static const int gasPhaseIdx
Index of the gas phase.
Definition H2ON2FluidSystem.hpp:79
Opm::H2ON2FluidSystem::heatCapacity
static LhsEval heatCapacity(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Specific isobaric heat capacity of a fluid phase [J/kg].
Definition H2ON2FluidSystem.hpp:457
Opm::H2ON2FluidSystem::componentName
static std::string_view componentName(unsigned compIdx)
Return the human readable name of a component.
Definition H2ON2FluidSystem.hpp:153
Opm::H2ON2FluidSystem::diffusionCoefficient
static LhsEval diffusionCoefficient(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx, unsigned)
Calculate the binary molecular diffusion coefficient for a component in a fluid phase [mol^2 * s / (k...
Definition H2ON2FluidSystem.hpp:379
Opm::H2ON2FluidSystem::ParameterCache
NullParameterCache< Evaluation > ParameterCache
The type of the fluid system's parameter cache.
Definition H2ON2FluidSystem.hpp:67
Opm::H2ON2FluidSystem::criticalPressure
static Scalar criticalPressure(unsigned compIdx)
Critical pressure of a component [Pa].
Definition H2ON2FluidSystem.hpp:194
Opm::H2ON2FluidSystem::enthalpy
static LhsEval enthalpy(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Given a phase's composition, temperature, pressure and density, calculate its specific enthalpy [J/kg...
Definition H2ON2FluidSystem.hpp:399
Opm::H2ON2FluidSystem::numComponents
static const int numComponents
Number of chemical species in the fluid system.
Definition H2ON2FluidSystem.hpp:137
Opm::H2ON2FluidSystem::molarMass
static Scalar molarMass(unsigned compIdx)
Return the molar mass of a component in [kg/mol].
Definition H2ON2FluidSystem.hpp:165
Opm::H2ON2FluidSystem::isIdealGas
static bool isIdealGas(unsigned phaseIdx)
Returns true if and only if a fluid phase is assumed to be an ideal gas.
Definition H2ON2FluidSystem.hpp:112
Opm::H2ON2FluidSystem::viscosity
static LhsEval viscosity(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx)
Calculate the dynamic viscosity of a fluid phase [Pa*s].
Definition H2ON2FluidSystem.hpp:299
Opm::H2ON2FluidSystem::N2
SimpleN2 N2
The component for pure nitrogen.
Definition H2ON2FluidSystem.hpp:150
Opm::H2ON2FluidSystem::N2Idx
static const int N2Idx
The component index of molecular nitrogen.
Definition H2ON2FluidSystem.hpp:142
Opm::H2ON2FluidSystem::isCompressible
static bool isCompressible(unsigned phaseIdx)
Returns true if and only if a fluid phase is assumed to be compressible.
Definition H2ON2FluidSystem.hpp:101
Opm::H2ON2FluidSystem::fugacityCoefficient
static LhsEval fugacityCoefficient(const FluidState &fluidState, const ParameterCache< ParamCacheEval > &, unsigned phaseIdx, unsigned compIdx)
Calculate the fugacity coefficient [Pa] of an individual component in a fluid phase.
Definition H2ON2FluidSystem.hpp:352
Opm::N2::gasThermalConductivity
static Evaluation gasThermalConductivity(const Evaluation &, const Evaluation &)
Specific heat conductivity of steam .
Definition N2.hpp:304
Opm::N2::gasDensity
static Evaluation gasDensity(const Evaluation &temperature, const Evaluation &pressure)
The density of gas at a given pressure and temperature.
Definition N2.hpp:146
Opm::N2::gasIsIdeal
static bool gasIsIdeal()
Returns true iff the gas phase is assumed to be ideal.
Definition N2.hpp:161
Opm::N2::criticalPressure
static Scalar criticalPressure()
Returns the critical pressure of molecular nitrogen.
Definition N2.hpp:75
Opm::N2::criticalTemperature
static Scalar criticalTemperature()
Returns the critical temperature of molecular nitrogen.
Definition N2.hpp:69
Opm::N2::name
static std::string_view name()
A human readable name for nitrogen.
Definition N2.hpp:57
Opm::N2::gasViscosity
static Evaluation gasViscosity(const Evaluation &temperature, const Evaluation &)
The dynamic viscosity of at a given pressure and temperature.
Definition N2.hpp:268
Opm::N2::acentricFactor
static Scalar acentricFactor()
Acentric factor of .
Definition N2.hpp:86
Opm::N2::molarMass
static Scalar molarMass()
The molar mass in of molecular nitrogen.
Definition N2.hpp:63
Opm::N2::gasHeatCapacity
static Evaluation gasHeatCapacity(const Evaluation &temperature, const Evaluation &)
Specific isobaric heat capacity of pure nitrogen gas.
Definition N2.hpp:237
Opm::N2::gasEnthalpy
static Evaluation gasEnthalpy(const Evaluation &temperature, const Evaluation &)
Specific enthalpy of pure nitrogen gas.
Definition N2.hpp:187
Opm::NullParameterCache
A parameter cache which does nothing.
Definition NullParameterCache.hpp:40
Opm::TabulatedComponent
A generic class which tabulates all thermodynamic properties of a given component.
Definition TabulatedComponent.hpp:139
Opm::TabulatedComponent< Scalar, IapwsH2O >::gasThermalConductivity
static Evaluation gasThermalConductivity(const Evaluation &temperature, const Evaluation &pressure)
Definition TabulatedComponent.hpp:618
Opm::TabulatedComponent< Scalar, IapwsH2O >::name
static std::string_view name()
Definition TabulatedComponent.hpp:328
Opm::TabulatedComponent< Scalar, IapwsH2O >::gasEnthalpy
static Evaluation gasEnthalpy(const Evaluation &temperature, const Evaluation &pressure)
Definition TabulatedComponent.hpp:396
Opm::TabulatedComponent< Scalar, IapwsH2O >::liquidHeatCapacity
static Evaluation liquidHeatCapacity(const Evaluation &temperature, const Evaluation &pressure)
Definition TabulatedComponent.hpp:450
Opm::TabulatedComponent< Scalar, IapwsH2O >::init
static void init(Scalar tempMin, Scalar tempMax, unsigned nTemp, Scalar pressMin, Scalar pressMax, unsigned nPress)
Definition TabulatedComponent.hpp:155
Opm::TabulatedComponent< Scalar, IapwsH2O >::criticalTemperature
static Scalar criticalTemperature()
Definition TabulatedComponent.hpp:340
Opm::TabulatedComponent< Scalar, IapwsH2O >::criticalPressure
static Scalar criticalPressure()
Definition TabulatedComponent.hpp:346
Opm::TabulatedComponent< Scalar, IapwsH2O >::molarMass
static Scalar molarMass()
Definition TabulatedComponent.hpp:334
Opm::TabulatedComponent< Scalar, IapwsH2O >::liquidIsCompressible
static bool liquidIsCompressible()
Definition TabulatedComponent.hpp:528
Opm::TabulatedComponent< Scalar, IapwsH2O >::liquidViscosity
static Evaluation liquidViscosity(const Evaluation &temperature, const Evaluation &pressure)
Definition TabulatedComponent.hpp:600
Opm::TabulatedComponent< Scalar, IapwsH2O >::gasDensity
static Evaluation gasDensity(const Evaluation &temperature, const Evaluation &pressure)
Definition TabulatedComponent.hpp:545
Opm::TabulatedComponent< Scalar, IapwsH2O >::gasHeatCapacity
static Evaluation gasHeatCapacity(const Evaluation &temperature, const Evaluation &pressure)
Definition TabulatedComponent.hpp:432
Opm::TabulatedComponent< Scalar, IapwsH2O >::gasIsIdeal
static bool gasIsIdeal()
Definition TabulatedComponent.hpp:534
Opm::TabulatedComponent< Scalar, IapwsH2O >::acentricFactor
static Scalar acentricFactor()
Definition TabulatedComponent.hpp:352
Opm::TabulatedComponent< Scalar, IapwsH2O >::liquidDensity
static Evaluation liquidDensity(const Evaluation &temperature, const Evaluation &pressure)
Definition TabulatedComponent.hpp:564
Opm::TabulatedComponent< Scalar, IapwsH2O >::vaporPressure
static Evaluation vaporPressure(const Evaluation &temperature)
Definition TabulatedComponent.hpp:380
Opm::TabulatedComponent< Scalar, IapwsH2O >::liquidThermalConductivity
static Evaluation liquidThermalConductivity(const Evaluation &temperature, const Evaluation &pressure)
Definition TabulatedComponent.hpp:636
Opm::TabulatedComponent< Scalar, IapwsH2O >::gasViscosity
static Evaluation gasViscosity(const Evaluation &temperature, const Evaluation &pressure)
Definition TabulatedComponent.hpp:582
Opm::TabulatedComponent< Scalar, IapwsH2O >::liquidEnthalpy
static Evaluation liquidEnthalpy(const Evaluation &temperature, const Evaluation &pressure)
Definition TabulatedComponent.hpp:414
Opm
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30