void assign(const FluidState& fs)
{
typedef typename FluidState::Scalar FsScalar;
typedef Opm::MathToolbox<FsScalar> FsToolbox;
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
saturation_[phaseIdx] = FsToolbox::template decay<Scalar>(fs.saturation(phaseIdx));
}
}
static Evaluation krg(const Params ¶ms,
const FluidState &fluidState)
{
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
const Evaluation& Sw = 1 - FsToolbox::template decay<Evaluation>(fluidState.saturation(gasPhaseIdx));
return GasOilMaterialLaw::twoPhaseSatKrn(params.gasOilParams(), Sw);
}
static Evaluation pcnw(const Params ¶ms,
const FluidState &fs)
{
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
const auto& Sw = FsToolbox::template toLhs<Evaluation>(fs.saturation(waterPhaseIdx));
return OilWaterMaterialLaw::twoPhaseSatPcnw(params.oilWaterParams(), Sw);
}
static Evaluation krw(const Params ¶ms,
const FluidState &fluidState)
{
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
const Evaluation& Sw = FsToolbox::template decay<Evaluation>(fluidState.saturation(waterPhaseIdx));
return OilWaterMaterialLaw::twoPhaseSatKrw(params.oilWaterParams(), Sw);
}
static Evaluation krn(const Params ¶ms, const FluidState &fs)
{
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
const Evaluation& Sw =
1.0 - FsToolbox::template toLhs<Evaluation>(fs.saturation(Traits::nonWettingPhaseIdx));
return twoPhaseSatKrn(params, Sw);
}
static Evaluation pcgn(const Params ¶ms,
const FluidState &fs)
{
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
const auto& Sw = 1.0 - FsToolbox::template decay<Evaluation>(fs.saturation(gasPhaseIdx));
return GasOilMaterialLaw::twoPhaseSatPcnw(params.gasOilParams(), Sw);
}
static Evaluation pcgn(const Params ¶ms, const FluidState &fluidState)
{
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
typedef MathToolbox<Evaluation> Toolbox;
Scalar PC_VG_REG = 0.01;
// sum of liquid saturations
const auto& St =
FsToolbox::template toLhs<Evaluation>(fluidState.saturation(wettingPhaseIdx))
+ FsToolbox::template toLhs<Evaluation>(fluidState.saturation(nonWettingPhaseIdx));
Evaluation Se = (St - params.Swrx())/(1. - params.Swrx());
// regularization
if (Se < 0.0)
Se=0.0;
if (Se > 1.0)
Se=1.0;
if (Se>PC_VG_REG && Se<1-PC_VG_REG)
{
const Evaluation& x = Toolbox::pow(Se,-1/params.vgM()) - 1;
return Toolbox::pow(x, 1.0 - params.vgM())/params.vgAlpha();
}
// value and derivative at regularization point
Scalar Se_regu;
if (Se<=PC_VG_REG)
Se_regu = PC_VG_REG;
else
Se_regu = 1-PC_VG_REG;
const Evaluation& x = std::pow(Se_regu,-1/params.vgM())-1;
const Evaluation& pc = Toolbox::pow(x, 1.0/params.vgN())/params.vgAlpha();
const Evaluation& pc_prime =
Toolbox::pow(x, 1/params.vgN()-1)
* std::pow(Se_regu,-1/params.vgM()-1)
/ (-params.vgM())
/ params.vgAlpha()
/ (1 - params.Sgr() - params.Swrx())
/ params.vgN();
// evaluate tangential
return ((Se-Se_regu)*pc_prime + pc)/params.betaGN();
}
static Scalar pcnw(const Params ¶ms, const FluidState &fs)
{
Scalar S = fs.saturation(Traits::wPhaseIdx);
Valgrind::CheckDefined(S);
Scalar wPhasePressure =
S*params.pcMaxSat(Traits::wPhaseIdx) +
(1.0 - S)*params.pcMinSat(Traits::wPhaseIdx);
S = fs.saturation(Traits::nPhaseIdx);
Valgrind::CheckDefined(S);
Scalar nPhasePressure =
S*params.pcMaxSat(Traits::nPhaseIdx) +
(1.0 - S)*params.pcMinSat(Traits::nPhaseIdx);
return nPhasePressure - wPhasePressure;
}
static Evaluation pcnw(const Params& params, const FluidState& fs)
{
const Evaluation& Sw =
Opm::decay<Evaluation>(fs.saturation(Traits::wettingPhaseIdx));
assert(0.0 <= Sw && Sw <= 1.0);
return twoPhaseSatPcnw(params, Sw);
}
static Evaluation pcnw(const Params ¶ms, const FluidState &fluidState)
{
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
const Evaluation& Sw =
FsToolbox::template toLhs<Evaluation>(fluidState.saturation(Traits::wettingPhaseIdx));
return twoPhaseSatPcnw(params, Sw);
}
static typename std::enable_if< (Traits::numPhases > 2), ScalarT>::type
pcgn(const Params ¶ms, const FluidState &fs)
{
Scalar S = fs.saturation(Traits::nPhaseIdx);
Valgrind::CheckDefined(S);
Scalar nPhasePressure =
S*params.pcMaxSat(Traits::nPhaseIdx) +
(1.0 - S)*params.pcMinSat(Traits::nPhaseIdx);
S = fs.saturation(Traits::gPhaseIdx);
Valgrind::CheckDefined(S);
Scalar gPhasePressure =
S*params.pcMaxSat(Traits::gPhaseIdx) +
(1.0 - S)*params.pcMinSat(Traits::gPhaseIdx);
return gPhasePressure - nPhasePressure;
}
static Evaluation pcnw(const Params ¶ms,
const FluidState &fs)
{
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
const auto& Sw = FsToolbox::template decay<Evaluation>(fs.saturation(waterPhaseIdx));
Valgrind::CheckDefined(Sw);
const auto& result = OilWaterMaterialLaw::twoPhaseSatPcnw(params.oilWaterParams(), Sw);
Valgrind::CheckDefined(result);
return result;
}
static void relativePermeabilities(ContainerT &values,
const Params ¶ms,
const FluidState &state)
{
for (int phaseIdx = 0; phaseIdx < Traits::numPhases; ++phaseIdx) {
Scalar S = state.saturation(phaseIdx);
Valgrind::CheckDefined(S);
values[phaseIdx] = std::max(std::min(S,1.0),0.0);
}
}
static Evaluation krn(const Params ¶ms,
const FluidState &fluidState)
{
typedef MathToolbox<Evaluation> Toolbox;
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
// the Eclipse docu is inconsistent here: In some places the connate water
// saturation is represented by "Swl", in others "Swco" is used.
Scalar Swco = params.Swl();
Scalar Sowcr = params.Sowcr();
Scalar Sogcr = params.Sogcr();
Scalar Som = std::min(Sowcr, Sogcr); // minimum residual oil saturation
Scalar eta = params.eta(); // exponent of the beta term
const Evaluation& Sw = FsToolbox::template toLhs<Evaluation>(fluidState.saturation(waterPhaseIdx));
const Evaluation& So = FsToolbox::template toLhs<Evaluation>(fluidState.saturation(oilPhaseIdx));
const Evaluation& Sg = FsToolbox::template toLhs<Evaluation>(fluidState.saturation(gasPhaseIdx));
Evaluation SSw;
if (Sw > Swco)
SSw = (Sw - Swco)/(1 - Swco - Som);
else
SSw = 0.0;
Evaluation SSo;
if (So > Som)
SSo = (So - Som)/(1 - Swco - Som);
else
SSo = 0.0;
Evaluation SSg = Sg/(1 - Swco - Som);
Scalar krocw = OilWaterMaterialLaw::twoPhaseSatKrn(params.oilWaterParams(), Swco);
Evaluation krow = OilWaterMaterialLaw::twoPhaseSatKrn(params.oilWaterParams(), Sw);
Evaluation krog = GasOilMaterialLaw::twoPhaseSatKrw(params.gasOilParams(), 1 - Sg);
Evaluation beta = Toolbox::pow(SSo/((1 - SSw)*(1 - SSg)), eta);
return beta*krow*krog/krocw;
}
static void capillaryPressures(ContainerT &values,
const Params ¶ms,
const FluidState &fluidState)
{
Scalar p_cgw = ThreePLaw::pCGW(params, fluidState.saturation(wPhaseIdx));
Scalar p_cnw = ThreePLaw::pCNW(params, fluidState.saturation(wPhaseIdx));
Scalar p_cgn = ThreePLaw::pCGN(params,
fluidState.saturation(wPhaseIdx)
+ fluidState.saturation(nPhaseIdx));
Scalar p_cAlpha = ThreePLaw::pCAlpha(params,
fluidState.saturation(nPhaseIdx));
Scalar p_cnw1 = 0.0;
Valgrind::CheckDefined(p_cgw);
Valgrind::CheckDefined(p_cnw);
Valgrind::CheckDefined(p_cgn);
Valgrind::CheckDefined(p_cAlpha);
values[gPhaseIdx] = 0;
values[nPhaseIdx] = - (p_cAlpha*p_cgn + (1 - p_cAlpha)*(p_cgw - p_cnw1));
values[wPhaseIdx] = values[nPhaseIdx] - (p_cAlpha*p_cnw + (1 - p_cAlpha)*p_cnw1);
}
static void capillaryPressures(ContainerT &values,
const Params ¶ms,
const FluidState &fluidState)
{
typedef typename std::remove_reference<decltype(values[0])>::type Evaluation;
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
switch (params.approach()) {
case EclTwoPhaseGasOil: {
const Evaluation& So =
FsToolbox::template decay<Evaluation>(fluidState.saturation(oilPhaseIdx));
values[oilPhaseIdx] = 0.0;
values[gasPhaseIdx] = GasOilMaterialLaw::twoPhaseSatPcnw(params.gasOilParams(), So);
break;
}
case EclTwoPhaseOilWater: {
const Evaluation& Sw =
FsToolbox::template decay<Evaluation>(fluidState.saturation(waterPhaseIdx));
values[waterPhaseIdx] = 0.0;
values[oilPhaseIdx] = OilWaterMaterialLaw::twoPhaseSatPcnw(params.oilWaterParams(), Sw);
break;
}
case EclTwoPhaseGasWater: {
const Evaluation& Sw =
FsToolbox::template decay<Evaluation>(fluidState.saturation(waterPhaseIdx));
values[waterPhaseIdx] = 0.0;
values[gasPhaseIdx] =
OilWaterMaterialLaw::twoPhaseSatPcnw(params.oilWaterParams(), Sw)
+ GasOilMaterialLaw::twoPhaseSatPcnw(params.gasOilParams(), 0.0);
break;
}
}
}
static void capillaryPressures(ContainerT &values,
const Params ¶ms,
const FluidState &state)
{
for (int phaseIdx = 0; phaseIdx < Traits::numPhases; ++phaseIdx) {
Scalar S = state.saturation(phaseIdx);
Valgrind::CheckDefined(S);
values[phaseIdx] =
S*params.pcMaxSat(phaseIdx) +
(1.0 - S)*params.pcMinSat(phaseIdx);
}
}
static void relativePermeabilities(Container &values, const Params ¶ms, const FluidState &fs)
{
typedef Opm::SaturationOverlayFluidState<FluidState> OverlayFluidState;
OverlayFluidState overlayFs(fs);
for (int phaseIdx = 0; phaseIdx < numPhases; ++ phaseIdx) {
overlayFs.setSaturation(phaseIdx,
effectiveSaturation(params,
fs.saturation(phaseIdx),
phaseIdx));
}
EffLaw::template relativePermeabilities<Container, OverlayFluidState>(values, params, overlayFs);
}
static void capillaryPressures(Container& values, const Params& params, const FluidState& fs)
{
typedef Opm::SaturationOverlayFluidState<FluidState> OverlayFluidState;
OverlayFluidState overlayFs(fs);
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++ phaseIdx) {
overlayFs.setSaturation(phaseIdx,
effectiveSaturation(params,
fs.saturation(phaseIdx),
phaseIdx));
}
EffLaw::template capillaryPressures<Container, OverlayFluidState>(values, params, overlayFs);
}
void checkSame(const FluidState &fsRef, const FluidState &fsFlash)
{
enum { numPhases = FluidState::numPhases };
enum { numComponents = FluidState::numComponents };
for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
Scalar error;
// check the pressures
error = 1 - fsRef.pressure(phaseIdx)/fsFlash.pressure(phaseIdx);
if (std::abs(error) > 1e-6) {
std::cout << "pressure error phase " << phaseIdx << ": "
<< fsFlash.pressure(phaseIdx) << " flash vs "
<< fsRef.pressure(phaseIdx) << " reference"
<< " error=" << error << "\n";
}
// check the saturations
error = fsRef.saturation(phaseIdx) - fsFlash.saturation(phaseIdx);
if (std::abs(error) > 1e-6)
std::cout << "saturation error phase " << phaseIdx << ": "
<< fsFlash.saturation(phaseIdx) << " flash vs "
<< fsRef.saturation(phaseIdx) << " reference"
<< " error=" << error << "\n";
// check the compositions
for (int compIdx = 0; compIdx < numComponents; ++ compIdx) {
error = fsRef.moleFraction(phaseIdx, compIdx) - fsFlash.moleFraction(phaseIdx, compIdx);
if (std::abs(error) > 1e-6)
std::cout << "composition error phase " << phaseIdx << ", component " << compIdx << ": "
<< fsFlash.moleFraction(phaseIdx, compIdx) << " flash vs "
<< fsRef.moleFraction(phaseIdx, compIdx) << " reference"
<< " error=" << error << "\n";
}
}
}
static void dRelativePermeabilities_dSaturation(ContainerT &values,
const Params ¶ms,
const FluidState &state,
int satPhaseIdx)
{
for (int krPhaseIdx = 0; krPhaseIdx < numPhases; ++krPhaseIdx)
values[krPhaseIdx] = 0.0;
// -> linear relation between 0 and 1, else constant
if (state.saturation(satPhaseIdx) >= 0 &&
state.saturation(satPhaseIdx) <= 1)
{
values[satPhaseIdx] = 1.0;
}
}
static Evaluation krw(const Params ¶ms, const FluidState &fluidState)
{
typedef MathToolbox<typename FluidState::Scalar> FsToolbox;
typedef MathToolbox<Evaluation> Toolbox;
const Evaluation& Sw =
FsToolbox::template toLhs<Evaluation>(fluidState.saturation(wettingPhaseIdx));
// transformation to effective saturation
const Evaluation& Se = (Sw - params.Swr()) / (1-params.Swr());
// regularization
if(Se > 1.0) return 1.;
if(Se < 0.0) return 0.;
const Evaluation& r = 1. - Toolbox::pow(1 - Toolbox::pow(Se, 1/params.vgM()), params.vgM());
return Toolbox::sqrt(Se)*r*r;
}
static Evaluation krn(const Params ¶ms, const FluidState &fs)
{
typedef Opm::SaturationOverlayFluidState<FluidState> OverlayFluidState;
static_assert(FluidState::numPhases == numPhases,
"The fluid state and the material law must exhibit the same "
"number of phases!");
OverlayFluidState overlayFs(fs);
for (int phaseIdx = 0; phaseIdx < numPhases; ++ phaseIdx) {
overlayFs.setSaturation(phaseIdx,
effectiveSaturation(params,
fs.saturation(phaseIdx),
phaseIdx));
}
return EffLaw::template krn<OverlayFluidState, Evaluation>(params, overlayFs);
}
static typename std::enable_if< (Traits::numPhases > 2), Evaluation>::type
krg(const Params& params, const FluidState& fs)
{
typedef Opm::SaturationOverlayFluidState<FluidState> OverlayFluidState;
static_assert(FluidState::numPhases == numPhases,
"The fluid state and the material law must exhibit the same "
"number of phases!");
OverlayFluidState overlayFs(fs);
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++ phaseIdx) {
overlayFs.setSaturation(phaseIdx,
effectiveSaturation(params,
fs.saturation(phaseIdx),
phaseIdx));
}
return EffLaw::template krg<OverlayFluidState, Evaluation>(params, overlayFs);
}
void assign(const FluidState& fs)
{
if (enableTemperature || enableEnergy)
setTemperature(fs.temperature(/*phaseIdx=*/0));
unsigned pvtRegionIdx = getPvtRegionIndex_<FluidState>(fs);
setPvtRegionIndex(pvtRegionIdx);
setRs(Opm::BlackOil::getRs_<FluidSystem, FluidState, Scalar>(fs, pvtRegionIdx));
setRv(Opm::BlackOil::getRv_<FluidSystem, FluidState, Scalar>(fs, pvtRegionIdx));
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
setSaturation(phaseIdx, fs.saturation(phaseIdx));
setPressure(phaseIdx, fs.pressure(phaseIdx));
setDensity(phaseIdx, fs.density(phaseIdx));
if (enableEnergy)
setEnthalpy(phaseIdx, fs.enthalpy(phaseIdx));
setInvB(phaseIdx, getInvB_<FluidSystem, FluidState, Scalar>(fs, phaseIdx, pvtRegionIdx));
}
}
static Scalar heatConductivity(const Params ¶ms,
const FluidState &fluidState)
{
Valgrind::CheckDefined(params.vacuumLambda());
Scalar lambda = 0;
for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
Valgrind::CheckDefined(params.fullySaturatedLambda(phaseIdx));
if (FluidSystem::isLiquid(phaseIdx)) {
lambda +=
regularizedSqrt_(std::max(0.0, std::min(1.0, fluidState.saturation(phaseIdx))))
* (params.fullySaturatedLambda(phaseIdx) - params.vacuumLambda());
}
else { // gas phase
lambda += params.fullySaturatedLambda(phaseIdx) - params.vacuumLambda();
}
};
lambda += params.vacuumLambda();
assert(lambda >= 0);
return lambda;
}
static Evaluation thermalConductivity(const Params& params,
const FluidState& fluidState)
{
Valgrind::CheckDefined(params.vacuumLambda());
Evaluation lambda = 0;
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
Valgrind::CheckDefined(params.fullySaturatedLambda(phaseIdx));
if (FluidSystem::isLiquid(phaseIdx)) {
const auto& sat = Opm::decay<Evaluation>(fluidState.saturation(phaseIdx));
lambda +=
regularizedSqrt_(Opm::max(0.0, Opm::min(1.0, sat)))
* (params.fullySaturatedLambda(phaseIdx) - params.vacuumLambda());
}
else { // gas phase
lambda += params.fullySaturatedLambda(phaseIdx) - params.vacuumLambda();
}
};
lambda += params.vacuumLambda();
assert(lambda >= 0);
return lambda;
}
/*!
* \brief Constructor
*
* The overlay fluid state copies the saturations from the
* argument, so it initially behaves exactly like the underlying
* fluid state.
*/
SaturationOverlayFluidState(const FluidState &fs)
: fs_(&fs)
{
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
saturation_[phaseIdx] = fs.saturation(phaseIdx);
}
static Evaluation krn(const Params& params, const FluidState& fs)
{
const Evaluation& Sw =
1.0 - Opm::decay<Evaluation>(fs.saturation(Traits::nonWettingPhaseIdx));
return twoPhaseSatKrn(params, Sw);
}
static Evaluation krw(const Params& params, const FluidState& fs)
{
const auto& Sw = Opm::decay<Evaluation>(fs.saturation(Traits::wettingPhaseIdx));
return twoPhaseSatKrw(params, Sw);
}
