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/fluidsystems/BlackOilFluidSystem.hpp>
32#include <opm/material/fluidstates/SimpleModularFluidState.hpp>
54{
static constexpr Scalar
value = 1.0; };
65template <
class TypeTag>
80 enum { numEq = getPropValue<TypeTag, Properties::NumEq>() };
83 enum { waterSwitchIdx = Indices::waterSwitchIdx };
84 enum { pressureSwitchIdx = Indices::pressureSwitchIdx };
85 enum { compositionSwitchIdx = Indices::compositionSwitchIdx };
86 enum { saltConcentrationIdx = Indices::saltConcentrationIdx };
87 enum { solventSaturationIdx = Indices::solventSaturationIdx };
89 static constexpr bool compositionSwitchEnabled = Indices::compositionSwitchIdx >= 0;
90 static constexpr bool waterEnabled = Indices::waterEnabled;
91 static constexpr bool gasEnabled = Indices::gasEnabled;
92 static constexpr bool oilEnabled = Indices::oilEnabled;
95 enum { numPhases = getPropValue<TypeTag, Properties::NumPhases>() };
96 enum { gasPhaseIdx = FluidSystem::gasPhaseIdx };
97 enum { waterPhaseIdx = FluidSystem::waterPhaseIdx };
98 enum { oilPhaseIdx = FluidSystem::oilPhaseIdx };
101 enum { numComponents = getPropValue<TypeTag, Properties::NumComponents>() };
102 enum { enableSolvent = getPropValue<TypeTag, Properties::EnableSolvent>() };
103 enum { enableExtbo = getPropValue<TypeTag, Properties::EnableExtbo>() };
104 enum { enablePolymer = getPropValue<TypeTag, Properties::EnablePolymer>() };
105 enum { enableFoam = getPropValue<TypeTag, Properties::EnableFoam>() };
106 enum { enableBrine = getPropValue<TypeTag, Properties::EnableBrine>() };
107 enum { enableSaltPrecipitation = getPropValue<TypeTag, Properties::EnableSaltPrecipitation>() };
108 enum { enableVapwat = getPropValue<TypeTag, Properties::EnableVapwat>() };
109 enum { enableEnergy = getPropValue<TypeTag, Properties::EnableEnergy>() };
110 enum { enableTemperature = getPropValue<TypeTag, Properties::EnableTemperature>() };
111 enum { enableMICP = getPropValue<TypeTag, Properties::EnableMICP>() };
112 enum { gasCompIdx = FluidSystem::gasCompIdx };
113 enum { waterCompIdx = FluidSystem::waterCompIdx };
114 enum { oilCompIdx = FluidSystem::oilCompIdx };
116 using Toolbox = MathToolbox<Evaluation>;
117 using ComponentVector = Dune::FieldVector<Scalar, numComponents>;
123 static_assert(numPhases == 3,
"The black-oil model assumes three phases!");
124 static_assert(numComponents == 3,
"The black-oil model assumes three components!");
161 Valgrind::SetUndefined(*
this);
173 result.pvtRegionIdx_ = 1;
179 for (std::size_t i = 0; i < result.size(); ++i) {
189 pressureScale_ = Parameters::Get<Parameters::PressureScale<Scalar>>();
194 Parameters::Register<Parameters::PressureScale<Scalar>>
195 (
"Scaling of pressure primary variable");
199 { pressureScale_ = val; }
205 const Scalar scale = varIdx == pressureSwitchIdx ? this->pressureScale_ : Scalar{1.0};
206 if (std::is_same_v<Evaluation, Scalar>) {
207 return (*
this)[varIdx] * scale;
211 if (timeIdx == linearizationType.time) {
212 return Toolbox::createVariable((*
this)[varIdx], varIdx) * scale;
215 return Toolbox::createConstant((*
this)[varIdx]) * scale;
228 { pvtRegionIdx_ =
static_cast<unsigned short>(value); }
234 {
return pvtRegionIdx_; }
241 {
return primaryVarsMeaningWater_; }
248 { primaryVarsMeaningWater_ = newMeaning; }
255 {
return primaryVarsMeaningPressure_; }
262 { primaryVarsMeaningPressure_ = newMeaning; }
269 {
return primaryVarsMeaningGas_; }
276 { primaryVarsMeaningGas_ = newMeaning; }
279 {
return primaryVarsMeaningBrine_; }
286 { primaryVarsMeaningBrine_ = newMeaning; }
289 {
return primaryVarsMeaningSolvent_; }
296 { primaryVarsMeaningSolvent_ = newMeaning; }
301 template <
class Flu
idState>
304 using ConstEvaluation = std::remove_reference_t<typename FluidState::Scalar>;
305 using FsEvaluation = std::remove_const_t<ConstEvaluation>;
306 using FsToolbox = MathToolbox<FsEvaluation>;
308 const bool gasPresent =
309 FluidSystem::phaseIsActive(gasPhaseIdx)
310 ? fluidState.saturation(gasPhaseIdx) > 0.0
312 const bool oilPresent =
313 FluidSystem::phaseIsActive(oilPhaseIdx)
314 ? fluidState.saturation(oilPhaseIdx) > 0.0
316 const bool waterPresent =
317 FluidSystem::phaseIsActive(waterPhaseIdx)
318 ? fluidState.saturation(waterPhaseIdx) > 0.0
320 const auto& saltSaturation =
321 BlackOil::getSaltSaturation_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
322 const bool precipitatedSaltPresent = enableSaltPrecipitation ? saltSaturation > 0.0 :
false;
323 const bool oneActivePhases = FluidSystem::numActivePhases() == 1;
330 if (gasPresent && FluidSystem::enableVaporizedOil() && !oilPresent) {
333 else if (FluidSystem::phaseIsActive(oilPhaseIdx)) {
336 else if (waterPresent && FluidSystem::enableDissolvedGasInWater() && !gasPresent) {
339 else if (FluidSystem::phaseIsActive(gasPhaseIdx)) {
343 assert(FluidSystem::phaseIsActive(waterPhaseIdx));
351 if (waterPresent && gasPresent) {
354 else if (gasPresent && FluidSystem::enableVaporizedWater()) {
357 else if (waterPresent && FluidSystem::enableDissolvedGasInWater()) {
360 else if (FluidSystem::phaseIsActive(waterPhaseIdx) && !oneActivePhases) {
372 if (gasPresent && oilPresent) {
375 else if (oilPresent && FluidSystem::enableDissolvedGas()) {
378 else if (gasPresent && FluidSystem::enableVaporizedOil()) {
381 else if (FluidSystem::phaseIsActive(gasPhaseIdx) && FluidSystem::phaseIsActive(oilPhaseIdx)) {
389 if constexpr (enableSaltPrecipitation) {
390 if (precipitatedSaltPresent) {
404 this->setScaledPressure_(FsToolbox::value(fluidState.pressure(oilPhaseIdx)));
407 this->setScaledPressure_(FsToolbox::value(fluidState.pressure(gasPhaseIdx)));
410 this->setScaledPressure_(FsToolbox::value(fluidState.pressure(waterPhaseIdx)));
413 throw std::logic_error(
"No valid primary variable selected for pressure");
419 (*this)[waterSwitchIdx] = FsToolbox::value(fluidState.saturation(waterPhaseIdx));
424 const auto& rvw = BlackOil::getRvw_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
425 (*this)[waterSwitchIdx] = rvw;
430 const auto& Rsw = BlackOil::getRsw_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
431 (*this)[waterSwitchIdx] = Rsw;
437 throw std::logic_error(
"No valid primary variable selected for water");
441 (*this)[compositionSwitchIdx] = FsToolbox::value(fluidState.saturation(gasPhaseIdx));
445 const auto& rs = BlackOil::getRs_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
446 (*this)[compositionSwitchIdx] = rs;
451 const auto& rv = BlackOil::getRv_<FluidSystem, FluidState, Scalar>(fluidState, pvtRegionIdx_);
452 (*this)[compositionSwitchIdx] = rv;
458 throw std::logic_error(
"No valid primary variable selected for composision");
474 unsigned globalDofIdx,
475 [[maybe_unused]] Scalar swMaximum,
476 Scalar thresholdWaterFilledCell, Scalar eps = 0.0)
495 Scalar saltConcentration = 0.0;
496 const Scalar& T = asImp_().temperature_(problem, globalDofIdx);
498 sw = (*this)[waterSwitchIdx];
501 sg = (*this)[compositionSwitchIdx];
513 if constexpr (enableSaltPrecipitation) {
516 saltConcentration = saltSolubility;
517 const Scalar saltSat = (*this)[saltConcentrationIdx];
518 if (saltSat < -eps) {
520 (*this)[saltConcentrationIdx] = saltSolubility;
524 saltConcentration = (*this)[saltConcentrationIdx];
525 if (saltConcentration > saltSolubility + eps) {
527 (*this)[saltConcentrationIdx] = 0.0;
535 if constexpr (enableSolvent) {
537 const Scalar p = (*this)[pressureSwitchIdx];
538 const Scalar solLimit =
541 const Scalar solSat = (*this)[solventSaturationIdx];
544 (*this)[solventSaturationIdx] = solLimit;
548 const Scalar rsolw = (*this)[solventSaturationIdx];
549 if (rsolw > solLimit + eps) {
551 (*this)[solventSaturationIdx] = 0.0;
558 bool changed =
false;
566 if (sw >= thresholdWaterFilledCell && !FluidSystem::enableDissolvedGasInWater()) {
568 if constexpr (waterEnabled) {
569 (*this)[Indices::waterSwitchIdx] = std::min(swMaximum, sw);
573 if constexpr (compositionSwitchEnabled) {
574 (*this)[Indices::compositionSwitchIdx] = 0.0;
579 if constexpr (compositionSwitchEnabled) {
589 const unsigned satnumRegionIdx = problem.satnumRegionIndex(globalDofIdx);
590 const Scalar Sp = saltConcentration_();
591 const Scalar porosityFactor = std::min(1.0 - Sp, 1.0);
593 pcFactor_ = pcfactTable.eval(porosityFactor,
true);
603 if (sw < -eps && sg > eps && FluidSystem::enableVaporizedWater()) {
604 Scalar p = this->pressure_();
606 std::array<Scalar, numPhases> pC{};
607 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
608 const Scalar so = 1.0 - sg - solventSaturation_();
609 computeCapillaryPressures_(pC, so, sg + solventSaturation_(), 0.0, matParams);
610 p += pcFactor_ * (pC[gasPhaseIdx] - pC[oilPhaseIdx]);
612 const Scalar rvwSat =
613 FluidSystem::gasPvt().saturatedWaterVaporizationFactor(pvtRegionIdx_,
618 (*this)[Indices::waterSwitchIdx] = rvwSat;
624 if (sg < -eps && sw > eps && FluidSystem::enableDissolvedGasInWater()) {
625 const Scalar pg = this->pressure_();
627 std::array<Scalar, numPhases> pC = { 0.0 };
628 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
629 const Scalar so = 1.0 - sw - solventSaturation_();
630 computeCapillaryPressures_(pC, so, 0.0, sw, matParams);
631 const Scalar pw = pg + pcFactor_ * (pC[waterPhaseIdx] - pC[gasPhaseIdx]);
632 const Scalar rswSat =
633 FluidSystem::waterPvt().saturatedGasDissolutionFactor(pvtRegionIdx_,
638 const Scalar rswMax = problem.maxGasDissolutionFactor(0, globalDofIdx);
639 (*this)[Indices::waterSwitchIdx] = std::min(rswSat, rswMax);
641 this->setScaledPressure_(pw);
649 const Scalar& rvw = (*this)[waterSwitchIdx];
650 Scalar p = this->pressure_();
652 std::array<Scalar, numPhases> pC{};
653 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
654 const Scalar so = 1.0 - sg - solventSaturation_();
655 computeCapillaryPressures_(pC, so, sg + solventSaturation_(), 0.0, matParams);
656 p += pcFactor_ * (pC[gasPhaseIdx] - pC[oilPhaseIdx]);
658 const Scalar rvwSat =
659 FluidSystem::gasPvt().saturatedWaterVaporizationFactor(pvtRegionIdx_,
664 if (rvw > rvwSat * (1.0 + eps)) {
666 (*this)[Indices::waterSwitchIdx] = 0.0;
676 const Scalar& pw = this->pressure_();
678 const Scalar rswSat =
679 FluidSystem::waterPvt().saturatedGasDissolutionFactor(pvtRegionIdx_,
684 const Scalar rsw = (*this)[Indices::waterSwitchIdx];
685 const Scalar rswMax = problem.maxGasDissolutionFactor(0, globalDofIdx);
686 if (rsw > std::min(rswSat, rswMax)) {
689 (*this)[Indices::waterSwitchIdx] = 1.0;
691 std::array<Scalar, numPhases> pC{};
692 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
693 computeCapillaryPressures_(pC, 0.0, 0.0, 1.0, matParams);
694 const Scalar pg = pw + pcFactor_ * (pC[gasPhaseIdx] - pC[waterPhaseIdx]);
695 this->setScaledPressure_(pg);
703 throw std::logic_error(
"No valid primary variable selected for water");
716 const Scalar s = 1.0 - sw - solventSaturation_();
717 if (sg < -eps && s > 0.0 && FluidSystem::enableDissolvedGas()) {
718 const Scalar po = this->pressure_();
720 const Scalar soMax = std::max(s, problem.maxOilSaturation(globalDofIdx));
721 const Scalar rsMax = problem.maxGasDissolutionFactor(0, globalDofIdx);
725 : FluidSystem::oilPvt().saturatedGasDissolutionFactor(pvtRegionIdx_,
730 (*this)[Indices::compositionSwitchIdx] = std::min(rsMax, rsSat);
733 const Scalar so = 1.0 - sw - solventSaturation_() - sg;
734 if (so < -eps && sg > 0.0 && FluidSystem::enableVaporizedOil()) {
739 const Scalar po = this->pressure_();
740 std::array<Scalar, numPhases> pC{};
741 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
742 computeCapillaryPressures_(pC, 0.0, sg + solventSaturation_(), sw, matParams);
743 const Scalar pg = po + pcFactor_ * (pC[gasPhaseIdx] - pC[oilPhaseIdx]);
748 this->setScaledPressure_(pg);
749 const Scalar soMax = problem.maxOilSaturation(globalDofIdx);
750 const Scalar rvMax = problem.maxOilVaporizationFactor(0, globalDofIdx);
754 : FluidSystem::gasPvt().saturatedOilVaporizationFactor(pvtRegionIdx_,
760 (*this)[Indices::compositionSwitchIdx] = std::min(rvMax, rvSat);
770 const Scalar po = this->pressure_();
771 const Scalar so = 1.0 - sw - solventSaturation_();
772 const Scalar soMax = std::max(so, problem.maxOilSaturation(globalDofIdx));
773 const Scalar rsMax = problem.maxGasDissolutionFactor(0, globalDofIdx);
777 : FluidSystem::oilPvt().saturatedGasDissolutionFactor(pvtRegionIdx_,
783 const Scalar rs = (*this)[Indices::compositionSwitchIdx];
784 if (rs > std::min(rsMax, rsSat * (Scalar{1.0} + eps))) {
787 (*this)[Indices::compositionSwitchIdx] = 0.0;
798 const Scalar pg = this->pressure_();
799 const Scalar soMax = problem.maxOilSaturation(globalDofIdx);
800 const Scalar rvMax = problem.maxOilVaporizationFactor(0, globalDofIdx);
804 : FluidSystem::gasPvt().saturatedOilVaporizationFactor(pvtRegionIdx_,
810 const Scalar rv = (*this)[Indices::compositionSwitchIdx];
811 if (rv > std::min(rvMax, rvSat * (Scalar{1.0} + eps))) {
815 const Scalar sg2 = 1.0 - sw - solventSaturation_();
816 std::array<Scalar, numPhases> pC{};
817 const MaterialLawParams& matParams = problem.materialLawParams(globalDofIdx);
818 computeCapillaryPressures_(pC,
820 sg2 + solventSaturation_(),
823 const Scalar po = pg + pcFactor_ * (pC[oilPhaseIdx] - pC[gasPhaseIdx]);
827 this->setScaledPressure_(po);
828 (*this)[Indices::compositionSwitchIdx] = sg2;
836 throw std::logic_error(
"No valid primary variable selected for water");
850 sw = (*this)[Indices::waterSwitchIdx];
854 sg = (*this)[Indices::compositionSwitchIdx];
859 ssol =(*this) [Indices::solventSaturationIdx];
862 Scalar so = 1.0 - sw - sg - ssol;
863 sw = std::min(std::max(sw, Scalar{0.0}), Scalar{1.0});
864 so = std::min(std::max(so, Scalar{0.0}), Scalar{1.0});
865 sg = std::min(std::max(sg, Scalar{0.0}), Scalar{1.0});
866 ssol = std::min(std::max(ssol, Scalar{0.0}), Scalar{1.0});
867 const Scalar st = sw + so + sg + ssol;
873 (*this)[Indices::waterSwitchIdx] = sw;
876 (*this)[Indices::compositionSwitchIdx] = sg;
879 (*this) [Indices::solventSaturationIdx] = ssol;
887 using ParentType::operator=;
900 for (
unsigned i = 0; i < this->size(); ++i) {
901 Valgrind::CheckDefined((*
this)[i]);
905 Valgrind::CheckDefined(primaryVarsMeaningWater_);
906 Valgrind::CheckDefined(primaryVarsMeaningGas_);
907 Valgrind::CheckDefined(primaryVarsMeaningPressure_);
908 Valgrind::CheckDefined(primaryVarsMeaningBrine_);
909 Valgrind::CheckDefined(primaryVarsMeaningSolvent_);
911 Valgrind::CheckDefined(pvtRegionIdx_);
915 template<
class Serializer>
918 using FV = Dune::FieldVector<Scalar, getPropValue<TypeTag, Properties::NumEq>()>;
919 serializer(
static_cast<FV&
>(*
this));
920 serializer(primaryVarsMeaningWater_);
921 serializer(primaryVarsMeaningPressure_);
922 serializer(primaryVarsMeaningGas_);
923 serializer(primaryVarsMeaningBrine_);
924 serializer(primaryVarsMeaningSolvent_);
925 serializer(pvtRegionIdx_);
932 && this->primaryVarsMeaningWater_ == rhs.primaryVarsMeaningWater_
933 && this->primaryVarsMeaningPressure_ == rhs.primaryVarsMeaningPressure_
934 && this->primaryVarsMeaningGas_ == rhs.primaryVarsMeaningGas_
935 && this->primaryVarsMeaningBrine_ == rhs.primaryVarsMeaningBrine_
936 && this->primaryVarsMeaningSolvent_ == rhs.primaryVarsMeaningSolvent_
937 && this->pvtRegionIdx_ == rhs.pvtRegionIdx_;
941 Implementation& asImp_()
942 {
return *
static_cast<Implementation*
>(
this); }
944 const Implementation& asImp_()
const
945 {
return *
static_cast<const Implementation*
>(
this); }
947 Scalar solventSaturation_()
const
949 if constexpr (enableSolvent) {
951 return (*
this)[Indices::solventSaturationIdx];
957 Scalar zFraction_()
const
959 if constexpr (enableExtbo) {
960 return (*
this)[Indices::zFractionIdx];
967 Scalar saltConcentration_()
const
969 if constexpr (enableBrine) {
970 return (*
this)[Indices::saltConcentrationIdx];
977 Scalar temperature_(
const Problem& problem, [[maybe_unused]]
unsigned globalDofIdx)
const
979 if constexpr (enableEnergy) {
980 return (*
this)[Indices::temperatureIdx];
982 else if constexpr (enableTemperature) {
983 return problem.temperature(globalDofIdx, 0);
986 return FluidSystem::reservoirTemperature();
990 template <
class Container>
991 void computeCapillaryPressures_(Container& result,
995 const MaterialLawParams& matParams)
const
1010 fluidState.setSaturation(waterPhaseIdx, sw);
1011 fluidState.setSaturation(oilPhaseIdx, so);
1012 fluidState.setSaturation(gasPhaseIdx, sg);
1014 MaterialLaw::capillaryPressures(result, matParams, fluidState);
1017 Scalar pressure_()
const
1018 {
return (*
this)[Indices::pressureSwitchIdx] * this->pressureScale_; }
1020 void setScaledPressure_(Scalar pressure)
1021 { (*this)[Indices::pressureSwitchIdx] = pressure / (this->pressureScale_); }
1028 unsigned short pvtRegionIdx_;
1030 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,...
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:56
static Scalar saltSol(unsigned regionIdx)
Definition: blackoilbrinemodules.hh:333
static const TabulatedFunction & pcfactTable(unsigned satnumRegionIdx)
Definition: blackoilbrinemodules.hh:277
static bool hasPcfactTables()
Definition: blackoilbrinemodules.hh:323
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
Represents the primary variables used by the black-oil model.
Definition: blackoilprimaryvariables.hh:67
bool operator==(const BlackOilPrimaryVariables &rhs) const
Definition: blackoilprimaryvariables.hh:928
WaterMeaning
Definition: blackoilprimaryvariables.hh:127
unsigned pvtRegionIndex() const
Return the index of the region which should be used for PVT properties.
Definition: blackoilprimaryvariables.hh:233
BlackOilPrimaryVariables & operator=(const BlackOilPrimaryVariables &other)=default
SolventMeaning
Definition: blackoilprimaryvariables.hh:153
static void registerParameters()
Definition: blackoilprimaryvariables.hh:192
GasMeaning primaryVarsMeaningGas() const
Return the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:268
PressureMeaning primaryVarsMeaningPressure() const
Return the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:254
void serializeOp(Serializer &serializer)
Definition: blackoilprimaryvariables.hh:916
static void init()
Definition: blackoilprimaryvariables.hh:186
void setPrimaryVarsMeaningSolvent(SolventMeaning newMeaning)
Set the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:295
BlackOilPrimaryVariables()
Definition: blackoilprimaryvariables.hh:159
static BlackOilPrimaryVariables serializationTestObject()
Definition: blackoilprimaryvariables.hh:170
SolventMeaning primaryVarsMeaningSolvent() const
Definition: blackoilprimaryvariables.hh:288
bool chopAndNormalizeSaturations()
Definition: blackoilprimaryvariables.hh:841
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:473
void setPrimaryVarsMeaningPressure(PressureMeaning newMeaning)
Set the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:261
WaterMeaning primaryVarsMeaningWater() const
Return the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:240
void setPrimaryVarsMeaningWater(WaterMeaning newMeaning)
Set the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:247
void assignNaive(const FluidState &fluidState)
Directly retrieve the primary variables from an arbitrary fluid state.
Definition: blackoilprimaryvariables.hh:302
Evaluation makeEvaluation(unsigned varIdx, unsigned timeIdx, LinearizationType linearizationType=LinearizationType()) const
Definition: blackoilprimaryvariables.hh:202
BrineMeaning
Definition: blackoilprimaryvariables.hh:147
void setPrimaryVarsMeaningBrine(BrineMeaning newMeaning)
Set the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:285
BlackOilPrimaryVariables(const BlackOilPrimaryVariables &value)=default
Copy constructor.
BrineMeaning primaryVarsMeaningBrine() const
Definition: blackoilprimaryvariables.hh:278
void setPressureScale(Scalar val)
Definition: blackoilprimaryvariables.hh:198
void setPrimaryVarsMeaningGas(GasMeaning newMeaning)
Set the interpretation which should be applied to the switching primary variables.
Definition: blackoilprimaryvariables.hh:275
PressureMeaning
Definition: blackoilprimaryvariables.hh:134
void setPvtRegionIndex(unsigned value)
Set the index of the region which should be used for PVT properties.
Definition: blackoilprimaryvariables.hh:227
void checkDefined() const
< Import base class assignment operators.
Definition: blackoilprimaryvariables.hh:896
GasMeaning
Definition: blackoilprimaryvariables.hh:140
Contains the high level supplements required to extend the black oil model by solvents.
Definition: blackoilsolventmodules.hh:68
static bool isSolubleInWater()
Definition: blackoilsolventmodules.hh:523
static Value solubilityLimit(unsigned pvtIdx, const Value &temperature, const Value &pressure, const Value &saltConcentration)
Definition: blackoilsolventmodules.hh:505
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:54
static constexpr Scalar value
Definition: blackoilprimaryvariables.hh:54