OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

Rename PrimaryVarsMeaning{Water/Gas/Pressure/Brine} to {Water/Gas/Pressure/Brine}Meaning

Browse Source
This commit is contained in:
Tor Harald Sandve 2022-11-25 12:36:25 +01:00
parent 74dde790a2
commit 899dcc253c
7 changed files with 109 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
opm/models/blackoil/blackoilbrinemodules.hh
View File

@ -428,7 +428,7 @@ public:
const auto& saltdenTable = BrineModule::saltdenTable(elemCtx, dofIdx, timeIdx);
saltDensity_ = saltdenTable;
if (priVars.primaryVarsMeaningBrine() == PrimaryVariables::PrimaryVarsMeaningBrine::Sp) {
if (priVars.primaryVarsMeaningBrine() == PrimaryVariables::BrineMeaning::Sp) {
saltSaturation_ = priVars.makeEvaluation(saltConcentrationIdx, timeIdx);
fs.setSaltConcentration(saltSolubility_);
}

6
opm/models/blackoil/blackoilextbomodules.hh
View File

@ -619,14 +619,14 @@ public:
Evaluation pbub = fs.pressure(oilPhaseIdx);
if (priVars.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::Sw) {
if (priVars.primaryVarsMeaningWater() == PrimaryVariables::WaterMeaning::Sw) {
static const Scalar thresholdWaterFilledCell = 1.0 - 1e-6;
Scalar sw = priVars.makeEvaluation(Indices::waterSwitchIdx, timeIdx).value();
if (sw >= thresholdWaterFilledCell)
rs_ = 0.0; // water only, zero rs_ ...
}
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::Rs) {
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Rs) {
rs_ = priVars.makeEvaluation(Indices::compositionSwitchIdx, timeIdx);
const Evaluation zLim = ExtboModule::zLim(pvtRegionIdx);
if (zFraction_ > zLim) {
@ -639,7 +639,7 @@ public:
xVolume_ = ExtboModule::xVolume(pvtRegionIdx, pbub, zFraction_);
}
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Rv) {
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Rv) {
rv_ = priVars.makeEvaluation(Indices::compositionSwitchIdx, timeIdx);
Evaluation rvsat = ExtboModule::rv(pvtRegionIdx, pbub, zFraction_);
bg_ = ExtboModule::bg(pvtRegionIdx, pbub, zFraction_) + ExtboModule::gasCmp(pvtRegionIdx, zFraction_)*(rv_-rvsat);

20
opm/models/blackoil/blackoilintensivequantities.hh
View File

@ -184,20 +184,20 @@ public:
// extract the water and the gas saturations for convenience
Evaluation Sw = 0.0;
if constexpr (waterEnabled) {
if (priVars.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::Sw) {
if (priVars.primaryVarsMeaningWater() == PrimaryVariables::WaterMeaning::Sw) {
Sw = priVars.makeEvaluation(Indices::waterSwitchIdx, timeIdx);
} else if (priVars.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::Disabled){
} else if (priVars.primaryVarsMeaningWater() == PrimaryVariables::WaterMeaning::Disabled){
// water is enabled but is not a primary variable i.e. one phase case
Sw = 1.0;
}
}
Evaluation Sg = 0.0;
if constexpr (gasEnabled) {
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Sg) {
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Sg) {
Sg = priVars.makeEvaluation(Indices::compositionSwitchIdx, timeIdx);
} else if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Rv) {
} else if (priVars.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Rv) {
Sg = 1.0 - Sw;
} else if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Disabled) {
} else if (priVars.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Disabled) {
if constexpr (waterEnabled) {
Sg = 1.0 - Sw; // two phase water + gas
} else {
@ -233,7 +233,7 @@ public:
problem.updateRelperms(mobility_, dirMob_, fluidState_, globalSpaceIdx);
// oil is the reference phase for pressure
if (priVars.primaryVarsMeaningPressure() == PrimaryVariables::PrimaryVarsMeaningPressure::Pg) {
if (priVars.primaryVarsMeaningPressure() == PrimaryVariables::PressureMeaning::Pg) {
const Evaluation& pg = priVars.makeEvaluation(Indices::pressureSwitchIdx, timeIdx);
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
if (FluidSystem::phaseIsActive(phaseIdx))
@ -265,7 +265,7 @@ public:
// take the meaning of the switching primary variable into account for the gas
// and oil phase compositions
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Rs) {
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Rs) {
const auto& Rs = priVars.makeEvaluation(Indices::compositionSwitchIdx, timeIdx);
fluidState_.setRs(Rs);
} else {
@ -281,7 +281,7 @@ public:
fluidState_.setRs(0.0);
}
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Rv) {
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Rv) {
const auto& Rv = priVars.makeEvaluation(Indices::compositionSwitchIdx, timeIdx);
fluidState_.setRv(Rv);
} else {
@ -297,7 +297,7 @@ public:
fluidState_.setRv(0.0);
}
if (priVars.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::Rvw) {
if (priVars.primaryVarsMeaningWater() == PrimaryVariables::WaterMeaning::Rvw) {
const auto& Rvw = priVars.makeEvaluation(Indices::waterSwitchIdx, timeIdx);
fluidState_.setRvw(Rvw);
} else {
@ -414,7 +414,7 @@ public:
}
// deal with salt-precipitation
if (enableSaltPrecipitation && priVars.primaryVarsMeaningBrine() == PrimaryVariables::PrimaryVarsMeaningBrine::Sp) {
if (enableSaltPrecipitation && priVars.primaryVarsMeaningBrine() == PrimaryVariables::BrineMeaning::Sp) {
Evaluation Sp = priVars.makeEvaluation(Indices::saltConcentrationIdx, timeIdx);
porosity_ *= (1.0 - Sp);
}

12
opm/models/blackoil/blackoilmodel.hh
View File

@ -424,12 +424,12 @@ public:
assert(int(Indices::compositionSwitchIdx) == int(pvIdx));
auto pvMeaning = this->solution(0)[globalDofIdx].primaryVarsMeaningGas();
if (pvMeaning == PrimaryVariables::PrimaryVarsMeaningGas::Sg)
if (pvMeaning == PrimaryVariables::GasMeaning::Sg)
return 1.0; // gas saturation
else if (pvMeaning == PrimaryVariables::PrimaryVarsMeaningGas::Rs)
else if (pvMeaning == PrimaryVariables::GasMeaning::Rs)
return 1.0/250.; // gas dissolution factor
else {
assert(pvMeaning == PrimaryVariables::PrimaryVarsMeaningGas::Rv);
assert(pvMeaning == PrimaryVariables::GasMeaning::Rv);
return 1.0/0.025; // oil vaporization factor
}
@ -530,9 +530,9 @@ public:
PolymerModule::deserializeEntity(*this, instream, dof);
EnergyModule::deserializeEntity(*this, instream, dof);
using PVM_G = typename PrimaryVariables::PrimaryVarsMeaningGas;
using PVM_W = typename PrimaryVariables::PrimaryVarsMeaningWater;
using PVM_P = typename PrimaryVariables::PrimaryVarsMeaningPressure;
using PVM_G = typename PrimaryVariables::GasMeaning;
using PVM_W = typename PrimaryVariables::WaterMeaning;
using PVM_P = typename PrimaryVariables::PressureMeaning;
priVars.setPrimaryVarsMeaningGas(static_cast<PVM_G>(primaryVarsMeaningGas));
priVars.setPrimaryVarsMeaningWater(static_cast<PVM_W>(primaryVarsMeaningWater));
priVars.setPrimaryVarsMeaningPressure(static_cast<PVM_P>(primaryVarsMeaningPressure));

14
opm/models/blackoil/blackoilnewtonmethod.hh
View File

@ -261,12 +261,12 @@ protected:
Scalar deltaSg = 0.0;
Scalar deltaSs = 0.0;
if (currentValue.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::Sw)
if (currentValue.primaryVarsMeaningWater() == PrimaryVariables::WaterMeaning::Sw)
{
deltaSw = update[Indices::waterSwitchIdx];
deltaSo -= deltaSw;
}
if (currentValue.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Sg)
if (currentValue.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Sg)
{
deltaSg = update[Indices::compositionSwitchIdx];
deltaSo -= deltaSg;
@ -303,7 +303,7 @@ protected:
}
// water saturation delta
else if (pvIdx == Indices::waterSwitchIdx)
if (currentValue.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::Sw)
if (currentValue.primaryVarsMeaningWater() == PrimaryVariables::WaterMeaning::Sw)
delta *= satAlpha;
else {
//Ensure Rvw factor does not become negative
@ -316,7 +316,7 @@ protected:
// interpretation since it can represent Sg, Rs or Rv. For now, we only
// limit saturation deltas and ensure that the R factors do not become
// negative.
if (currentValue.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Sg)
if (currentValue.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Sg)
delta *= satAlpha;
else {
//Ensure Rv and Rs factor does not become negative
@ -348,7 +348,7 @@ protected:
}
else if (enableBrine && pvIdx == Indices::saltConcentrationIdx &&
enableSaltPrecipitation &&
currentValue.primaryVarsMeaningBrine() == PrimaryVariables::PrimaryVarsMeaningBrine::Sp) {
currentValue.primaryVarsMeaningBrine() == PrimaryVariables::BrineMeaning::Sp) {
const double maxSaltSaturationChange = 0.1;
const double sign = delta >= 0. ? 1. : -1.;
delta = sign * std::min(std::abs(delta), maxSaltSaturationChange);
@ -382,10 +382,10 @@ protected:
if (enableBrine && pvIdx == Indices::saltConcentrationIdx) {
// keep the salt concentration above 0
if (!enableSaltPrecipitation || (enableSaltPrecipitation && currentValue.primaryVarsMeaningBrine() == PrimaryVariables::PrimaryVarsMeaningBrine::Cs))
if (!enableSaltPrecipitation || (enableSaltPrecipitation && currentValue.primaryVarsMeaningBrine() == PrimaryVariables::BrineMeaning::Cs))
nextValue[pvIdx] = std::max(nextValue[pvIdx], 0.0);
// keep the salt saturation below upperlimit
if ((enableSaltPrecipitation && currentValue.primaryVarsMeaningBrine() == PrimaryVariables::PrimaryVarsMeaningBrine::Sp))
if ((enableSaltPrecipitation && currentValue.primaryVarsMeaningBrine() == PrimaryVariables::BrineMeaning::Sp))
nextValue[pvIdx] = std::min(nextValue[pvIdx], 1.0-1.e-8);
}

162
opm/models/blackoil/blackoilprimaryvariables.hh
View File

@ -124,18 +124,18 @@ class BlackOilPrimaryVariables : public FvBasePrimaryVariables<TypeTag>
static_assert(numComponents == 3, "The black-oil model assumes three components!");
public:
enum class PrimaryVarsMeaningWater {
enum class WaterMeaning {
Sw, // water saturation
Rvw, // vaporized water
Disabled, // The primary variable is not used
};
enum class PrimaryVarsMeaningPressure {
enum class PressureMeaning {
Po, // oil pressure
Pg, // gas pressure
Pw, // water pressure
};
enum class PrimaryVarsMeaningGas {
enum class GasMeaning {
Sg, // gas saturation
Rs, // dissolved gas in oil
//Rsw, // dissolved gas in water
@ -143,7 +143,7 @@ public:
Disabled, // The primary variable is not used
};
enum class PrimaryVarsMeaningBrine {
enum class BrineMeaning {
Cs, // salt concentration
Sp, // (precipitated) salt saturation
Disabled, // The primary variable is not used
@ -196,45 +196,45 @@ public:
* \brief Return the interpretation which should be applied to the switching primary
* variables.
*/
PrimaryVarsMeaningWater primaryVarsMeaningWater() const
WaterMeaning primaryVarsMeaningWater() const
{ return primaryVarsMeaningWater_; }
/*!
* \brief Set the interpretation which should be applied to the switching primary
* variables.
*/
void setPrimaryVarsMeaningWater(PrimaryVarsMeaningWater newMeaning)
void setPrimaryVarsMeaningWater(WaterMeaning newMeaning)
{ primaryVarsMeaningWater_ = newMeaning; }
/*!
* \brief Return the interpretation which should be applied to the switching primary
* variables.
*/
PrimaryVarsMeaningPressure primaryVarsMeaningPressure() const
PressureMeaning primaryVarsMeaningPressure() const
{ return primaryVarsMeaningPressure_; }
/*!
* \brief Set the interpretation which should be applied to the switching primary
* variables.
*/
void setPrimaryVarsMeaningPressure(PrimaryVarsMeaningPressure newMeaning)
void setPrimaryVarsMeaningPressure(PressureMeaning newMeaning)
{ primaryVarsMeaningPressure_ = newMeaning; }
/*!
* \brief Return the interpretation which should be applied to the switching primary
* variables.
*/
PrimaryVarsMeaningGas primaryVarsMeaningGas() const
GasMeaning primaryVarsMeaningGas() const
{ return primaryVarsMeaningGas_; }
/*!
* \brief Set the interpretation which should be applied to the switching primary
* variables.
*/
void setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas newMeaning)
void setPrimaryVarsMeaningGas(GasMeaning newMeaning)
{ primaryVarsMeaningGas_ = newMeaning; }
PrimaryVarsMeaningBrine primaryVarsMeaningBrine() const
BrineMeaning primaryVarsMeaningBrine() const
{ return primaryVarsMeaningBrine_; }
/*!
@ -242,7 +242,7 @@ public:
* variables.
*/
void setPrimaryVarsMeaningBrine(PrimaryVarsMeaningBrine newMeaning)
void setPrimaryVarsMeaningBrine(BrineMeaning newMeaning)
{ primaryVarsMeaningBrine_ = newMeaning; }
/*!
@ -344,78 +344,78 @@ public:
// determine the meaning of the primary variables
if (gasPresent && FluidSystem::enableVaporizedOil() && !oilPresent){
primaryVarsMeaningPressure_ = PrimaryVarsMeaningPressure::Pg;
primaryVarsMeaningPressure_ = PressureMeaning::Pg;
} else if (FluidSystem::phaseIsActive(oilPhaseIdx)) {
primaryVarsMeaningPressure_ = PrimaryVarsMeaningPressure::Po;
primaryVarsMeaningPressure_ = PressureMeaning::Po;
} else if (FluidSystem::phaseIsActive(gasPhaseIdx)) {
primaryVarsMeaningPressure_ = PrimaryVarsMeaningPressure::Pg;
primaryVarsMeaningPressure_ = PressureMeaning::Pg;
} else {
assert(FluidSystem::phaseIsActive(waterPhaseIdx));
primaryVarsMeaningPressure_ = PrimaryVarsMeaningPressure::Pw;
primaryVarsMeaningPressure_ = PressureMeaning::Pw;
}
// determine the meaning of the primary variables
if ( waterPresent && gasPresent ){
primaryVarsMeaningWater_ = PrimaryVarsMeaningWater::Sw;
primaryVarsMeaningWater_ = WaterMeaning::Sw;
} else if (gasPresent && FluidSystem::enableVaporizedWater()) {
primaryVarsMeaningWater_ = PrimaryVarsMeaningWater::Rvw;
primaryVarsMeaningWater_ = WaterMeaning::Rvw;
} else if (FluidSystem::phaseIsActive(waterPhaseIdx) && !oneActivePhases) {
primaryVarsMeaningWater_ = PrimaryVarsMeaningWater::Sw;
primaryVarsMeaningWater_ = WaterMeaning::Sw;
} else {
primaryVarsMeaningWater_ = PrimaryVarsMeaningWater::Disabled;
primaryVarsMeaningWater_ = WaterMeaning::Disabled;
}
// determine the meaning of the primary variables
if ( gasPresent && oilPresent ) {
primaryVarsMeaningGas_ = PrimaryVarsMeaningGas::Sg;
primaryVarsMeaningGas_ = GasMeaning::Sg;
} else if (oilPresent && FluidSystem::enableDissolvedGas()) {
primaryVarsMeaningGas_ = PrimaryVarsMeaningGas::Rs;
primaryVarsMeaningGas_ = GasMeaning::Rs;
} else if (gasPresent && FluidSystem::enableVaporizedOil()){
primaryVarsMeaningGas_ = PrimaryVarsMeaningGas::Rv;
primaryVarsMeaningGas_ = GasMeaning::Rv;
//} else if (waterPresent && FluidSystem::enableDissolvedGasInWater()) {
// primaryVarsMeaningGas_ = Rsw;
} else if (FluidSystem::phaseIsActive(gasPhaseIdx) && FluidSystem::phaseIsActive(oilPhaseIdx)) {
primaryVarsMeaningGas_ = PrimaryVarsMeaningGas::Sg;
primaryVarsMeaningGas_ = GasMeaning::Sg;
} else {
primaryVarsMeaningGas_ = PrimaryVarsMeaningGas::Disabled;
primaryVarsMeaningGas_ = GasMeaning::Disabled;
}
if constexpr (enableSaltPrecipitation){
if (precipitatedSaltPresent)
primaryVarsMeaningBrine_ = PrimaryVarsMeaningBrine::Sp;
primaryVarsMeaningBrine_ = BrineMeaning::Sp;
else
primaryVarsMeaningBrine_ = PrimaryVarsMeaningBrine::Cs;
primaryVarsMeaningBrine_ = BrineMeaning::Cs;
} else {
primaryVarsMeaningBrine_ = PrimaryVarsMeaningBrine::Disabled;
primaryVarsMeaningBrine_ = BrineMeaning::Disabled;
}
// assign the actual primary variables
switch(primaryVarsMeaningPressure()) {
case PrimaryVarsMeaningPressure::Po:
case PressureMeaning::Po:
(*this)[pressureSwitchIdx] = FsToolbox::value(fluidState.pressure(oilPhaseIdx));
break;
case PrimaryVarsMeaningPressure::Pg:
case PressureMeaning::Pg:
(*this)[pressureSwitchIdx] = FsToolbox::value(fluidState.pressure(gasPhaseIdx));
break;
case PrimaryVarsMeaningPressure::Pw:
case PressureMeaning::Pw:
(*this)[pressureSwitchIdx] = FsToolbox::value(fluidState.pressure(waterPhaseIdx));
break;
default:
throw std::logic_error("No valid primary variable selected for pressure");
}
switch(primaryVarsMeaningWater()) {
case PrimaryVarsMeaningWater::Sw:
case WaterMeaning::Sw:
{
(*this)[waterSwitchIdx] = FsToolbox::value(fluidState.saturation(waterPhaseIdx));
break;
}
case PrimaryVarsMeaningWater::Rvw:
case WaterMeaning::Rvw:
{
const auto& rvw = BlackOil::getRvw_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
(*this)[waterSwitchIdx] = rvw;
break;
}
case PrimaryVarsMeaningWater::Disabled:
case WaterMeaning::Disabled:
{
break;
}
@ -423,18 +423,18 @@ public:
throw std::logic_error("No valid primary variable selected for water");
}
switch(primaryVarsMeaningGas()) {
case PrimaryVarsMeaningGas::Sg:
case GasMeaning::Sg:
{
(*this)[compositionSwitchIdx] = FsToolbox::value(fluidState.saturation(gasPhaseIdx));
break;
}
case PrimaryVarsMeaningGas::Rs:
case GasMeaning::Rs:
{
const auto& rs = BlackOil::getRs_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
(*this)[compositionSwitchIdx] = rs;
break;
}
case PrimaryVarsMeaningGas::Rv:
case GasMeaning::Rv:
{
const auto& rv = BlackOil::getRv_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
(*this)[compositionSwitchIdx] = rv;
@ -446,7 +446,7 @@ public:
//(*this)[waterSwitchIdx] = Rsw;
// break;
//}
case PrimaryVarsMeaningGas::Disabled:
case GasMeaning::Disabled:
{
break;
}
@ -462,7 +462,7 @@ public:
*
* If the meaning of the primary variables changes, their values are also adapted in a
* meaningful manner. (e.g. if the gas phase appears and the composition switching
* variable changes its meaning from the gas dissolution factor PrimaryVarsMeaningGas::Rs to the gas
* variable changes its meaning from the gas dissolution factor GasMeaning::Rs to the gas
* saturation Sg, the value for this variable is set to zero.)
* A Scalar eps can be passed to make the switching condition more strict.
* Useful for avoiding ocsilation in the primaryVarsMeaning.
@ -478,35 +478,35 @@ public:
// the IntensiveQuantities). The reason is that most intensive quantities are not
// required to be able to decide if the primary variables needs to be switched or
// not, so it would be a waste to compute them.
if (primaryVarsMeaningWater() == PrimaryVarsMeaningWater::Disabled && primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Disabled){
if (primaryVarsMeaningWater() == WaterMeaning::Disabled && primaryVarsMeaningGas() == GasMeaning::Disabled){
return false;
}
Scalar sw = 0.0;
Scalar sg = 0.0;
Scalar saltConcentration = 0.0;
const Scalar& T = asImp_().temperature_();
if (primaryVarsMeaningWater() == PrimaryVarsMeaningWater::Sw)
if (primaryVarsMeaningWater() == WaterMeaning::Sw)
sw = (*this)[waterSwitchIdx];
if (primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Sg)
if (primaryVarsMeaningGas() == GasMeaning::Sg)
sg = (*this)[compositionSwitchIdx];
if (primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Disabled && gasEnabled)
if (primaryVarsMeaningGas() == GasMeaning::Disabled && gasEnabled)
sg = 1.0 - sw; // water + gas case
if constexpr (enableSaltPrecipitation) {
Scalar saltSolubility = BrineModule::saltSol(pvtRegionIndex());
if (primaryVarsMeaningBrine() == PrimaryVarsMeaningBrine::Sp) {
if (primaryVarsMeaningBrine() == BrineMeaning::Sp) {
saltConcentration = saltSolubility;
Scalar saltSat = (*this)[saltConcentrationIdx];
if (saltSat < -eps){ //precipitated salt dissappears
setPrimaryVarsMeaningBrine(PrimaryVarsMeaningBrine::Cs);
setPrimaryVarsMeaningBrine(BrineMeaning::Cs);
(*this)[saltConcentrationIdx] = saltSolubility; //set salt concentration to solubility limit
}
}
else if (primaryVarsMeaningBrine() == PrimaryVarsMeaningBrine::Cs) {
else if (primaryVarsMeaningBrine() == BrineMeaning::Cs) {
saltConcentration = (*this)[saltConcentrationIdx];
if (saltConcentration > saltSolubility + eps){ //salt concentration exceeds solubility limit
setPrimaryVarsMeaningBrine(PrimaryVarsMeaningBrine::Sp);
setPrimaryVarsMeaningBrine(BrineMeaning::Sp);
(*this)[saltConcentrationIdx] = 0.0;
}
}
@ -524,25 +524,25 @@ public:
(*this)[Indices::compositionSwitchIdx] = 0.0;
//const Scalar& po = (*this)[pressureSwitchIdx];
changed = primaryVarsMeaningWater() != PrimaryVarsMeaningWater::Sw || primaryVarsMeaningGas() != PrimaryVarsMeaningGas::Sg;
changed = primaryVarsMeaningWater() != WaterMeaning::Sw || primaryVarsMeaningGas() != GasMeaning::Sg;
if(changed) {
if constexpr (waterEnabled)
setPrimaryVarsMeaningWater(PrimaryVarsMeaningWater::Sw);
setPrimaryVarsMeaningWater(WaterMeaning::Sw);
if constexpr (compositionSwitchEnabled)
setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas::Sg);
setPrimaryVarsMeaningGas(GasMeaning::Sg);
//setPrimaryVarsMeaningPressure(PrimaryVarsMeaningPressure::Po);
//setPrimaryVarsMeaningPressure(PressureMeaning::Po);
// use water pressure?
}
return changed;
}
switch(primaryVarsMeaningWater()) {
case PrimaryVarsMeaningWater::Sw:
case WaterMeaning::Sw:
{
if(sw < -eps && sg > eps && FluidSystem::enableVaporizedWater()) {
Scalar p = (*this)[pressureSwitchIdx];
if(primaryVarsMeaningPressure() == PrimaryVarsMeaningPressure::Po) {
if(primaryVarsMeaningPressure() == PressureMeaning::Po) {
std::array<Scalar, numPhases> pC = { 0.0 };
const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
Scalar so = 1.0 - sg - solventSaturation_();
@ -553,7 +553,7 @@ public:
T,
p,
saltConcentration);
setPrimaryVarsMeaningWater(PrimaryVarsMeaningWater::Rvw);
setPrimaryVarsMeaningWater(WaterMeaning::Rvw);
(*this)[Indices::waterSwitchIdx] = rvwSat; //primary variable becomes Rvw
changed = true;
break;
@ -576,11 +576,11 @@ public:
//}
break;
}
case PrimaryVarsMeaningWater::Rvw:
case WaterMeaning::Rvw:
{
const Scalar& rvw = (*this)[waterSwitchIdx];
Scalar p = (*this)[pressureSwitchIdx];
if(primaryVarsMeaningPressure() == PrimaryVarsMeaningPressure::Po) {
if(primaryVarsMeaningPressure() == PressureMeaning::Po) {
std::array<Scalar, numPhases> pC = { 0.0 };
const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
Scalar so = 1.0 - sg - solventSaturation_();
@ -593,13 +593,13 @@ public:
saltConcentration);
if (rvw > rvwSat*(1.0 + eps)) {
// water phase appears
setPrimaryVarsMeaningWater(PrimaryVarsMeaningWater::Sw);
setPrimaryVarsMeaningWater(WaterMeaning::Sw);
(*this)[Indices::waterSwitchIdx] = 0.0; // water saturation
changed = true;
}
break;
}
case PrimaryVarsMeaningWater::Disabled:
case WaterMeaning::Disabled:
{
break;
}
@ -608,12 +608,12 @@ public:
}
switch(primaryVarsMeaningGas()) {
case PrimaryVarsMeaningGas::Sg:
case GasMeaning::Sg:
{
Scalar s = 1.0 - sw - solventSaturation_();
if (sg < -eps && s > 0.0 && FluidSystem::enableDissolvedGas()) {
const Scalar& po = (*this)[pressureSwitchIdx];
setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas::Rs);
setPrimaryVarsMeaningGas(GasMeaning::Rs);
Scalar soMax = problem.maxOilSaturation(globalDofIdx);
Scalar rsMax = problem.maxGasDissolutionFactor(/*timeIdx=*/0, globalDofIdx);
Scalar rsSat = enableExtbo ? ExtboModule::rs(pvtRegionIndex(),
@ -630,7 +630,7 @@ public:
Scalar so = 1.0 - sw - solventSaturation_() - sg;
if (so < -eps && sg > 0.0 && FluidSystem::enableVaporizedOil()) {
// the oil phase disappeared and some hydrocarbon gas phase is still
// present, i.e., switch the primary variables to PrimaryVarsMeaningGas::Rv.
// present, i.e., switch the primary variables to GasMeaning::Rv.
// we only have the oil pressure readily available, but we need the gas
// pressure, i.e. we must determine capillary pressure
const Scalar& po = (*this)[pressureSwitchIdx];
@ -639,9 +639,9 @@ public:
computeCapillaryPressures_(pC, /*so=*/0.0, sg + solventSaturation_(), sw, matParams);
Scalar pg = po + (pC[gasPhaseIdx] - pC[oilPhaseIdx]);
// we start at the PrimaryVarsMeaningGas::Rv value that corresponds to that of oil-saturated
// we start at the GasMeaning::Rv value that corresponds to that of oil-saturated
// hydrocarbon gas
setPrimaryVarsMeaningPressure(PrimaryVarsMeaningPressure::Pg);
setPrimaryVarsMeaningPressure(PressureMeaning::Pg);
(*this)[Indices::pressureSwitchIdx] = pg;
Scalar soMax = problem.maxOilSaturation(globalDofIdx);
Scalar rvMax = problem.maxOilVaporizationFactor(/*timeIdx=*/0, globalDofIdx);
@ -653,13 +653,13 @@ public:
pg,
Scalar(0),
soMax);
setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas::Rv);
setPrimaryVarsMeaningGas(GasMeaning::Rv);
(*this)[Indices::compositionSwitchIdx] = std::min(rvMax, rvSat);
changed = true;
}
break;
}
case PrimaryVarsMeaningGas::Rs:
case GasMeaning::Rs:
{
// Gas phase not present. The hydrocarbon gas phase
// appears as soon as more of the gas component is present in the oil phase
@ -679,14 +679,14 @@ public:
Scalar rs = (*this)[Indices::compositionSwitchIdx];
if (rs > std::min(rsMax, rsSat*(1.0 + eps))) {
// the gas phase appears, i.e., switch the primary variables to PrimaryVarsMeaningGas::Sg
setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas::Sg);
// the gas phase appears, i.e., switch the primary variables to GasMeaning::Sg
setPrimaryVarsMeaningGas(GasMeaning::Sg);
(*this)[Indices::compositionSwitchIdx] = 0.0; // hydrocarbon gas saturation
changed = true;
}
break;
}
case PrimaryVarsMeaningGas::Rv:
case GasMeaning::Rv:
{
// The oil phase appears as
// soon as more of the oil component is present in the hydrocarbon gas phase
@ -719,8 +719,8 @@ public:
matParams);
Scalar po = pg + (pC[oilPhaseIdx] - pC[gasPhaseIdx]);
setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas::Sg);
setPrimaryVarsMeaningPressure(PrimaryVarsMeaningPressure::Po);
setPrimaryVarsMeaningGas(GasMeaning::Sg);
setPrimaryVarsMeaningPressure(PressureMeaning::Po);
(*this)[Indices::pressureSwitchIdx] = po;
(*this)[Indices::compositionSwitchIdx] = sg2; // hydrocarbon gas saturation
changed = true;
@ -732,7 +732,7 @@ public:
//TODO
// break;
//}
case PrimaryVarsMeaningGas::Disabled:
case GasMeaning::Disabled:
{
break;
}
@ -743,15 +743,15 @@ public:
}
bool chopAndNormalizeSaturations(){
if (primaryVarsMeaningWater() == PrimaryVarsMeaningWater::Disabled &&
primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Disabled){
if (primaryVarsMeaningWater() == WaterMeaning::Disabled &&
primaryVarsMeaningGas() == GasMeaning::Disabled){
return false;
}
Scalar sw = 0.0;
if (primaryVarsMeaningWater() == PrimaryVarsMeaningWater::Sw)
if (primaryVarsMeaningWater() == WaterMeaning::Sw)
sw = (*this)[Indices::waterSwitchIdx];
Scalar sg = 0.0;
if (primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Sg)
if (primaryVarsMeaningGas() == GasMeaning::Sg)
sg = (*this)[Indices::compositionSwitchIdx];
Scalar ssol = 0.0;
@ -768,9 +768,9 @@ public:
sg = sg/st;
ssol = ssol/st;
assert(st>0.5);
if (primaryVarsMeaningWater() == PrimaryVarsMeaningWater::Sw)
if (primaryVarsMeaningWater() == WaterMeaning::Sw)
(*this)[Indices::waterSwitchIdx] = sw;
if (primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Sg)
if (primaryVarsMeaningGas() == GasMeaning::Sg)
(*this)[Indices::compositionSwitchIdx] = sg;
if constexpr (enableSolvent)
(*this) [Indices::solventSaturationIdx] = ssol;
@ -933,10 +933,10 @@ private:
MaterialLaw::capillaryPressures(result, matParams, fluidState);
}
PrimaryVarsMeaningWater primaryVarsMeaningWater_;
PrimaryVarsMeaningPressure primaryVarsMeaningPressure_;
PrimaryVarsMeaningGas primaryVarsMeaningGas_;
PrimaryVarsMeaningBrine primaryVarsMeaningBrine_;
WaterMeaning primaryVarsMeaningWater_;
PressureMeaning primaryVarsMeaningPressure_;
GasMeaning primaryVarsMeaningGas_;
BrineMeaning primaryVarsMeaningBrine_;
unsigned short pvtRegionIdx_;
};

2
opm/models/blackoil/blackoilsolventmodules.hh
View File

@ -733,7 +733,7 @@ public:
//oil is the reference phase for pressure
const auto linearizationType = elemCtx.linearizationType();
if (priVars.primaryVarsMeaningPressure() == PrimaryVariables::Pg)
if (priVars.primaryVarsMeaningPressure() == PrimaryVariables::PressureMeaning::Pg)
pgMisc = priVars.makeEvaluation(Indices::pressureSwitchIdx, timeIdx, linearizationType);
else {
const Evaluation& po = priVars.makeEvaluation(Indices::pressureSwitchIdx, timeIdx, linearizationType);