Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
dumux-repositories
dumux
Commits
993d4801
Commit
993d4801
authored
Jan 02, 2018
by
Bernd Flemisch
Browse files
Merge branch 'doc/henry' into 'releases/2.12'
Doc Henry coefficient and rename fluidsystems See merge request
!488
parents
432136ff
6862817f
Changes
16
Hide whitespace changes
Inline
Side-by-side
dumux/material/binarycoefficients/h2o_heavyoil.hh
View file @
993d4801
...
...
@@ -41,10 +41,8 @@ public:
/*!
* \brief Henry coefficient \f$[N/m^2]\f$ for heavy oil in liquid water.
*
* See:
*
* \todo values copied from TCE, please improve it
*/
template
<
class
Scalar
>
static
Scalar
henryOilInWater
(
Scalar
temperature
)
{
...
...
@@ -57,10 +55,8 @@ public:
/*!
* \brief Henry coefficient \f$[N/m^2]\f$ for water in liquid heavy oil.
*
* See:
*
* \todo arbitrary value, please improve it
*/
template
<
class
Scalar
>
static
Scalar
henryWaterInOil
(
Scalar
temperature
)
{
...
...
@@ -72,17 +68,18 @@ public:
/*!
* \brief Binary diffusion coefficient [m^2/s] for molecular water and heavy oil.
*
* \todo value is just an order of magnitude, please improve it
*/
template
<
class
Scalar
>
static
Scalar
gasDiffCoeff
(
Scalar
temperature
,
Scalar
pressure
)
{
return
1e-6
;
// [m^2/s] This is just an order of magnitude. Please improve it!
return
1e-6
;
// [m^2/s]
TODO:
This is just an order of magnitude. Please improve it!
}
/*!
* \brief Diffusion coefficient [m^2/s] for tce in liquid water.
*
* \todo
* \todo
value is just an order of magnitude, please improve it
*/
template
<
class
Scalar
>
static
Scalar
liquidDiffCoeff
(
Scalar
temperature
,
Scalar
pressure
)
...
...
dumux/material/fluidsystems/1p.hh
View file @
993d4801
...
...
@@ -265,11 +265,13 @@ public:
* \brief Calculate the fugacity coefficient \f$\mathrm{[Pa]}\f$ of an individual
* component in a fluid phase
*
* The fugacity coefficient \f$\mathrm{\phi_\kappa}\f$ is connected to the
* fugacity \f$\mathrm{f
_
\kappa}\f$ and the component's mol
arity
* \f$\mathrm{x
_
\kappa}\f$ by means of the relation
* The fugacity coefficient \f$\mathrm{\phi_\kappa
_\alpha
}\f$ is connected to the
* fugacity \f$\mathrm{f
^
\kappa
_\alpha
}\f$ and the component's mol
e
*
fraction
\f$\mathrm{x
^
\kappa
_\alpha
}\f$ by means of the relation
*
* \f[ f_\kappa = \phi_\kappa * x_{\kappa} \f]
* \f[
f^\kappa_\alpha = \phi^\kappa_\alpha\;x^\kappa_\alpha\;p_\alpha
* \f]
*/
template
<
class
FluidState
>
static
Scalar
fugacityCoefficient
(
const
FluidState
&
fluidState
,
...
...
dumux/material/fluidsystems/2pimmiscible.hh
View file @
993d4801
...
...
@@ -293,17 +293,20 @@ public:
using
Base
::
fugacityCoefficient
;
/*!
* \brief Calculate the fugacity coefficient \f$\mathrm{[
Pa
]}\f$ of an individual
* \brief Calculate the fugacity coefficient \f$\mathrm{[
-
]}\f$ of an individual
* component in a fluid phase
*
* The fugacity coefficient \f$\mathrm{\phi_\kappa_\alpha}\f$ is connected to the
* fugacity \f$\mathrm{f^\kappa_\alpha}\f$ and the component's mole
* fraction \f$\mathrm{x^\kappa_\alpha}\f$ by means of the relation
*
* \f[
f^\kappa_\alpha = \phi^\kappa_\alpha\;x^\kappa_\alpha\;p_\alpha
* \f]
*
* \param fluidState The fluid state of the two-phase model
* \param phaseIdx Index of the fluid phase
* \param compIdx index of the component
*
* The fugacity coefficient \f$\mathrm{\phi_\kappa}\f$ is connected to the
* fugacity \f$\mathrm{f_\kappa}\f$ and the component's molarity
* \f$\mathrm{x_\kappa}\f$ by means of the relation
*
* \f[ f_\kappa = \phi_\kappa * x_{\kappa} \f]
*/
template
<
class
FluidState
>
static
Scalar
fugacityCoefficient
(
const
FluidState
&
fluidState
,
...
...
dumux/material/fluidsystems/2pliquidvapor.hh
View file @
993d4801
...
...
@@ -377,7 +377,7 @@ public:
}
/*!
* \brief Calculate the fugacity coefficient [
Pa
] of an individual
* \brief Calculate the fugacity coefficient [
-
] of an individual
* component in a fluid phase
*
* The fugacity coefficient \f$\phi^\kappa_\alpha\f$ of
...
...
dumux/material/fluidsystems/CMakeLists.txt
View file @
993d4801
...
...
@@ -10,6 +10,7 @@ install(FILES
h2oair.hh
h2oairmesitylene.hh
h2oairxylene.hh
h2oheavyoil.hh
h2oheavyoilfluidsystem.hh
h2on2.hh
h2on2kinetic.hh
...
...
dumux/material/fluidsystems/base.hh
View file @
993d4801
...
...
@@ -61,18 +61,21 @@ public:
}
/*!
* \brief Calculate the fugacity coefficient \f$\mathrm{[
Pa
]}\f$ of an individual
* \brief Calculate the fugacity coefficient \f$\mathrm{[
-
]}\f$ of an individual
* component in a fluid phase
*
* The fugacity coefficient \f$\mathrm{\phi_\kappa_\alpha}\f$ is connected to the
* fugacity \f$\mathrm{f^\kappa_\alpha}\f$ and the component's mole
* fraction \f$\mathrm{x^\kappa_\alpha}\f$ by means of the relation
*
* \f[
f^\kappa_\alpha = \phi^\kappa_\alpha\;x^\kappa_\alpha\;p_\alpha
* \f]
*
* \param fluidState The fluid state
* \param paramCache mutable parameters
* \param phaseIdx Index of the fluid phase
* \param compIdx Index of the component
*
* The fugacity coefficient \f$\mathrm{\phi_\kappa}\f$ is connected to the
* fugacity \f$\mathrm{f_\kappa}\f$ and the component's molarity
* \f$\mathrm{x_\kappa}\f$ by means of the relation
*
* \f[ f_\kappa = \phi_\kappa * x_{\kappa} \f]
*/
template
<
class
FluidState
>
static
Scalar
fugacityCoefficient
(
const
FluidState
&
fluidState
,
...
...
dumux/material/fluidsystems/brineair.hh
View file @
993d4801
...
...
@@ -436,7 +436,7 @@ public:
* where \f$\mathrm{p_\alpha}\f$ is the pressure of the fluid phase.
*
* For liquids with very low miscibility this boils down to the
*
inverse
Henry constant for the solutes and the saturated vapor pressure
* Henry constant for the solutes and the saturated vapor pressure
* both divided by phase pressure.
*/
template
<
class
FluidState
>
...
...
dumux/material/fluidsystems/h2oair.hh
View file @
993d4801
...
...
@@ -547,7 +547,7 @@ public:
* where \f$p_\alpha\f$ is the pressure of the fluid phase.
*
* For liquids with very low miscibility this boils down to the
*
inverse
Henry constant for the solutes and the saturated vapor pressure
* Henry constant for the solutes and the saturated vapor pressure
* both divided by phase pressure.
*/
template
<
class
FluidState
>
...
...
dumux/material/fluidsystems/h2oairmesitylene.hh
View file @
993d4801
...
...
@@ -428,9 +428,9 @@ public:
*
* In this case, things are actually pretty simple. We have an ideal
* solution. Thus, the fugacity coefficient is 1 in the gas phase
* (fugacity equals the partial pressure of the component in the gas phase
* respectively in the liquid phases it is the
inverse of the
*
Henry coefficients scaled
by pressure
* (fugacity equals the partial pressure of the component in the gas phase
)
* respectively in the liquid phases it is the
Henry coefficients divided
* by pressure
.
* \param fluidState The fluid state
* \param phaseIdx The index of the phase
* \param compIdx The index of the component
...
...
dumux/material/fluidsystems/h2oairxylene.hh
View file @
993d4801
...
...
@@ -430,9 +430,9 @@ public:
*
* In this case, things are actually pretty simple. We have an ideal
* solution. Thus, the fugacity coefficient is 1 in the gas phase
* (fugacity equals the partial pressure of the component in the gas phase
* respectively in the liquid phases it is the
inverse of the
*
Henry coefficients scal
ed by pressure
* (fugacity equals the partial pressure of the component in the gas phase
)
* respectively in the liquid phases it is the
Henry coefficients
*
divid
ed by pressure
.
*/
template
<
class
FluidState
>
static
Scalar
fugacityCoefficient
(
const
FluidState
&
fluidState
,
...
...
dumux/material/fluidsystems/h2oheavyoil.hh
0 → 100644
View file @
993d4801
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
* See the file COPYING for full copying permissions. *
* *
* This program 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. *
* *
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>. *
*****************************************************************************/
/*!
* \file
*
* \brief A fluid system with water, gas and NAPL as phases and
* \f$H_2O\f$ and \f$NAPL (contaminant)\f$ as components.
* It uses heavyoil Properties, but allows for a scaling of density
* thus enabling an artifical DNAPL if desired
*/
#ifndef DUMUX_H2O_HEAVYOIL_FLUID_SYSTEM_HH
#define DUMUX_H2O_HEAVYOIL_FLUID_SYSTEM_HH
#include <dumux/material/idealgas.hh>
#include <dumux/material/components/h2o.hh>
#include <dumux/material/components/tabulatedcomponent.hh>
#include <dumux/material/components/simpleh2o.hh>
#include <dumux/material/components/heavyoil.hh>
#include <dumux/material/binarycoefficients/h2o_heavyoil.hh>
#include <dumux/material/fluidsystems/base.hh>
namespace
Dumux
{
namespace
FluidSystems
{
/*!
* \ingroup Fluidsystems
* \brief A compositional fluid with water and heavy oil
* components in both, the liquid and the gas phase.
*/
template
<
class
TypeTag
,
class
Scalar
,
class
H2OType
=
Dumux
::
TabulatedComponent
<
Scalar
,
Dumux
::
H2O
<
Scalar
>
>
>
class
H2OHeavyOil
:
public
BaseFluidSystem
<
Scalar
,
H2OHeavyOil
<
TypeTag
,
Scalar
,
H2OType
>
>
{
typedef
H2OHeavyOil
<
TypeTag
,
Scalar
,
H2OType
>
ThisType
;
typedef
BaseFluidSystem
<
Scalar
,
ThisType
>
Base
;
public:
typedef
Dumux
::
HeavyOil
<
Scalar
>
HeavyOil
;
typedef
H2OType
H2O
;
static
const
int
numPhases
=
3
;
static
const
int
numComponents
=
2
;
static
const
int
wPhaseIdx
=
0
;
// index of the water phase
static
const
int
nPhaseIdx
=
1
;
// index of the NAPL phase
static
const
int
gPhaseIdx
=
2
;
// index of the gas phase
static
const
int
H2OIdx
=
0
;
static
const
int
NAPLIdx
=
1
;
// export component indices to indicate the main component
// of the corresponding phase at atmospheric pressure 1 bar
// and room temperature 20°C:
static
const
int
wCompIdx
=
H2OIdx
;
static
const
int
nCompIdx
=
NAPLIdx
;
/*!
* \brief Initialize the fluid system's static parameters generically
*
* If a tabulated H2O component is used, we do our best to create
* tables that always work.
*/
static
void
init
()
{
init
(
/*tempMin=*/
273.15
,
/*tempMax=*/
623.15
,
/*numTemp=*/
100
,
/*pMin=*/
0.0
,
/*pMax=*/
20e6
,
/*numP=*/
200
);
}
/*!
* \brief Initialize the fluid system's static parameters using
* problem specific temperature and pressure ranges
*
* \param tempMin The minimum temperature used for tabulation of water [K]
* \param tempMax The maximum temperature used for tabulation of water [K]
* \param nTemp The number of ticks on the temperature axis of the table of water
* \param pressMin The minimum pressure used for tabulation of water [Pa]
* \param pressMax The maximum pressure used for tabulation of water [Pa]
* \param nPress The number of ticks on the pressure axis of the table of water
*/
static
void
init
(
Scalar
tempMin
,
Scalar
tempMax
,
unsigned
nTemp
,
Scalar
pressMin
,
Scalar
pressMax
,
unsigned
nPress
)
{
if
(
H2O
::
isTabulated
)
{
std
::
cout
<<
"Initializing tables for the H2O fluid properties ("
<<
nTemp
*
nPress
<<
" entries).
\n
"
;
H2O
::
init
(
tempMin
,
tempMax
,
nTemp
,
pressMin
,
pressMax
,
nPress
);
}
}
/*!
* \brief Return whether a phase is liquid
*
* \param phaseIdx The index of the fluid phase to consider
*/
static
bool
isLiquid
(
int
phaseIdx
)
{
assert
(
0
<=
phaseIdx
&&
phaseIdx
<
numPhases
);
return
phaseIdx
!=
gPhaseIdx
;
}
static
bool
isIdealGas
(
int
phaseIdx
)
{
return
phaseIdx
==
gPhaseIdx
&&
H2O
::
gasIsIdeal
()
&&
HeavyOil
::
gasIsIdeal
();
}
/*!
* \brief Returns true if and only if a fluid phase is assumed to
* be an ideal mixture.
*
* We define an ideal mixture as a fluid phase where the fugacity
* coefficients of all components times the pressure of the phase
* are indepent on the fluid composition. This assumtion is true
* if Henry's law and Raoult's law apply. If you are unsure what
* this function should return, it is safe to return false. The
* only damage done will be (slightly) increased computation times
* in some cases.
*
* \param phaseIdx The index of the fluid phase to consider
*/
static
bool
isIdealMixture
(
int
phaseIdx
)
{
assert
(
0
<=
phaseIdx
&&
phaseIdx
<
numPhases
);
// we assume Henry's and Raoult's laws for the water phase and
// and no interaction between gas molecules of different
// components, so all phases are ideal mixtures!
return
true
;
}
/*!
* \brief Returns true if and only if a fluid phase is assumed to
* be compressible.
*
* Compressible means that the partial derivative of the density
* to the fluid pressure is always larger than zero.
*
* \param phaseIdx The index of the fluid phase to consider
*/
static
bool
isCompressible
(
int
phaseIdx
)
{
assert
(
0
<=
phaseIdx
&&
phaseIdx
<
numPhases
);
// gases are always compressible
if
(
phaseIdx
==
gPhaseIdx
)
return
true
;
else
if
(
phaseIdx
==
wPhaseIdx
)
// the water component decides for the water phase...
return
H2O
::
liquidIsCompressible
();
// the NAPL component decides for the napl phase...
return
HeavyOil
::
liquidIsCompressible
();
}
/*!
* \brief Return the human readable name of a phase (used in indices)
*/
static
std
::
string
phaseName
(
int
phaseIdx
)
{
switch
(
phaseIdx
)
{
case
wPhaseIdx
:
return
"w"
;
case
nPhaseIdx
:
return
"n"
;
case
gPhaseIdx
:
return
"g"
;;
};
DUNE_THROW
(
Dune
::
InvalidStateException
,
"Invalid phase index "
<<
phaseIdx
);
}
/*!
* \brief Return the human readable name of a component (used in indices)
*/
static
std
::
string
componentName
(
int
compIdx
)
{
switch
(
compIdx
)
{
case
H2OIdx
:
return
H2O
::
name
();
case
NAPLIdx
:
return
HeavyOil
::
name
();
};
DUNE_THROW
(
Dune
::
InvalidStateException
,
"Invalid component index "
<<
compIdx
);
}
/*!
* \brief Return the molar mass of a component in [kg/mol].
*/
static
Scalar
molarMass
(
int
compIdx
)
{
switch
(
compIdx
)
{
case
H2OIdx
:
return
H2O
::
molarMass
();
case
NAPLIdx
:
return
HeavyOil
::
molarMass
();
};
DUNE_THROW
(
Dune
::
InvalidStateException
,
"Invalid component index "
<<
compIdx
);
}
/*!
* \brief Given all mole fractions in a phase, return the phase
* density [kg/m^3].
*/
using
Base
::
density
;
template
<
class
FluidState
>
static
Scalar
density
(
const
FluidState
&
fluidState
,
int
phaseIdx
)
{
if
(
phaseIdx
==
wPhaseIdx
)
{
// See: doctoral thesis of Steffen Ochs 2007
// Steam injection into saturated porous media : process analysis including experimental and numerical investigations
// http://elib.uni-stuttgart.de/bitstream/11682/271/1/Diss_Ochs_OPUS.pdf
Scalar
rholH2O
=
H2O
::
liquidDensity
(
fluidState
.
temperature
(
phaseIdx
),
fluidState
.
pressure
(
phaseIdx
));
Scalar
clH2O
=
rholH2O
/
H2O
::
molarMass
();
// this assumes each dissolved molecule displaces exactly one
// water molecule in the liquid
return
clH2O
*
(
H2O
::
molarMass
()
*
fluidState
.
moleFraction
(
wPhaseIdx
,
H2OIdx
)
+
HeavyOil
::
molarMass
()
*
fluidState
.
moleFraction
(
wPhaseIdx
,
NAPLIdx
));
}
else
if
(
phaseIdx
==
nPhaseIdx
)
{
// assume pure NAPL for the NAPL phase
Scalar
pressure
=
HeavyOil
::
liquidIsCompressible
()
?
fluidState
.
pressure
(
phaseIdx
)
:
1e100
;
return
HeavyOil
::
liquidDensity
(
fluidState
.
temperature
(
phaseIdx
),
pressure
);
}
assert
(
phaseIdx
==
gPhaseIdx
);
Scalar
pH2O
=
fluidState
.
moleFraction
(
gPhaseIdx
,
H2OIdx
)
*
fluidState
.
pressure
(
gPhaseIdx
);
Scalar
pNAPL
=
fluidState
.
moleFraction
(
gPhaseIdx
,
NAPLIdx
)
*
fluidState
.
pressure
(
gPhaseIdx
);
return
H2O
::
gasDensity
(
fluidState
.
temperature
(
phaseIdx
),
pH2O
)
+
HeavyOil
::
gasDensity
(
fluidState
.
temperature
(
phaseIdx
),
pNAPL
);
}
/*!
* \brief Return the viscosity of a phase.
*/
using
Base
::
viscosity
;
template
<
class
FluidState
>
static
Scalar
viscosity
(
const
FluidState
&
fluidState
,
int
phaseIdx
)
{
if
(
phaseIdx
==
wPhaseIdx
)
{
// assume pure water viscosity
return
H2O
::
liquidViscosity
(
fluidState
.
temperature
(
phaseIdx
),
fluidState
.
pressure
(
phaseIdx
));
}
else
if
(
phaseIdx
==
nPhaseIdx
)
{
// assume pure NAPL viscosity
return
HeavyOil
::
liquidViscosity
(
fluidState
.
temperature
(
phaseIdx
),
fluidState
.
pressure
(
phaseIdx
));
}
assert
(
phaseIdx
==
gPhaseIdx
);
/* 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
*
* in this case, we use a simplified version in order to avoid
* computationally costly evaluation of sqrt and pow functions and
* divisions
* -- compare e.g. with Promo Class p. 32/33
*/
const
Scalar
mu
[
numComponents
]
=
{
H2O
::
gasViscosity
(
fluidState
.
temperature
(
phaseIdx
),
H2O
::
vaporPressure
(
fluidState
.
temperature
(
phaseIdx
))),
HeavyOil
::
gasViscosity
(
fluidState
.
temperature
(
phaseIdx
),
HeavyOil
::
vaporPressure
(
fluidState
.
temperature
(
phaseIdx
)))
};
return
mu
[
H2OIdx
]
*
fluidState
.
moleFraction
(
gPhaseIdx
,
H2OIdx
)
+
mu
[
NAPLIdx
]
*
fluidState
.
moleFraction
(
gPhaseIdx
,
NAPLIdx
);
}
using
Base
::
binaryDiffusionCoefficient
;
template
<
class
FluidState
>
static
Scalar
diffusionCoefficient
(
const
FluidState
&
fluidState
,
int
phaseIdx
)
{
const
Scalar
T
=
fluidState
.
temperature
(
phaseIdx
);
const
Scalar
p
=
fluidState
.
pressure
(
phaseIdx
);
// liquid phase
if
(
phaseIdx
==
wPhaseIdx
)
return
BinaryCoeff
::
H2O_HeavyOil
::
liquidDiffCoeff
(
T
,
p
);
// gas phase
else
if
(
phaseIdx
==
gPhaseIdx
)
return
BinaryCoeff
::
H2O_HeavyOil
::
gasDiffCoeff
(
T
,
p
);
else
DUNE_THROW
(
Dune
::
InvalidStateException
,
"non-existent diffusion coefficient for phase index "
<<
phaseIdx
);
}
/*!
* \brief Henry coefficients
*/
template
<
class
FluidState
>
static
Scalar
henryCoefficient
(
const
FluidState
&
fluidState
,
int
phaseIdx
,
int
compIdx
)
{
assert
(
0
<=
phaseIdx
&&
phaseIdx
<
numPhases
);
assert
(
0
<=
compIdx
&&
compIdx
<
numComponents
);
const
Scalar
T
=
fluidState
.
temperature
(
phaseIdx
);
if
(
compIdx
==
NAPLIdx
&&
phaseIdx
==
wPhaseIdx
)
return
Dumux
::
BinaryCoeff
::
H2O_HeavyOil
::
henryOilInWater
(
T
);
else
if
(
phaseIdx
==
nPhaseIdx
&&
compIdx
==
H2OIdx
)
return
Dumux
::
BinaryCoeff
::
H2O_HeavyOil
::
henryWaterInOil
(
T
);
else
DUNE_THROW
(
Dune
::
InvalidStateException
,
"non-existent henry coefficient for phase index "
<<
phaseIdx
<<
" and component index "
<<
compIdx
);
}
/*!
* \brief Partial pressures in the gas phase, taken from saturation vapor pressures
*/
template
<
class
FluidState
>
static
Scalar
partialPressureGas
(
const
FluidState
&
fluidState
,
int
phaseIdx
,
int
compIdx
)
{
assert
(
0
<=
compIdx
&&
compIdx
<
numComponents
);
const
Scalar
T
=
fluidState
.
temperature
(
phaseIdx
);
if
(
compIdx
==
NAPLIdx
)
return
HeavyOil
::
vaporPressure
(
T
);
else
if
(
compIdx
==
H2OIdx
)
return
H2O
::
vaporPressure
(
T
);
else
DUNE_THROW
(
Dune
::
InvalidStateException
,
"non-existent component index "
<<
compIdx
);
}
/*!
* \brief Inverse vapor pressures, taken from inverse saturation vapor pressures
*/
template
<
class
FluidState
>
static
Scalar
inverseVaporPressureCurve
(
const
FluidState
&
fluidState
,
int
phaseIdx
,
int
compIdx
)
{
assert
(
0
<=
compIdx
&&
compIdx
<
numComponents
);
const
Scalar
pressure
=
fluidState
.
pressure
(
phaseIdx
);
if
(
compIdx
==
NAPLIdx
)
return
HeavyOil
::
vaporTemperature
(
pressure
);
else
if
(
compIdx
==
H2OIdx
)
return
H2O
::
vaporTemperature
(
pressure
);
else
DUNE_THROW
(
Dune
::
InvalidStateException
,
"non-existent component index "
<<
compIdx
);
}
/*!
* \brief Given all mole fractions in a phase, return the specific
* phase enthalpy [J/kg].
*
* \todo This system neglects the contribution of gas-molecules in the liquid phase.
* This contribution is probably not big. Somebody would have to find out the enthalpy of solution for this system. ...
*/
using
Base
::
enthalpy
;
template
<
class
FluidState
>
static
Scalar
enthalpy
(
const
FluidState
&
fluidState
,
int
phaseIdx
)
{
if
(
phaseIdx
==
wPhaseIdx
)
{
return
H2O
::
liquidEnthalpy
(
fluidState
.
temperature
(
phaseIdx
),
fluidState
.
pressure
(
phaseIdx
));
}
else
if
(
phaseIdx
==
nPhaseIdx
)
{
return
HeavyOil
::
liquidEnthalpy
(
fluidState
.
temperature
(
phaseIdx
),
fluidState
.
pressure
(
phaseIdx
));
}
else
if
(
phaseIdx
==
gPhaseIdx
)
{
// gas phase enthalpy depends strongly on composition
Scalar
hgc
=
HeavyOil
::
gasEnthalpy
(
fluidState
.
temperature
(
phaseIdx
),
fluidState
.
pressure
(
phaseIdx
));
Scalar
hgw
=
H2O
::
gasEnthalpy
(
fluidState
.
temperature
(
phaseIdx
),
fluidState
.
pressure
(
phaseIdx
));
Scalar
result
=
0
;
result
+=
hgw
*
fluidState
.
massFraction
(
gPhaseIdx
,
H2OIdx
);
result
+=
hgc
*
fluidState
.
massFraction
(
gPhaseIdx
,
NAPLIdx
);
return
result
;
}
DUNE_THROW
(
Dune
::
InvalidStateException
,
"Invalid phase index "
<<
phaseIdx
);
}
using
Base
::
heatCapacity
;
template
<
class
FluidState
>
static
Scalar
heatCapacity
(
const
FluidState
&
fluidState
,
int
phaseIdx
)