24#ifndef EWOMS_BLACK_OIL_PRIMARY_VARIABLES_HH
25#define EWOMS_BLACK_OIL_PRIMARY_VARIABLES_HH
27#include <dune/common/fvector.hh>
29#include <opm/material/common/MathToolbox.hpp>
30#include <opm/material/common/Valgrind.hpp>
31#include <opm/material/constraintsolvers/NcpFlash.hpp>
32#include <opm/material/fluidsystems/BlackOilFluidSystem.hpp>
33#include <opm/material/fluidstates/CompositionalFluidState.hpp>
34#include <opm/material/fluidstates/SimpleModularFluidState.hpp>
59{
static constexpr Scalar
value = 1.0; };
70template <
class TypeTag>
85 enum { numEq = getPropValue<TypeTag, Properties::NumEq>() };
88 enum { waterSwitchIdx = Indices::waterSwitchIdx };
89 enum { pressureSwitchIdx = Indices::pressureSwitchIdx };
90 enum { compositionSwitchIdx = Indices::compositionSwitchIdx };
91 enum { saltConcentrationIdx = Indices::saltConcentrationIdx };
92 enum { solventSaturationIdx = Indices::solventSaturationIdx };
94 static constexpr bool compositionSwitchEnabled = Indices::compositionSwitchIdx >= 0;
95 static constexpr bool waterEnabled = Indices::waterEnabled;
96 static constexpr bool gasEnabled = Indices::gasEnabled;
97 static constexpr bool oilEnabled = Indices::oilEnabled;
100 enum { numPhases = getPropValue<TypeTag, Properties::NumPhases>() };
101 enum { gasPhaseIdx = FluidSystem::gasPhaseIdx };
102 enum { waterPhaseIdx = FluidSystem::waterPhaseIdx };
103 enum { oilPhaseIdx = FluidSystem::oilPhaseIdx };
106 enum { numComponents = getPropValue<TypeTag, Properties::NumComponents>() };
107 enum { enableSolvent = getPropValue<TypeTag, Properties::EnableSolvent>() };
108 enum { enableExtbo = getPropValue<TypeTag, Properties::EnableExtbo>() };
109 enum { enablePolymer = getPropValue<TypeTag, Properties::EnablePolymer>() };
110 enum { enableFoam = getPropValue<TypeTag, Properties::EnableFoam>() };
111 enum { enableBrine = getPropValue<TypeTag, Properties::EnableBrine>() };
112 enum { enableSaltPrecipitation = getPropValue<TypeTag, Properties::EnableSaltPrecipitation>() };
113 enum { enableVapwat = getPropValue<TypeTag, Properties::EnableVapwat>() };
114 enum { enableEnergy = getPropValue<TypeTag, Properties::EnableEnergy>() };
115 enum { enableTemperature = getPropValue<TypeTag, Properties::EnableTemperature>() };
116 enum { enableMICP = getPropValue<TypeTag, Properties::EnableMICP>() };
117 enum { gasCompIdx = FluidSystem::gasCompIdx };
118 enum { waterCompIdx = FluidSystem::waterCompIdx };
119 enum { oilCompIdx = FluidSystem::oilCompIdx };
121 using Toolbox = MathToolbox<Evaluation>;
122 using ComponentVector = Dune::FieldVector<Scalar, numComponents>;
131 static_assert(numPhases == 3,
"The black-oil model assumes three phases!");
132 static_assert(numComponents == 3,
"The black-oil model assumes three components!");
169 Valgrind::SetUndefined(*
this);
181 result.pvtRegionIdx_ = 1;
187 for (std::size_t i = 0; i < result.size(); ++i) {
197 pressureScale_ = Parameters::Get<Parameters::PressureScale<Scalar>>();
202 Parameters::Register<Parameters::PressureScale<Scalar>>
203 (
"Scaling of pressure primary variable");
207 { pressureScale_ = val; }
213 const Scalar scale = varIdx == pressureSwitchIdx ? this->pressureScale_ : Scalar{1.0};
214 if (std::is_same_v<Evaluation, Scalar>) {
215 return (*
this)[varIdx] * scale;
219 if (timeIdx == linearizationType.time) {
220 return Toolbox::createVariable((*
this)[varIdx], varIdx) * scale;
223 return Toolbox::createConstant((*
this)[varIdx]) * scale;
236 { pvtRegionIdx_ =
static_cast<unsigned short>(value); }
242 {
return pvtRegionIdx_; }
249 {
return primaryVarsMeaningWater_; }
256 { primaryVarsMeaningWater_ = newMeaning; }
263 {
return primaryVarsMeaningPressure_; }
270 { primaryVarsMeaningPressure_ = newMeaning; }
277 {
return primaryVarsMeaningGas_; }
284 { primaryVarsMeaningGas_ = newMeaning; }
287 {
return primaryVarsMeaningBrine_; }
294 { primaryVarsMeaningBrine_ = newMeaning; }
297 {
return primaryVarsMeaningSolvent_; }
304 { primaryVarsMeaningSolvent_ = newMeaning; }
309 template <
class Flu
idState>
311 const MaterialLawParams& matParams,
312 bool isInEquilibrium =
false)
314 using ConstEvaluation = std::remove_reference_t<typename FluidState::Scalar>;
315 using FsEvaluation = std::remove_const_t<ConstEvaluation>;
316 using FsToolbox = MathToolbox<FsEvaluation>;
320 for (
unsigned phaseIdx = 1; phaseIdx < numPhases; ++phaseIdx) {
321 Valgrind::CheckDefined(fluidState.temperature(0));
322 Valgrind::CheckDefined(fluidState.temperature(phaseIdx));
324 assert(fluidState.temperature(0) == fluidState.temperature(phaseIdx));
330 if (isInEquilibrium) {
337 typename FluidSystem::template ParameterCache<Scalar> paramCache;
338 paramCache.setRegionIndex(pvtRegionIdx_);
339 paramCache.setMaxOilSat(FsToolbox::value(fluidState.saturation(oilPhaseIdx)));
342 using NcpFlash = NcpFlash<Scalar, FluidSystem>;
343 using FlashFluidState = CompositionalFluidState<Scalar, FluidSystem>;
344 FlashFluidState fsFlash;
345 fsFlash.setTemperature(FsToolbox::value(fluidState.temperature(0)));
346 for (
unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
347 fsFlash.setPressure(phaseIdx, FsToolbox::value(fluidState.pressure(phaseIdx)));
348 fsFlash.setSaturation(phaseIdx, FsToolbox::value(fluidState.saturation(phaseIdx)));
349 for (
unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
350 fsFlash.setMoleFraction(phaseIdx, compIdx,
351 FsToolbox::value(fluidState.moleFraction(phaseIdx, compIdx)));
355 paramCache.updateAll(fsFlash);
356 for (
unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
357 if (!FluidSystem::phaseIsActive(phaseIdx)) {
362 FluidSystem::template density<FlashFluidState, Scalar>(fsFlash, paramCache, phaseIdx);
363 fsFlash.setDensity(phaseIdx, rho);
367 ComponentVector globalMolarities(0.0);
368 for (
unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
369 for (
unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
370 if (!FluidSystem::phaseIsActive(phaseIdx)) {
374 globalMolarities[compIdx] +=
375 fsFlash.saturation(phaseIdx) * fsFlash.molarity(phaseIdx, compIdx);
383 NcpFlash::template solve<MaterialLaw>(fsFlash, matParams, paramCache, globalMolarities);
392 template <
class Flu
idState>
395 using ConstEvaluation = std::remove_reference_t<typename FluidState::Scalar>;
396 using FsEvaluation = std::remove_const_t<ConstEvaluation>;
397 using FsToolbox = MathToolbox<FsEvaluation>;
399 const bool gasPresent =
400 FluidSystem::phaseIsActive(gasPhaseIdx)
401 ? fluidState.saturation(gasPhaseIdx) > 0.0
403 const bool oilPresent =
404 FluidSystem::phaseIsActive(oilPhaseIdx)
405 ? fluidState.saturation(oilPhaseIdx) > 0.0
407 const bool waterPresent =
408 FluidSystem::phaseIsActive(waterPhaseIdx)
409 ? fluidState.saturation(waterPhaseIdx) > 0.0
411 const auto& saltSaturation =
412 BlackOil::getSaltSaturation_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
413 const bool precipitatedSaltPresent = enableSaltPrecipitation ? saltSaturation > 0.0 :
false;
414 const bool oneActivePhases = FluidSystem::numActivePhases() == 1;
421 if (gasPresent && FluidSystem::enableVaporizedOil() && !oilPresent) {
424 else if (FluidSystem::phaseIsActive(oilPhaseIdx)) {
427 else if (waterPresent && FluidSystem::enableDissolvedGasInWater() && !gasPresent) {
430 else if (FluidSystem::phaseIsActive(gasPhaseIdx)) {
434 assert(FluidSystem::phaseIsActive(waterPhaseIdx));
442 if (waterPresent && gasPresent) {
445 else if (gasPresent && FluidSystem::enableVaporizedWater()) {
448 else if (waterPresent && FluidSystem::enableDissolvedGasInWater()) {
451 else if (FluidSystem::phaseIsActive(waterPhaseIdx) && !oneActivePhases) {
463 if (gasPresent && oilPresent) {
466 else if (oilPresent && FluidSystem::enableDissolvedGas()) {
469 else if (gasPresent && FluidSystem::enableVaporizedOil()) {
472 else if (FluidSystem::phaseIsActive(gasPhaseIdx) && FluidSystem::phaseIsActive(oilPhaseIdx)) {
480 if constexpr (enableSaltPrecipitation) {
481 if (precipitatedSaltPresent) {
495 this->setScaledPressure_(FsToolbox::value(fluidState.pressure(oilPhaseIdx)));
498 this->setScaledPressure_(FsToolbox::value(fluidState.pressure(gasPhaseIdx)));
501 this->setScaledPressure_(FsToolbox::value(fluidState.pressure(waterPhaseIdx)));
504 throw std::logic_error(
"No valid primary variable selected for pressure");
510 (*this)[waterSwitchIdx] = FsToolbox::value(fluidState.saturation(waterPhaseIdx));
515 const auto& rvw = BlackOil::getRvw_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
516 (*this)[waterSwitchIdx] = rvw;
521 const auto& Rsw = BlackOil::getRsw_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
522 (*this)[waterSwitchIdx] = Rsw;
528 throw std::logic_error(
"No valid primary variable selected for water");
532 (*this)[compositionSwitchIdx] = FsToolbox::value(fluidState.saturation(gasPhaseIdx));
536 const auto& rs = BlackOil::getRs_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
537 (*this)[compositionSwitchIdx] = rs;
542 const auto& rv = BlackOil::getRv_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
543 (*this)[compositionSwitchIdx] = rv;
549 throw std::logic_error(
"No valid primary variable selected for composision");
565 unsigned globalDofIdx,
566 [[maybe_unused]] Scalar swMaximum,
567 Scalar thresholdWaterFilledCell, Scalar eps = 0.0)
586 Scalar saltConcentration = 0.0;
587 const Scalar& T = asImp_().temperature_(problem, globalDofIdx);
589 sw = (*this)[waterSwitchIdx];
592 sg = (*this)[compositionSwitchIdx];
604 if constexpr (enableSaltPrecipitation) {
607 saltConcentration = saltSolubility;
608 const Scalar saltSat = (*this)[saltConcentrationIdx];
609 if (saltSat < -eps) {
611 (*this)[saltConcentrationIdx] = saltSolubility;
615 saltConcentration = (*this)[saltConcentrationIdx];
616 if (saltConcentration > saltSolubility + eps) {
618 (*this)[saltConcentrationIdx] = 0.0;
626 if constexpr (enableSolvent) {
628 const Scalar p = (*this)[pressureSwitchIdx];
629 const Scalar solLimit =
632 const Scalar solSat = (*this)[solventSaturationIdx];
635 (*this)[solventSaturationIdx] = solLimit;
639 const Scalar rsolw = (*this)[solventSaturationIdx];
640 if (rsolw > solLimit + eps) {
642 (*this)[solventSaturationIdx] = 0.0;
649 bool changed =
false;
657 if (sw >= thresholdWaterFilledCell && !FluidSystem::enableDissolvedGasInWater()) {
659 if constexpr (waterEnabled) {
660 (*this)[Indices::waterSwitchIdx] = std::min(swMaximum, sw);
664 if constexpr (compositionSwitchEnabled) {
665 (*this)[Indices::compositionSwitchIdx] = 0.0;
670 if constexpr (compositionSwitchEnabled) {
680 const unsigned satnumRegionIdx = problem.satnumRegionIndex(globalDofIdx);
681 const Scalar Sp = saltConcentration_();
682 const Scalar porosityFactor = min(1.0 - Sp, 1.0);
684 pcFactor_ = pcfactTable.eval(porosityFactor,
true);
694 if (sw < -eps && sg > eps && FluidSystem::enableVaporizedWater()) {
695 Scalar p = this->pressure_();
697 std::array<Scalar, numPhases> pC{};
698 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
699 const Scalar so = 1.0 - sg - solventSaturation_();
700 computeCapillaryPressures_(pC, so, sg + solventSaturation_(), 0.0, matParams);
701 p += pcFactor_ * (pC[gasPhaseIdx] - pC[oilPhaseIdx]);
703 const Scalar rvwSat =
704 FluidSystem::gasPvt().saturatedWaterVaporizationFactor(pvtRegionIdx_,
709 (*this)[Indices::waterSwitchIdx] = rvwSat;
715 if (sg < -eps && sw > eps && FluidSystem::enableDissolvedGasInWater()) {
716 const Scalar pg = this->pressure_();
718 std::array<Scalar, numPhases> pC = { 0.0 };
719 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
720 const Scalar so = 1.0 - sw - solventSaturation_();
721 computeCapillaryPressures_(pC, so, 0.0, sw, matParams);
722 const Scalar pw = pg + pcFactor_ * (pC[waterPhaseIdx] - pC[gasPhaseIdx]);
723 const Scalar rswSat =
724 FluidSystem::waterPvt().saturatedGasDissolutionFactor(pvtRegionIdx_,
729 const Scalar rswMax = problem.maxGasDissolutionFactor(0, globalDofIdx);
730 (*this)[Indices::waterSwitchIdx] = min(rswSat, rswMax);
732 this->setScaledPressure_(pw);
740 const Scalar& rvw = (*this)[waterSwitchIdx];
741 Scalar p = this->pressure_();
743 std::array<Scalar, numPhases> pC{};
744 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
745 const Scalar so = 1.0 - sg - solventSaturation_();
746 computeCapillaryPressures_(pC, so, sg + solventSaturation_(), 0.0, matParams);
747 p += pcFactor_ * (pC[gasPhaseIdx] - pC[oilPhaseIdx]);
749 const Scalar rvwSat =
750 FluidSystem::gasPvt().saturatedWaterVaporizationFactor(pvtRegionIdx_,
755 if (rvw > rvwSat * (1.0 + eps)) {
757 (*this)[Indices::waterSwitchIdx] = 0.0;
767 const Scalar& pw = this->pressure_();
769 const Scalar rswSat =
770 FluidSystem::waterPvt().saturatedGasDissolutionFactor(pvtRegionIdx_,
775 const Scalar rsw = (*this)[Indices::waterSwitchIdx];
776 const Scalar rswMax = problem.maxGasDissolutionFactor(0, globalDofIdx);
777 if (rsw > min(rswSat, rswMax)) {
780 (*this)[Indices::waterSwitchIdx] = 1.0;
782 std::array<Scalar, numPhases> pC{};
783 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
784 computeCapillaryPressures_(pC, 0.0, 0.0, 1.0, matParams);
785 const Scalar pg = pw + pcFactor_ * (pC[gasPhaseIdx] - pC[waterPhaseIdx]);
786 this->setScaledPressure_(pg);
794 throw std::logic_error(
"No valid primary variable selected for water");
807 const Scalar s = 1.0 - sw - solventSaturation_();
808 if (sg < -eps && s > 0.0 && FluidSystem::enableDissolvedGas()) {
809 const Scalar po = this->pressure_();
811 const Scalar soMax = std::max(s, problem.maxOilSaturation(globalDofIdx));
812 const Scalar rsMax = problem.maxGasDissolutionFactor(0, globalDofIdx);
816 : FluidSystem::oilPvt().saturatedGasDissolutionFactor(pvtRegionIdx_,
821 (*this)[Indices::compositionSwitchIdx] = std::min(rsMax, rsSat);
824 const Scalar so = 1.0 - sw - solventSaturation_() - sg;
825 if (so < -eps && sg > 0.0 && FluidSystem::enableVaporizedOil()) {
830 const Scalar po = this->pressure_();
831 std::array<Scalar, numPhases> pC{};
832 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
833 computeCapillaryPressures_(pC, 0.0, sg + solventSaturation_(), sw, matParams);
834 const Scalar pg = po + pcFactor_ * (pC[gasPhaseIdx] - pC[oilPhaseIdx]);
839 this->setScaledPressure_(pg);
840 const Scalar soMax = problem.maxOilSaturation(globalDofIdx);
841 const Scalar rvMax = problem.maxOilVaporizationFactor(0, globalDofIdx);
845 : FluidSystem::gasPvt().saturatedOilVaporizationFactor(pvtRegionIdx_,
851 (*this)[Indices::compositionSwitchIdx] = std::min(rvMax, rvSat);
861 const Scalar po = this->pressure_();
862 const Scalar so = 1.0 - sw - solventSaturation_();
863 const Scalar soMax = std::max(so, problem.maxOilSaturation(globalDofIdx));
864 const Scalar rsMax = problem.maxGasDissolutionFactor(0, globalDofIdx);
868 : FluidSystem::oilPvt().saturatedGasDissolutionFactor(pvtRegionIdx_,
874 const Scalar rs = (*this)[Indices::compositionSwitchIdx];
875 if (rs > std::min(rsMax, rsSat * (Scalar{1.0} + eps))) {
878 (*this)[Indices::compositionSwitchIdx] = 0.0;
889 const Scalar pg = this->pressure_();
890 const Scalar soMax = problem.maxOilSaturation(globalDofIdx);
891 const Scalar rvMax = problem.maxOilVaporizationFactor(0, globalDofIdx);
895 : FluidSystem::gasPvt().saturatedOilVaporizationFactor(pvtRegionIdx_,
901 const Scalar rv = (*this)[Indices::compositionSwitchIdx];
902 if (rv > std::min(rvMax, rvSat * (Scalar{1.0} + eps))) {
906 const Scalar sg2 = 1.0 - sw - solventSaturation_();
907 std::array<Scalar, numPhases> pC{};
908 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
909 computeCapillaryPressures_(pC,
911 sg2 + solventSaturation_(),
914 const Scalar po = pg + pcFactor_ * (pC[oilPhaseIdx] - pC[gasPhaseIdx]);
918 this->setScaledPressure_(po);
919 (*this)[Indices::compositionSwitchIdx] = sg2;
927 throw std::logic_error(
"No valid primary variable selected for water");
941 sw = (*this)[Indices::waterSwitchIdx];
945 sg = (*this)[Indices::compositionSwitchIdx];
950 ssol =(*this) [Indices::solventSaturationIdx];
953 Scalar so = 1.0 - sw - sg - ssol;
954 sw = std::min(std::max(sw, Scalar{0.0}), Scalar{1.0});
955 so = std::min(std::max(so, Scalar{0.0}), Scalar{1.0});
956 sg = std::min(std::max(sg, Scalar{0.0}), Scalar{1.0});
957 ssol = std::min(std::max(ssol, Scalar{0.0}), Scalar{1.0});
958 const Scalar st = sw + so + sg + ssol;
964 (*this)[Indices::waterSwitchIdx] = sw;
967 (*this)[Indices::compositionSwitchIdx] = sg;
970 (*this) [Indices::solventSaturationIdx] = ssol;
978 using ParentType::operator=;
991 for (
unsigned i = 0; i < this->size(); ++i) {
992 Valgrind::CheckDefined((*
this)[i]);
996 Valgrind::CheckDefined(primaryVarsMeaningWater_);
997 Valgrind::CheckDefined(primaryVarsMeaningGas_);
998 Valgrind::CheckDefined(primaryVarsMeaningPressure_);
999 Valgrind::CheckDefined(primaryVarsMeaningBrine_);
1000 Valgrind::CheckDefined(primaryVarsMeaningSolvent_);
1002 Valgrind::CheckDefined(pvtRegionIdx_);
1006 template<
class Serializer>
1009 using FV = Dune::FieldVector<Scalar, getPropValue<TypeTag, Properties::NumEq>()>;
1010 serializer(
static_cast<FV&
>(*
this));
1011 serializer(primaryVarsMeaningWater_);
1012 serializer(primaryVarsMeaningPressure_);
1013 serializer(primaryVarsMeaningGas_);
1014 serializer(primaryVarsMeaningBrine_);
1015 serializer(primaryVarsMeaningSolvent_);
1016 serializer(pvtRegionIdx_);
1023 && this->primaryVarsMeaningWater_ == rhs.primaryVarsMeaningWater_
1024 && this->primaryVarsMeaningPressure_ == rhs.primaryVarsMeaningPressure_
1025 && this->primaryVarsMeaningGas_ == rhs.primaryVarsMeaningGas_
1026 && this->primaryVarsMeaningBrine_ == rhs.primaryVarsMeaningBrine_
1027 && this->primaryVarsMeaningSolvent_ == rhs.primaryVarsMeaningSolvent_
1028 && this->pvtRegionIdx_ == rhs.pvtRegionIdx_;
1032 Implementation& asImp_()
1033 {
return *
static_cast<Implementation*
>(
this); }
1035 const Implementation& asImp_()
const
1036 {
return *
static_cast<const Implementation*
>(
this); }
1038 Scalar solventSaturation_()
const
1040 if constexpr (enableSolvent) {
1042 return (*
this)[Indices::solventSaturationIdx];
1048 Scalar zFraction_()
const
1050 if constexpr (enableExtbo) {
1051 return (*
this)[Indices::zFractionIdx];
1058 Scalar polymerConcentration_()
const
1060 if constexpr (enablePolymer) {
1061 return (*
this)[Indices::polymerConcentrationIdx];
1068 Scalar foamConcentration_()
const
1070 if constexpr (enableFoam) {
1071 return (*
this)[Indices::foamConcentrationIdx];
1078 Scalar saltConcentration_()
const
1080 if constexpr (enableBrine) {
1081 return (*
this)[Indices::saltConcentrationIdx];
1088 Scalar temperature_(
const Problem& problem, [[maybe_unused]]
unsigned globalDofIdx)
const
1090 if constexpr (enableEnergy) {
1091 return (*
this)[Indices::temperatureIdx];
1093 else if constexpr (enableTemperature) {
1094 return problem.temperature(globalDofIdx, 0);
1097 return FluidSystem::reservoirTemperature();
1101 Scalar microbialConcentration_()
const
1103 if constexpr (enableMICP) {
1104 return (*
this)[Indices::microbialConcentrationIdx];
1111 Scalar oxygenConcentration_()
const
1113 if constexpr (enableMICP) {
1114 return (*
this)[Indices::oxygenConcentrationIdx];
1121 Scalar ureaConcentration_()
const
1123 if constexpr (enableMICP) {
1124 return (*
this)[Indices::ureaConcentrationIdx];
1131 Scalar biofilmConcentration_()
const
1133 if constexpr (enableMICP) {
1134 return (*
this)[Indices::biofilmConcentrationIdx];
1141 Scalar calciteConcentration_()
const
1143 if constexpr (enableMICP) {
1144 return (*
this)[Indices::calciteConcentrationIdx];
1151 template <
class Container>
1152 void computeCapillaryPressures_(Container& result,
1156 const MaterialLawParams& matParams)
const
1171 fluidState.setSaturation(waterPhaseIdx, sw);
1172 fluidState.setSaturation(oilPhaseIdx, so);
1173 fluidState.setSaturation(gasPhaseIdx, sg);
1175 MaterialLaw::capillaryPressures(result, matParams, fluidState);
1178 Scalar pressure_()
const
1179 {
return (*
this)[Indices::pressureSwitchIdx] * this->pressureScale_; }
1181 void setScaledPressure_(Scalar pressure)
1182 { (*this)[Indices::pressureSwitchIdx] = pressure / (this->pressureScale_); }
1189 unsigned short pvtRegionIdx_;
1191 static inline Scalar pressureScale_ = 1.0;
Contains the classes required to extend the black-oil model by brine.
Contains the classes required to extend the black-oil model by energy.
Contains the classes required to extend the black-oil model by solvent component. For details,...
Contains the classes required to extend the black-oil model to include the effects of foam.
Contains the classes required to extend the black-oil model by MICP.
Contains the classes required to extend the black-oil model by polymer.
Declares the properties required by the black oil model.
Contains the classes required to extend the black-oil model by solvents.
Contains the high level supplements required to extend the black oil model by brine.
Definition: blackoilbrinemodules.hh:55
static Scalar saltSol(unsigned regionIdx)
Definition: blackoilbrinemodules.hh:322
static const TabulatedFunction & pcfactTable(unsigned satnumRegionIdx)
Definition: blackoilbrinemodules.hh:276
static bool hasPcfactTables()
Definition: blackoilbrinemodules.hh:312
Contains the high level supplements required to extend the black oil model by energy.
Definition: blackoilenergymodules.hh:58
static void assignPrimaryVars(PrimaryVariables &priVars, const FluidState &fluidState)
Assign the energy specific primary variables to a PrimaryVariables object.
Definition: blackoilenergymodules.hh:263
Contains the high level supplements required to extend the black oil model.
Definition: blackoilextbomodules.hh:62
static Value rs(unsigned pvtRegionIdx, const Value &pressure, const Value &z)
Definition: blackoilextbomodules.hh:354
static Value rv(unsigned pvtRegionIdx, const Value &pressure, const Value &z)
Definition: blackoilextbomodules.hh:358
Contains the high level supplements required to extend the black oil model to include the effects of ...
Definition: blackoilfoammodules.hh:58
Contains the high level supplements required to extend the black oil model by MICP.
Definition: blackoilmicpmodules.hh:54
Contains the high level supplements required to extend the black oil model by polymer.
Definition: blackoilpolymermodules.hh:64
Represents the primary variables used by the black-oil model.
Definition: blackoilprimaryvariables.hh:72
bool operator==(const BlackOilPrimaryVariables &rhs) const
Definition: blackoilprimaryvariables.hh:1019
WaterMeaning
Definition: blackoilprimaryvariables.hh:135
unsigned pvtRegionIndex() const
Return the index of the region which should be used for PVT properties.
Definition: blackoilprimaryvariables.hh:241
BlackOilPrimaryVariables & operator=(const BlackOilPrimaryVariables &other)=default
SolventMeaning
Definition: blackoilprimaryvariables.hh:161
static void registerParameters()
Definition: blackoilprimaryvariables.hh:200
GasMeaning primaryVarsMeaningGas() const
Return the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:276
PressureMeaning primaryVarsMeaningPressure() const
Return the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:262
void serializeOp(Serializer &serializer)
Definition: blackoilprimaryvariables.hh:1007
static void init()
Definition: blackoilprimaryvariables.hh:194
void setPrimaryVarsMeaningSolvent(SolventMeaning newMeaning)
Set the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:303
BlackOilPrimaryVariables()
Definition: blackoilprimaryvariables.hh:167
static BlackOilPrimaryVariables serializationTestObject()
Definition: blackoilprimaryvariables.hh:178
SolventMeaning primaryVarsMeaningSolvent() const
Definition: blackoilprimaryvariables.hh:296
bool chopAndNormalizeSaturations()
Definition: blackoilprimaryvariables.hh:932
bool adaptPrimaryVariables(const Problem &problem, unsigned globalDofIdx, Scalar swMaximum, Scalar thresholdWaterFilledCell, Scalar eps=0.0)
Adapt the interpretation of the switching variables to be physically meaningful.
Definition: blackoilprimaryvariables.hh:564
void setPrimaryVarsMeaningPressure(PressureMeaning newMeaning)
Set the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:269
WaterMeaning primaryVarsMeaningWater() const
Return the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:248
void setPrimaryVarsMeaningWater(WaterMeaning newMeaning)
Set the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:255
void assignNaive(const FluidState &fluidState)
Directly retrieve the primary variables from an arbitrary fluid state.
Definition: blackoilprimaryvariables.hh:393
Evaluation makeEvaluation(unsigned varIdx, unsigned timeIdx, LinearizationType linearizationType=LinearizationType()) const
Definition: blackoilprimaryvariables.hh:210
void assignMassConservative(const FluidState &fluidState, const MaterialLawParams &matParams, bool isInEquilibrium=false)
< Import base class assignment operators.
Definition: blackoilprimaryvariables.hh:310
BrineMeaning
Definition: blackoilprimaryvariables.hh:155
void setPrimaryVarsMeaningBrine(BrineMeaning newMeaning)
Set the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:293
BlackOilPrimaryVariables(const BlackOilPrimaryVariables &value)=default
Copy constructor.
BrineMeaning primaryVarsMeaningBrine() const
Definition: blackoilprimaryvariables.hh:286
void setPressureScale(Scalar val)
Definition: blackoilprimaryvariables.hh:206
void setPrimaryVarsMeaningGas(GasMeaning newMeaning)
Set the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:283
PressureMeaning
Definition: blackoilprimaryvariables.hh:142
void setPvtRegionIndex(unsigned value)
Set the index of the region which should be used for PVT properties.
Definition: blackoilprimaryvariables.hh:235
void checkDefined() const
< Import base class assignment operators.
Definition: blackoilprimaryvariables.hh:987
GasMeaning
Definition: blackoilprimaryvariables.hh:148
Contains the high level supplements required to extend the black oil model by solvents.
Definition: blackoilsolventmodules.hh:66
static bool isSolubleInWater()
Definition: blackoilsolventmodules.hh:508
static Value solubilityLimit(unsigned pvtIdx, const Value &temperature, const Value &pressure, const Value &saltConcentration)
Definition: blackoilsolventmodules.hh:490
Represents the primary variables used by the a model.
Definition: fvbaseprimaryvariables.hh:53
SimpleModularFluidState< double, 3, 3, FluidSystemSimple, false, false, false, false, true, false, false, false > SatOnlyFluidState
Definition: EquilibrationHelpers_impl.hpp:53
Definition: blackoilnewtonmethodparams.hpp:31
Definition: blackoilboundaryratevector.hh:39
typename Properties::Detail::GetPropImpl< TypeTag, Property >::type::type GetPropType
get the type alias defined in the property (equivalent to old macro GET_PROP_TYPE(....
Definition: propertysystem.hh:233
Definition: linearizationtype.hh:34
Definition: blackoilprimaryvariables.hh:59
static constexpr Scalar value
Definition: blackoilprimaryvariables.hh:59