OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2025-02-16 20:24:48 -06:00
Code Issues Packages Projects Releases Wiki Activity

Change enum to enum class for primary variable meaning

Browse Source
This commit is contained in:
Tor Harald Sandve 2022-11-25 10:16:58 +01:00
parent de09a3eb3c
commit 74dde790a2
7 changed files with 102 additions and 101 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::Sp) {
if (priVars.primaryVarsMeaningBrine() == PrimaryVariables::PrimaryVarsMeaningBrine::Sp) {
saltSaturation_ = priVars.makeEvaluation(saltConcentrationIdx, timeIdx);
fs.setSaltConcentration(saltSolubility_);
}

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

@ -619,7 +619,7 @@ public:
Evaluation pbub = fs.pressure(oilPhaseIdx);
if (priVars.primaryVarsMeaningWater() == PrimaryVariables::Sw) {
if (priVars.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::Sw) {
static const Scalar thresholdWaterFilledCell = 1.0 - 1e-6;
Scalar sw = priVars.makeEvaluation(Indices::waterSwitchIdx, timeIdx).value();
if (sw >= thresholdWaterFilledCell)
@ -639,7 +639,7 @@ public:
xVolume_ = ExtboModule::xVolume(pvtRegionIdx, pbub, zFraction_);
}
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::Rv) {
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::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::Sw) {
if (priVars.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::Sw) {
Sw = priVars.makeEvaluation(Indices::waterSwitchIdx, timeIdx);
} else if (priVars.primaryVarsMeaningWater() == PrimaryVariables::W_disabled){
} else if (priVars.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::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::Sg) {
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Sg) {
Sg = priVars.makeEvaluation(Indices::compositionSwitchIdx, timeIdx);
} else if (priVars.primaryVarsMeaningGas() == PrimaryVariables::Rv) {
} else if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Rv) {
Sg = 1.0 - Sw;
} else if (priVars.primaryVarsMeaningGas() == PrimaryVariables::G_disabled) {
} else if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::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::Pg) {
if (priVars.primaryVarsMeaningPressure() == PrimaryVariables::PrimaryVarsMeaningPressure::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::Rs) {
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::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::Rv) {
if (priVars.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::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::Rvw) {
if (priVars.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::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::Sp) {
if (enableSaltPrecipitation && priVars.primaryVarsMeaningBrine() == PrimaryVariables::PrimaryVarsMeaningBrine::Sp) {
Evaluation Sp = priVars.makeEvaluation(Indices::saltConcentrationIdx, timeIdx);
porosity_ *= (1.0 - Sp);
}

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

@ -343,7 +343,7 @@ public:
std::ostringstream oss;
if (pvIdx == Indices::waterSwitchIdx)
oss << "saturation_" << FluidSystem::phaseName(FluidSystem::waterPhaseIdx);
oss << "water_switching";
else if (pvIdx == Indices::pressureSwitchIdx)
oss << "pressure_switching";
else if (static_cast<int>(pvIdx) == Indices::compositionSwitchIdx)
@ -424,12 +424,12 @@ public:
assert(int(Indices::compositionSwitchIdx) == int(pvIdx));
auto pvMeaning = this->solution(0)[globalDofIdx].primaryVarsMeaningGas();
if (pvMeaning == PrimaryVariables::Sg)
if (pvMeaning == PrimaryVariables::PrimaryVarsMeaningGas::Sg)
return 1.0; // gas saturation
else if (pvMeaning == PrimaryVariables::Rs)
else if (pvMeaning == PrimaryVariables::PrimaryVarsMeaningGas::Rs)
return 1.0/250.; // gas dissolution factor
else {
assert(pvMeaning == PrimaryVariables::Rv);
assert(pvMeaning == PrimaryVariables::PrimaryVarsMeaningGas::Rv);
return 1.0/0.025; // oil vaporization factor
}
@ -475,9 +475,9 @@ public:
outstream << priVars[eqIdx] << " ";
// write the pseudo primary variables
outstream << priVars.primaryVarsMeaningGas() << " ";
outstream << priVars.primaryVarsMeaningWater() << " ";
outstream << priVars.primaryVarsMeaningPressure() << " ";
outstream << static_cast<int>(priVars.primaryVarsMeaningGas()) << " ";
outstream << static_cast<int>(priVars.primaryVarsMeaningWater()) << " ";
outstream << static_cast<int>(priVars.primaryVarsMeaningPressure()) << " ";
outstream << priVars.pvtRegionIndex() << " ";

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::Sw)
if (currentValue.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::Sw)
{
deltaSw = update[Indices::waterSwitchIdx];
deltaSo -= deltaSw;
}
if (currentValue.primaryVarsMeaningGas() == PrimaryVariables::Sg)
if (currentValue.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::Sg)
{
deltaSg = update[Indices::compositionSwitchIdx];
deltaSo -= deltaSg;
@ -303,7 +303,7 @@ protected:
}
// water saturation delta
else if (pvIdx == Indices::waterSwitchIdx)
if (currentValue.primaryVarsMeaningWater() == PrimaryVariables::Sw)
if (currentValue.primaryVarsMeaningWater() == PrimaryVariables::PrimaryVarsMeaningWater::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::Sg)
if (currentValue.primaryVarsMeaningGas() == PrimaryVariables::PrimaryVarsMeaningGas::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::Sp) {
currentValue.primaryVarsMeaningBrine() == PrimaryVariables::PrimaryVarsMeaningBrine::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::Cs))
if (!enableSaltPrecipitation || (enableSaltPrecipitation && currentValue.primaryVarsMeaningBrine() == PrimaryVariables::PrimaryVarsMeaningBrine::Cs))
nextValue[pvIdx] = std::max(nextValue[pvIdx], 0.0);
// keep the salt saturation below upperlimit
if ((enableSaltPrecipitation && currentValue.primaryVarsMeaningBrine() == PrimaryVariables::Sp))
if ((enableSaltPrecipitation && currentValue.primaryVarsMeaningBrine() == PrimaryVariables::PrimaryVarsMeaningBrine::Sp))
nextValue[pvIdx] = std::min(nextValue[pvIdx], 1.0-1.e-8);
}

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

@ -124,29 +124,29 @@ class BlackOilPrimaryVariables : public FvBasePrimaryVariables<TypeTag>
static_assert(numComponents == 3, "The black-oil model assumes three components!");
public:
enum PrimaryVarsMeaningWater {
enum class PrimaryVarsMeaningWater {
Sw, // water saturation
Rvw, // vaporized water
W_disabled,
Disabled, // The primary variable is not used
};
enum PrimaryVarsMeaningPressure {
enum class PrimaryVarsMeaningPressure {
Po, // oil pressure
Pg, // gas pressure
Pw, // water pressure
};
enum PrimaryVarsMeaningGas {
enum class PrimaryVarsMeaningGas {
Sg, // gas saturation
Rs, // dissolved gas in oil
//Rsw, // dissolved gas in water
Rv, // vapporized oil
G_disabled,
Disabled, // The primary variable is not used
};
enum PrimaryVarsMeaningBrine {
enum class PrimaryVarsMeaningBrine {
Cs, // salt concentration
Sp, // (precipitated) salt saturation
Brine_disabled,
Disabled, // The primary variable is not used
};
BlackOilPrimaryVariables()
@ -344,78 +344,78 @@ public:
// determine the meaning of the primary variables
if (gasPresent && FluidSystem::enableVaporizedOil() && !oilPresent){
primaryVarsMeaningPressure_ = Pg;
primaryVarsMeaningPressure_ = PrimaryVarsMeaningPressure::Pg;
} else if (FluidSystem::phaseIsActive(oilPhaseIdx)) {
primaryVarsMeaningPressure_ = Po;
primaryVarsMeaningPressure_ = PrimaryVarsMeaningPressure::Po;
} else if (FluidSystem::phaseIsActive(gasPhaseIdx)) {
primaryVarsMeaningPressure_ = Pg;
primaryVarsMeaningPressure_ = PrimaryVarsMeaningPressure::Pg;
} else {
assert(FluidSystem::phaseIsActive(waterPhaseIdx));
primaryVarsMeaningPressure_ = Pw;
primaryVarsMeaningPressure_ = PrimaryVarsMeaningPressure::Pw;
}
// determine the meaning of the primary variables
if ( waterPresent && gasPresent ){
primaryVarsMeaningWater_ = Sw;
primaryVarsMeaningWater_ = PrimaryVarsMeaningWater::Sw;
} else if (gasPresent && FluidSystem::enableVaporizedWater()) {
primaryVarsMeaningWater_ = Rvw;
primaryVarsMeaningWater_ = PrimaryVarsMeaningWater::Rvw;
} else if (FluidSystem::phaseIsActive(waterPhaseIdx) && !oneActivePhases) {
primaryVarsMeaningWater_ = Sw;
primaryVarsMeaningWater_ = PrimaryVarsMeaningWater::Sw;
} else {
primaryVarsMeaningWater_ = W_disabled;
primaryVarsMeaningWater_ = PrimaryVarsMeaningWater::Disabled;
}
// determine the meaning of the primary variables
if ( gasPresent && oilPresent ) {
primaryVarsMeaningGas_ = Sg;
primaryVarsMeaningGas_ = PrimaryVarsMeaningGas::Sg;
} else if (oilPresent && FluidSystem::enableDissolvedGas()) {
primaryVarsMeaningGas_ = Rs;
primaryVarsMeaningGas_ = PrimaryVarsMeaningGas::Rs;
} else if (gasPresent && FluidSystem::enableVaporizedOil()){
primaryVarsMeaningGas_ = Rv;
primaryVarsMeaningGas_ = PrimaryVarsMeaningGas::Rv;
//} else if (waterPresent && FluidSystem::enableDissolvedGasInWater()) {
// primaryVarsMeaningGas_ = Rsw;
} else if (FluidSystem::phaseIsActive(gasPhaseIdx) && FluidSystem::phaseIsActive(oilPhaseIdx)) {
primaryVarsMeaningGas_ = Sg;
primaryVarsMeaningGas_ = PrimaryVarsMeaningGas::Sg;
} else {
primaryVarsMeaningGas_ = G_disabled;
primaryVarsMeaningGas_ = PrimaryVarsMeaningGas::Disabled;
}
if constexpr (enableSaltPrecipitation){
if (precipitatedSaltPresent)
primaryVarsMeaningBrine_ = Sp;
primaryVarsMeaningBrine_ = PrimaryVarsMeaningBrine::Sp;
else
primaryVarsMeaningBrine_ = Cs;
primaryVarsMeaningBrine_ = PrimaryVarsMeaningBrine::Cs;
} else {
primaryVarsMeaningBrine_ = Brine_disabled;
primaryVarsMeaningBrine_ = PrimaryVarsMeaningBrine::Disabled;
}
// assign the actual primary variables
switch(primaryVarsMeaningPressure()) {
case Po:
case PrimaryVarsMeaningPressure::Po:
(*this)[pressureSwitchIdx] = FsToolbox::value(fluidState.pressure(oilPhaseIdx));
break;
case Pg:
case PrimaryVarsMeaningPressure::Pg:
(*this)[pressureSwitchIdx] = FsToolbox::value(fluidState.pressure(gasPhaseIdx));
break;
case Pw:
case PrimaryVarsMeaningPressure::Pw:
(*this)[pressureSwitchIdx] = FsToolbox::value(fluidState.pressure(waterPhaseIdx));
break;
default:
throw std::logic_error("No valid primary variable selected for pressure");
}
switch(primaryVarsMeaningWater()) {
case Sw:
case PrimaryVarsMeaningWater::Sw:
{
(*this)[waterSwitchIdx] = FsToolbox::value(fluidState.saturation(waterPhaseIdx));
break;
}
case Rvw:
case PrimaryVarsMeaningWater::Rvw:
{
const auto& rvw = BlackOil::getRvw_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
(*this)[waterSwitchIdx] = rvw;
break;
}
case W_disabled:
case PrimaryVarsMeaningWater::Disabled:
{
break;
}
@ -423,18 +423,18 @@ public:
throw std::logic_error("No valid primary variable selected for water");
}
switch(primaryVarsMeaningGas()) {
case Sg:
case PrimaryVarsMeaningGas::Sg:
{
(*this)[compositionSwitchIdx] = FsToolbox::value(fluidState.saturation(gasPhaseIdx));
break;
}
case Rs:
case PrimaryVarsMeaningGas::Rs:
{
const auto& rs = BlackOil::getRs_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
(*this)[compositionSwitchIdx] = rs;
break;
}
case Rv:
case PrimaryVarsMeaningGas::Rv:
{
const auto& rv = BlackOil::getRv_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
(*this)[compositionSwitchIdx] = rv;
@ -446,7 +446,7 @@ public:
//(*this)[waterSwitchIdx] = Rsw;
// break;
//}
case G_disabled:
case PrimaryVarsMeaningGas::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 Rs to the gas
* variable changes its meaning from the gas dissolution factor PrimaryVarsMeaningGas::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() == W_disabled && primaryVarsMeaningGas() == G_disabled){
if (primaryVarsMeaningWater() == PrimaryVarsMeaningWater::Disabled && primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Disabled){
return false;
}
Scalar sw = 0.0;
Scalar sg = 0.0;
Scalar saltConcentration = 0.0;
const Scalar& T = asImp_().temperature_();
if (primaryVarsMeaningWater() == Sw)
if (primaryVarsMeaningWater() == PrimaryVarsMeaningWater::Sw)
sw = (*this)[waterSwitchIdx];
if (primaryVarsMeaningGas() == Sg)
if (primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Sg)
sg = (*this)[compositionSwitchIdx];
if (primaryVarsMeaningGas() == G_disabled && gasEnabled)
if (primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Disabled && gasEnabled)
sg = 1.0 - sw; // water + gas case
if constexpr (enableSaltPrecipitation) {
Scalar saltSolubility = BrineModule::saltSol(pvtRegionIndex());
if (primaryVarsMeaningBrine() == Sp) {
if (primaryVarsMeaningBrine() == PrimaryVarsMeaningBrine::Sp) {
saltConcentration = saltSolubility;
Scalar saltSat = (*this)[saltConcentrationIdx];
if (saltSat < -eps){ //precipitated salt dissappears
setPrimaryVarsMeaningBrine(Cs);
setPrimaryVarsMeaningBrine(PrimaryVarsMeaningBrine::Cs);
(*this)[saltConcentrationIdx] = saltSolubility; //set salt concentration to solubility limit
}
}
else if (primaryVarsMeaningBrine() == Cs) {
else if (primaryVarsMeaningBrine() == PrimaryVarsMeaningBrine::Cs) {
saltConcentration = (*this)[saltConcentrationIdx];
if (saltConcentration > saltSolubility + eps){ //salt concentration exceeds solubility limit
setPrimaryVarsMeaningBrine(Sp);
setPrimaryVarsMeaningBrine(PrimaryVarsMeaningBrine::Sp);
(*this)[saltConcentrationIdx] = 0.0;
}
}
@ -524,25 +524,25 @@ public:
(*this)[Indices::compositionSwitchIdx] = 0.0;
//const Scalar& po = (*this)[pressureSwitchIdx];
changed = primaryVarsMeaningWater() != Sw || primaryVarsMeaningGas() != Sg;
changed = primaryVarsMeaningWater() != PrimaryVarsMeaningWater::Sw || primaryVarsMeaningGas() != PrimaryVarsMeaningGas::Sg;
if(changed) {
if constexpr (waterEnabled)
setPrimaryVarsMeaningWater(Sw);
setPrimaryVarsMeaningWater(PrimaryVarsMeaningWater::Sw);
if constexpr (compositionSwitchEnabled)
setPrimaryVarsMeaningGas(Sg);
setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas::Sg);
//setPrimaryVarsMeaningPressure(Po);
//setPrimaryVarsMeaningPressure(PrimaryVarsMeaningPressure::Po);
// use water pressure?
}
return changed;
}
switch(primaryVarsMeaningWater()) {
case Sw:
case PrimaryVarsMeaningWater::Sw:
{
if(sw < -eps && sg > eps && FluidSystem::enableVaporizedWater()) {
Scalar p = (*this)[pressureSwitchIdx];
if(primaryVarsMeaningPressure() == Po) {
if(primaryVarsMeaningPressure() == PrimaryVarsMeaningPressure::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(Rvw);
setPrimaryVarsMeaningWater(PrimaryVarsMeaningWater::Rvw);
(*this)[Indices::waterSwitchIdx] = rvwSat; //primary variable becomes Rvw
changed = true;
break;
@ -576,11 +576,11 @@ public:
//}
break;
}
case Rvw:
case PrimaryVarsMeaningWater::Rvw:
{
const Scalar& rvw = (*this)[waterSwitchIdx];
Scalar p = (*this)[pressureSwitchIdx];
if(primaryVarsMeaningPressure() == Po) {
if(primaryVarsMeaningPressure() == PrimaryVarsMeaningPressure::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(Sw);
setPrimaryVarsMeaningWater(PrimaryVarsMeaningWater::Sw);
(*this)[Indices::waterSwitchIdx] = 0.0; // water saturation
changed = true;
}
break;
}
case W_disabled:
case PrimaryVarsMeaningWater::Disabled:
{
break;
}
@ -608,12 +608,12 @@ public:
}
switch(primaryVarsMeaningGas()) {
case Sg:
case PrimaryVarsMeaningGas::Sg:
{
Scalar s = 1.0 - sw - solventSaturation_();
if (sg < -eps && s > 0.0 && FluidSystem::enableDissolvedGas()) {
const Scalar& po = (*this)[pressureSwitchIdx];
setPrimaryVarsMeaningGas(Rs);
setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas::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 Rv.
// present, i.e., switch the primary variables to PrimaryVarsMeaningGas::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 Rv value that corresponds to that of oil-saturated
// we start at the PrimaryVarsMeaningGas::Rv value that corresponds to that of oil-saturated
// hydrocarbon gas
setPrimaryVarsMeaningPressure(Pg);
setPrimaryVarsMeaningPressure(PrimaryVarsMeaningPressure::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(Rv);
setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas::Rv);
(*this)[Indices::compositionSwitchIdx] = std::min(rvMax, rvSat);
changed = true;
}
break;
}
case Rs:
case PrimaryVarsMeaningGas::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 Sg
setPrimaryVarsMeaningGas(Sg);
// the gas phase appears, i.e., switch the primary variables to PrimaryVarsMeaningGas::Sg
setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas::Sg);
(*this)[Indices::compositionSwitchIdx] = 0.0; // hydrocarbon gas saturation
changed = true;
}
break;
}
case Rv:
case PrimaryVarsMeaningGas::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(Sg);
setPrimaryVarsMeaningPressure(Po);
setPrimaryVarsMeaningGas(PrimaryVarsMeaningGas::Sg);
setPrimaryVarsMeaningPressure(PrimaryVarsMeaningPressure::Po);
(*this)[Indices::pressureSwitchIdx] = po;
(*this)[Indices::compositionSwitchIdx] = sg2; // hydrocarbon gas saturation
changed = true;
@ -732,7 +732,7 @@ public:
//TODO
// break;
//}
case G_disabled:
case PrimaryVarsMeaningGas::Disabled:
{
break;
}
@ -743,14 +743,15 @@ public:
}
bool chopAndNormalizeSaturations(){
if (primaryVarsMeaningWater() == W_disabled && primaryVarsMeaningGas() == G_disabled){
if (primaryVarsMeaningWater() == PrimaryVarsMeaningWater::Disabled &&
primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Disabled){
return false;
}
Scalar sw = 0.0;
if (primaryVarsMeaningWater() == Sw)
if (primaryVarsMeaningWater() == PrimaryVarsMeaningWater::Sw)
sw = (*this)[Indices::waterSwitchIdx];
Scalar sg = 0.0;
if (primaryVarsMeaningGas() == Sg)
if (primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Sg)
sg = (*this)[Indices::compositionSwitchIdx];
Scalar ssol = 0.0;
@ -767,9 +768,9 @@ public:
sg = sg/st;
ssol = ssol/st;
assert(st>0.5);
if (primaryVarsMeaningWater() == Sw)
if (primaryVarsMeaningWater() == PrimaryVarsMeaningWater::Sw)
(*this)[Indices::waterSwitchIdx] = sw;
if (primaryVarsMeaningGas() == Sg)
if (primaryVarsMeaningGas() == PrimaryVarsMeaningGas::Sg)
(*this)[Indices::compositionSwitchIdx] = sg;
if constexpr (enableSolvent)
(*this) [Indices::solventSaturationIdx] = ssol;

6
opm/models/io/vtkblackoilmodule.hh
View File

@ -294,11 +294,11 @@ public:
if (primaryVarsMeaningOutput_()) {
primaryVarsMeaningWater_[globalDofIdx] =
primaryVars.primaryVarsMeaningWater();
static_cast<int>(primaryVars.primaryVarsMeaningWater());
primaryVarsMeaningGas_[globalDofIdx] =
primaryVars.primaryVarsMeaningGas();
static_cast<int>(primaryVars.primaryVarsMeaningGas());
primaryVarsMeaningPressure_[globalDofIdx] =
primaryVars.primaryVarsMeaningPressure();
static_cast<int>(primaryVars.primaryVarsMeaningPressure());
}
}
}