27#ifndef OPM_WET_HUMID_GAS_PVT_HPP
28#define OPM_WET_HUMID_GAS_PVT_HPP
35#include <opm/input/eclipse/EclipseState/EclipseState.hpp>
36#include <opm/input/eclipse/EclipseState/Tables/TableManager.hpp>
41#include <opm/common/OpmLog/OpmLog.hpp>
50template <
class Scalar>
53 using SamplingPoints = std::vector<std::pair<Scalar, Scalar>>;
67 const std::vector<TabulatedTwoDFunction>& inverseGasBRvwSat,
68 const std::vector<TabulatedTwoDFunction>& inverseGasBRvSat,
70 const std::vector<TabulatedTwoDFunction>& gasMuRvwSat,
71 const std::vector<TabulatedTwoDFunction>& gasMuRvSat,
72 const std::vector<TabulatedTwoDFunction>& inverseGasBMuRvwSat,
73 const std::vector<TabulatedTwoDFunction>& inverseGasBMuRvSat,
83 , inverseGasBRvwSat_(inverseGasBRvwSat)
84 , inverseGasBRvSat_(inverseGasBRvSat)
86 , gasMuRvwSat_(gasMuRvwSat)
87 , gasMuRvSat_(gasMuRvSat)
88 , inverseGasBMuRvwSat_(inverseGasBMuRvwSat)
89 , inverseGasBMuRvSat_(inverseGasBMuRvSat)
106 void initFromState(
const EclipseState& eclState,
const Schedule& schedule)
108 const auto& pvtgwTables = eclState.getTableManager().getPvtgwTables();
109 const auto& pvtgTables = eclState.getTableManager().getPvtgTables();
110 const auto& densityTable = eclState.getTableManager().getDensityTable();
112 assert(pvtgwTables.size() == densityTable.size());
113 assert(pvtgTables.size() == densityTable.size());
118 for (
unsigned regionIdx = 0; regionIdx <
numRegions; ++ regionIdx) {
119 Scalar rhoRefO = densityTable[regionIdx].oil;
120 Scalar rhoRefG = densityTable[regionIdx].gas;
121 Scalar rhoRefW = densityTable[regionIdx].water;
126 enableRwgSalt_ = !eclState.getTableManager().getRwgSaltTables().empty();
129 const auto& rwgsaltTables = eclState.getTableManager().getRwgSaltTables();
131 for (
unsigned regionIdx = 0; regionIdx <
numRegions; ++ regionIdx) {
132 const auto& rwgsaltTable = rwgsaltTables[regionIdx];
133 const auto& saturatedTable = rwgsaltTable.getSaturatedTable();
134 assert(saturatedTable.numRows() > 1);
136 auto& waterVaporizationFac = saturatedWaterVaporizationSaltFactorTable_[regionIdx];
137 for (
unsigned outerIdx = 0; outerIdx < saturatedTable.numRows(); ++ outerIdx) {
138 const auto& underSaturatedTable = rwgsaltTable.getUnderSaturatedTable(outerIdx);
139 Scalar pg = saturatedTable.get(
"PG" , outerIdx);
140 waterVaporizationFac.appendXPos(pg);
142 size_t numRows = underSaturatedTable.numRows();
143 for (
size_t innerIdx = 0; innerIdx < numRows; ++ innerIdx) {
144 Scalar saltConcentration = underSaturatedTable.get(
"C_SALT" , innerIdx);
145 Scalar rvwSat= underSaturatedTable.get(
"RVW" , innerIdx);
147 waterVaporizationFac.appendSamplePoint(outerIdx, saltConcentration, rvwSat);
154 for (
unsigned regionIdx = 0; regionIdx <
numRegions; ++ regionIdx) {
155 const auto& pvtgwTable = pvtgwTables[regionIdx];
157 const auto& saturatedTable = pvtgwTable.getSaturatedTable();
158 assert(saturatedTable.numRows() > 1);
161 auto& gasMuRvSat = gasMuRvSat_[regionIdx];
162 auto& invGasBRvSat = inverseGasBRvSat_[regionIdx];
163 auto& invSatGasB = inverseSaturatedGasB_[regionIdx];
164 auto& invSatGasBMu = inverseSaturatedGasBMu_[regionIdx];
165 auto& waterVaporizationFac = saturatedWaterVaporizationFactorTable_[regionIdx];
167 waterVaporizationFac.setXYArrays(saturatedTable.numRows(),
168 saturatedTable.getColumn(
"PG"),
169 saturatedTable.getColumn(
"RW"));
171 std::vector<Scalar> invSatGasBArray;
172 std::vector<Scalar> invSatGasBMuArray;
175 for (
unsigned outerIdx = 0; outerIdx < saturatedTable.numRows(); ++ outerIdx) {
176 Scalar pg = saturatedTable.get(
"PG" , outerIdx);
177 Scalar B = saturatedTable.get(
"BG" , outerIdx);
178 Scalar mu = saturatedTable.get(
"MUG" , outerIdx);
180 invGasBRvSat.appendXPos(pg);
181 gasMuRvSat.appendXPos(pg);
183 invSatGasBArray.push_back(1.0/B);
184 invSatGasBMuArray.push_back(1.0/(mu*B));
186 assert(invGasBRvSat.numX() == outerIdx + 1);
187 assert(gasMuRvSat.numX() == outerIdx + 1);
189 const auto& underSaturatedTable = pvtgwTable.getUnderSaturatedTable(outerIdx);
190 size_t numRows = underSaturatedTable.numRows();
191 for (
size_t innerIdx = 0; innerIdx < numRows; ++ innerIdx) {
192 Scalar Rw = underSaturatedTable.get(
"RW" , innerIdx);
193 Scalar Bg = underSaturatedTable.get(
"BG" , innerIdx);
194 Scalar mug = underSaturatedTable.get(
"MUG" , innerIdx);
196 invGasBRvSat.appendSamplePoint(outerIdx, Rw, 1.0/Bg);
197 gasMuRvSat.appendSamplePoint(outerIdx, Rw, mug);
202 std::vector<double> tmpPressure = saturatedTable.getColumn(
"PG").vectorCopy( );
204 invSatGasB.setXYContainers(tmpPressure, invSatGasBArray);
205 invSatGasBMu.setXYContainers(tmpPressure, invSatGasBMuArray);
209 for (
unsigned xIdx = 0; xIdx < invGasBRvSat.numX(); ++xIdx) {
211 assert(invGasBRvSat.numY(xIdx) > 0);
215 if (invGasBRvSat.numY(xIdx) > 1)
221 size_t masterTableIdx = xIdx + 1;
222 for (; masterTableIdx < saturatedTable.numRows(); ++masterTableIdx)
224 if (pvtgwTable.getUnderSaturatedTable(masterTableIdx).numRows() > 1)
228 if (masterTableIdx >= saturatedTable.numRows())
229 throw std::runtime_error(
"PVTGW tables are invalid: The last table must exhibit at least one "
230 "entry for undersaturated gas!");
234 extendPvtgwTable_(regionIdx,
236 pvtgwTable.getUnderSaturatedTable(xIdx),
237 pvtgwTable.getUnderSaturatedTable(masterTableIdx));
242 for (
unsigned regionIdx = 0; regionIdx <
numRegions; ++ regionIdx) {
243 const auto& pvtgTable = pvtgTables[regionIdx];
245 const auto& saturatedTable = pvtgTable.getSaturatedTable();
246 assert(saturatedTable.numRows() > 1);
248 auto& gasMuRvwSat = gasMuRvwSat_[regionIdx];
249 auto& invGasBRvwSat = inverseGasBRvwSat_[regionIdx];
250 auto& invSatGasB = inverseSaturatedGasB_[regionIdx];
251 auto& invSatGasBMu = inverseSaturatedGasBMu_[regionIdx];
252 auto& oilVaporizationFac = saturatedOilVaporizationFactorTable_[regionIdx];
254 oilVaporizationFac.setXYArrays(saturatedTable.numRows(),
255 saturatedTable.getColumn(
"PG"),
256 saturatedTable.getColumn(
"RV"));
258 std::vector<Scalar> invSatGasBArray;
259 std::vector<Scalar> invSatGasBMuArray;
262 for (
unsigned outerIdx = 0; outerIdx < saturatedTable.numRows(); ++ outerIdx) {
263 Scalar pg = saturatedTable.get(
"PG" , outerIdx);
264 Scalar B = saturatedTable.get(
"BG" , outerIdx);
265 Scalar mu = saturatedTable.get(
"MUG" , outerIdx);
267 invGasBRvwSat.appendXPos(pg);
268 gasMuRvwSat.appendXPos(pg);
270 invSatGasBArray.push_back(1.0/B);
271 invSatGasBMuArray.push_back(1.0/(mu*B));
273 assert(invGasBRvwSat.numX() == outerIdx + 1);
274 assert(gasMuRvwSat.numX() == outerIdx + 1);
276 const auto& underSaturatedTable = pvtgTable.getUnderSaturatedTable(outerIdx);
277 size_t numRows = underSaturatedTable.numRows();
278 for (
size_t innerIdx = 0; innerIdx < numRows; ++ innerIdx) {
279 Scalar Rv = underSaturatedTable.get(
"RV" , innerIdx);
280 Scalar Bg = underSaturatedTable.get(
"BG" , innerIdx);
281 Scalar mug = underSaturatedTable.get(
"MUG" , innerIdx);
283 invGasBRvwSat.appendSamplePoint(outerIdx, Rv, 1.0/Bg);
284 gasMuRvwSat.appendSamplePoint(outerIdx, Rv, mug);
289 std::vector<double> tmpPressure = saturatedTable.getColumn(
"PG").vectorCopy( );
291 invSatGasB.setXYContainers(tmpPressure, invSatGasBArray);
292 invSatGasBMu.setXYContainers(tmpPressure, invSatGasBMuArray);
296 for (
unsigned xIdx = 0; xIdx < invGasBRvwSat.numX(); ++xIdx) {
298 assert(invGasBRvwSat.numY(xIdx) > 0);
302 if (invGasBRvwSat.numY(xIdx) > 1)
308 size_t masterTableIdx = xIdx + 1;
309 for (; masterTableIdx < saturatedTable.numRows(); ++masterTableIdx)
311 if (pvtgTable.getUnderSaturatedTable(masterTableIdx).numRows() > 1)
315 if (masterTableIdx >= saturatedTable.numRows())
316 throw std::runtime_error(
"PVTG tables are invalid: The last table must exhibit at least one "
317 "entry for undersaturated gas!");
321 extendPvtgTable_(regionIdx,
323 pvtgTable.getUnderSaturatedTable(xIdx),
324 pvtgTable.getUnderSaturatedTable(masterTableIdx));
328 const auto& oilVap = schedule[0].oilvap();
329 if (oilVap.getType() == OilVaporizationProperties::OilVaporization::VAPPARS) {
330 vapPar1_ = oilVap.vap1();
337 void extendPvtgwTable_(
unsigned regionIdx,
339 const SimpleTable& curTable,
340 const SimpleTable& masterTable)
342 std::vector<double> RvArray = curTable.getColumn(
"RW").vectorCopy();
343 std::vector<double> gasBArray = curTable.getColumn(
"BG").vectorCopy();
344 std::vector<double> gasMuArray = curTable.getColumn(
"MUG").vectorCopy();
346 auto& invGasBRvSat = inverseGasBRvSat_[regionIdx];
347 auto& gasMuRvSat = gasMuRvSat_[regionIdx];
349 for (
size_t newRowIdx = 1; newRowIdx < masterTable.numRows(); ++ newRowIdx) {
350 const auto& RVColumn = masterTable.getColumn(
"RW");
351 const auto& BGColumn = masterTable.getColumn(
"BG");
352 const auto& viscosityColumn = masterTable.getColumn(
"MUG");
355 Scalar diffRv = RVColumn[newRowIdx] - RVColumn[newRowIdx - 1];
356 Scalar newRv = RvArray.back() + diffRv;
359 Scalar B1 = BGColumn[newRowIdx];
360 Scalar B2 = BGColumn[newRowIdx - 1];
361 Scalar x = (B1 - B2)/( (B1 + B2)/2.0 );
365 Scalar newBg = gasBArray.back()*(1.0 + x/2.0)/(1.0 - x/2.0);
368 Scalar mu1 = viscosityColumn[newRowIdx];
369 Scalar mu2 = viscosityColumn[newRowIdx - 1];
370 Scalar xMu = (mu1 - mu2)/( (mu1 + mu2)/2.0 );
374 Scalar newMug = gasMuArray.back()*(1.0 + xMu/2)/(1.0 - xMu/2.0);
378 RvArray.push_back(newRv);
379 gasBArray.push_back(newBg);
380 gasMuArray.push_back(newMug);
383 invGasBRvSat.appendSamplePoint(xIdx, newRv, 1.0/newBg);
384 gasMuRvSat.appendSamplePoint(xIdx, newRv, newMug);
387 void extendPvtgTable_(
unsigned regionIdx,
389 const SimpleTable& curTable,
390 const SimpleTable& masterTable)
392 std::vector<double> RvArray = curTable.getColumn(
"RV").vectorCopy();
393 std::vector<double> gasBArray = curTable.getColumn(
"BG").vectorCopy();
394 std::vector<double> gasMuArray = curTable.getColumn(
"MUG").vectorCopy();
396 auto& invGasBRvwSat= inverseGasBRvwSat_[regionIdx];
397 auto& gasMuRvwSat = gasMuRvwSat_[regionIdx];
399 for (
size_t newRowIdx = 1; newRowIdx < masterTable.numRows(); ++ newRowIdx) {
400 const auto& RVColumn = masterTable.getColumn(
"RV");
401 const auto& BGColumn = masterTable.getColumn(
"BG");
402 const auto& viscosityColumn = masterTable.getColumn(
"MUG");
405 Scalar diffRv = RVColumn[newRowIdx] - RVColumn[newRowIdx - 1];
406 Scalar newRv = RvArray.back() + diffRv;
409 Scalar B1 = BGColumn[newRowIdx];
410 Scalar B2 = BGColumn[newRowIdx - 1];
411 Scalar x = (B1 - B2)/( (B1 + B2)/2.0 );
415 Scalar newBg = gasBArray.back()*(1.0 + x/2.0)/(1.0 - x/2.0);
418 Scalar mu1 = viscosityColumn[newRowIdx];
419 Scalar mu2 = viscosityColumn[newRowIdx - 1];
420 Scalar xMu = (mu1 - mu2)/( (mu1 + mu2)/2.0 );
424 Scalar newMug = gasMuArray.back()*(1.0 + xMu/2)/(1.0 - xMu/2.0);
428 RvArray.push_back(newRv);
429 gasBArray.push_back(newBg);
430 gasMuArray.push_back(newMug);
433 invGasBRvwSat.appendSamplePoint(xIdx, newRv, 1.0/newBg);
434 gasMuRvwSat.appendSamplePoint(xIdx, newRv, newMug);
454 saturatedWaterVaporizationFactorTable_.resize(
numRegions);
456 saturatedOilVaporizationFactorTable_.resize(
numRegions);
468 waterReferenceDensity_[regionIdx] = rhoRefWater;
469 oilReferenceDensity_[regionIdx] = rhoRefOil;
470 gasReferenceDensity_[regionIdx] = rhoRefGas;
479 { saturatedWaterVaporizationFactorTable_[regionIdx].setContainerOfTuples(samplePoints); }
487 { saturatedOilVaporizationFactorTable_[regionIdx].setContainerOfTuples(samplePoints); }
499 for (
unsigned regionIdx = 0; regionIdx <
numRegions; ++ regionIdx) {
502 const auto& gasMuRvSat = gasMuRvSat_[regionIdx];
503 const auto& invGasBRvSat = inverseGasBRvSat_[regionIdx];
504 assert(gasMuRvSat.numX() == invGasBRvSat.numX());
506 auto& invGasBMuRvSat = inverseGasBMuRvSat_[regionIdx];
507 auto& invSatGasB = inverseSaturatedGasB_[regionIdx];
508 auto& invSatGasBMu = inverseSaturatedGasBMu_[regionIdx];
510 std::vector<Scalar> satPressuresArray;
511 std::vector<Scalar> invSatGasBArray;
512 std::vector<Scalar> invSatGasBMuArray;
513 for (
size_t pIdx = 0; pIdx < gasMuRvSat.numX(); ++pIdx) {
514 invGasBMuRvSat.appendXPos(gasMuRvSat.xAt(pIdx));
516 assert(gasMuRvSat.numY(pIdx) == invGasBRvSat.numY(pIdx));
518 size_t numRw = gasMuRvSat.numY(pIdx);
519 for (
size_t RwIdx = 0; RwIdx < numRw; ++RwIdx)
520 invGasBMuRvSat.appendSamplePoint(pIdx,
521 gasMuRvSat.yAt(pIdx, RwIdx),
522 invGasBRvSat.valueAt(pIdx, RwIdx)
523 / gasMuRvSat.valueAt(pIdx, RwIdx));
528 satPressuresArray.push_back(gasMuRvSat.xAt(pIdx));
529 invSatGasBArray.push_back(invGasBRvSat.valueAt(pIdx, numRw - 1));
530 invSatGasBMuArray.push_back(invGasBMuRvSat.valueAt(pIdx, numRw - 1));
533 invSatGasB.setXYContainers(satPressuresArray, invSatGasBArray);
534 invSatGasBMu.setXYContainers(satPressuresArray, invSatGasBMuArray);
540 for (
unsigned regionIdx = 0; regionIdx <
numRegions; ++ regionIdx) {
543 const auto& gasMuRvwSat = gasMuRvwSat_[regionIdx];
544 const auto& invGasBRvwSat = inverseGasBRvwSat_[regionIdx];
545 assert(gasMuRvwSat.numX() == invGasBRvwSat.numX());
547 auto& invGasBMuRvwSat = inverseGasBMuRvwSat_[regionIdx];
548 auto& invSatGasB = inverseSaturatedGasB_[regionIdx];
549 auto& invSatGasBMu = inverseSaturatedGasBMu_[regionIdx];
551 std::vector<Scalar> satPressuresArray;
552 std::vector<Scalar> invSatGasBArray;
553 std::vector<Scalar> invSatGasBMuArray;
554 for (
size_t pIdx = 0; pIdx < gasMuRvwSat.numX(); ++pIdx) {
555 invGasBMuRvwSat.appendXPos(gasMuRvwSat.xAt(pIdx));
557 assert(gasMuRvwSat.numY(pIdx) == invGasBRvwSat.numY(pIdx));
559 size_t numRw = gasMuRvwSat.numY(pIdx);
560 for (
size_t RwIdx = 0; RwIdx < numRw; ++RwIdx)
561 invGasBMuRvwSat.appendSamplePoint(pIdx,
562 gasMuRvwSat.yAt(pIdx, RwIdx),
563 invGasBRvwSat.valueAt(pIdx, RwIdx)
564 / gasMuRvwSat.valueAt(pIdx, RwIdx));
569 satPressuresArray.push_back(gasMuRvwSat.xAt(pIdx));
570 invSatGasBArray.push_back(invGasBRvwSat.valueAt(pIdx, numRw - 1));
571 invSatGasBMuArray.push_back(invGasBMuRvwSat.valueAt(pIdx, numRw - 1));
574 invSatGasB.setXYContainers(satPressuresArray, invSatGasBArray);
575 invSatGasBMu.setXYContainers(satPressuresArray, invSatGasBMuArray);
577 updateSaturationPressure_(regionIdx);
585 {
return gasReferenceDensity_.size(); }
590 template <
class Evaluation>
594 const Evaluation&)
const
596 throw std::runtime_error(
"Requested the enthalpy of gas but the thermal option is not enabled");
602 template <
class Evaluation>
605 const Evaluation& pressure,
606 const Evaluation& Rv,
607 const Evaluation& Rvw)
const
609 const Evaluation& temperature = 1E30;
612 const Evaluation& invBg = inverseGasBRvSat_[regionIdx].eval(pressure, Rvw,
true);
613 const Evaluation& invMugBg = inverseGasBMuRvSat_[regionIdx].eval(pressure, Rvw,
true);
614 return invBg/invMugBg;
618 const Evaluation& invBg = inverseGasBRvwSat_[regionIdx].eval(pressure, Rv,
true);
619 const Evaluation& invMugBg = inverseGasBMuRvwSat_[regionIdx].eval(pressure, Rv,
true);
620 return invBg/invMugBg;
627 template <
class Evaluation>
630 const Evaluation& pressure)
const
632 const Evaluation& invBg = inverseSaturatedGasB_[regionIdx].eval(pressure,
true);
633 const Evaluation& invMugBg = inverseSaturatedGasBMu_[regionIdx].eval(pressure,
true);
635 return invBg/invMugBg;
648 template <
class Evaluation>
651 const Evaluation& pressure,
652 const Evaluation& Rv,
653 const Evaluation& Rvw)
const
655 const Evaluation& temperature = 1E30;
658 return inverseGasBRvSat_[regionIdx].eval(pressure, Rvw,
true);
662 return inverseGasBRvwSat_[regionIdx].eval(pressure, Rv,
true);
671 template <
class Evaluation>
674 const Evaluation& pressure)
const
675 {
return inverseSaturatedGasB_[regionIdx].eval(pressure,
true); }
680 template <
class Evaluation>
683 const Evaluation& pressure)
const
685 return saturatedWaterVaporizationFactorTable_[regionIdx].eval(pressure,
true);
691 template <
class Evaluation>
694 const Evaluation& pressure,
695 const Evaluation& saltConcentration)
const
698 return saturatedWaterVaporizationSaltFactorTable_[regionIdx].eval(pressure, saltConcentration,
true);
700 return saturatedWaterVaporizationFactorTable_[regionIdx].eval(pressure,
true);
705 template <
class Evaluation>
708 const Evaluation& pressure)
const
710 return saturatedOilVaporizationFactorTable_[regionIdx].eval(pressure,
true);
720 template <
class Evaluation>
723 const Evaluation& pressure,
724 const Evaluation& oilSaturation,
725 Evaluation maxOilSaturation)
const
728 saturatedOilVaporizationFactorTable_[regionIdx].eval(pressure,
true);
732 maxOilSaturation =
min(maxOilSaturation, Scalar(1.0));
733 if (vapPar1_ > 0.0 && maxOilSaturation > 0.01 && oilSaturation < maxOilSaturation) {
734 constexpr const Scalar eps = 0.001;
735 const Evaluation& So =
max(oilSaturation, eps);
736 tmp *=
max(1e-3,
pow(So/maxOilSaturation, vapPar1_));
750 template <
class Evaluation>
753 const Evaluation& Rw)
const
757 const auto& RwTable = saturatedWaterVaporizationFactorTable_[regionIdx];
758 constexpr const Scalar eps = std::numeric_limits<typename Toolbox::Scalar>::epsilon()*1e6;
761 Evaluation pSat = saturationPressure_[regionIdx].eval(Rw,
true);
766 bool onProbation =
false;
767 for (
unsigned i = 0; i < 20; ++i) {
768 const Evaluation& f = RwTable.eval(pSat,
true) - Rw;
769 const Evaluation& fPrime = RwTable.evalDerivative(pSat,
true);
777 const Evaluation& delta = f/fPrime;
795 std::stringstream errlog;
796 errlog <<
"Finding saturation pressure did not converge:"
797 <<
" pSat = " << pSat
800 OpmLog::debug(
"Wet gas saturation pressure", errlog.str());
805 template <
class Evaluation>
810 throw std::runtime_error(
"Not implemented: The PVT model does not provide a diffusionCoefficient()");
814 {
return gasReferenceDensity_[regionIdx]; }
817 {
return oilReferenceDensity_[regionIdx]; }
820 {
return waterReferenceDensity_[regionIdx]; }
823 return inverseGasBRvSat_;
827 return inverseSaturatedGasB_;
830 const std::vector<TabulatedTwoDFunction>&
gasMu()
const {
835 return inverseGasBMuRvSat_;
839 return inverseSaturatedGasBMu_;
843 return saturatedWaterVaporizationFactorTable_;
847 return saturatedWaterVaporizationSaltFactorTable_;
851 return saturatedOilVaporizationFactorTable_;
855 return saturationPressure_;
864 return this->gasReferenceDensity_ == data.gasReferenceDensity_ &&
865 this->oilReferenceDensity_ == data.oilReferenceDensity_ &&
866 this->waterReferenceDensity_ == data.waterReferenceDensity_ &&
878 void updateSaturationPressure_(
unsigned regionIdx)
880 const auto& oilVaporizationFac = saturatedOilVaporizationFactorTable_[regionIdx];
884 size_t n = oilVaporizationFac.numSamples();
885 Scalar delta = (oilVaporizationFac.xMax() - oilVaporizationFac.xMin())/Scalar(n + 1);
887 SamplingPoints pSatSamplePoints;
889 for (
size_t i = 0; i <= n; ++ i) {
890 Scalar pSat = oilVaporizationFac.xMin() + Scalar(i)*delta;
893 pSatSamplePoints.emplace_back(Rv, pSat);
897 auto x_coord_comparator = [](
const auto& a,
const auto& b) {
return a.first == b.first; };
898 auto last = std::unique(pSatSamplePoints.begin(), pSatSamplePoints.end(), x_coord_comparator);
899 pSatSamplePoints.erase(last, pSatSamplePoints.end());
901 saturationPressure_[regionIdx].setContainerOfTuples(pSatSamplePoints);
904 std::vector<Scalar> gasReferenceDensity_;
905 std::vector<Scalar> waterReferenceDensity_;
906 std::vector<Scalar> oilReferenceDensity_;
907 std::vector<TabulatedTwoDFunction> inverseGasBRvwSat_;
908 std::vector<TabulatedTwoDFunction> inverseGasBRvSat_;
909 std::vector<TabulatedOneDFunction> inverseSaturatedGasB_;
910 std::vector<TabulatedTwoDFunction> gasMuRvwSat_;
911 std::vector<TabulatedTwoDFunction> gasMuRvSat_;
912 std::vector<TabulatedTwoDFunction> inverseGasBMuRvwSat_;
913 std::vector<TabulatedTwoDFunction> inverseGasBMuRvSat_;
914 std::vector<TabulatedOneDFunction> inverseSaturatedGasBMu_;
915 std::vector<TabulatedOneDFunction> saturatedWaterVaporizationFactorTable_;
916 std::vector<TabulatedTwoDFunction> saturatedWaterVaporizationSaltFactorTable_;
917 std::vector<TabulatedOneDFunction> saturatedOilVaporizationFactorTable_;
918 std::vector<TabulatedOneDFunction> saturationPressure_;
Definition: Exceptions.hpp:46
Implements a linearly interpolated scalar function that depends on one variable.
Definition: Tabulated1DFunction.hpp:48
This class represents the Pressure-Volume-Temperature relations of the gas phase with vaporized oil a...
Definition: WetHumidGasPvt.hpp:52
Evaluation saturationPressure(unsigned regionIdx, const Evaluation &, const Evaluation &Rw) const
Returns the saturation pressure of the gas phase [Pa] depending on its mass fraction of the water com...
Definition: WetHumidGasPvt.hpp:751
const std::vector< TabulatedTwoDFunction > & inverseGasB() const
Definition: WetHumidGasPvt.hpp:822
const std::vector< TabulatedTwoDFunction > & gasMu() const
Definition: WetHumidGasPvt.hpp:830
unsigned numRegions() const
Return the number of PVT regions which are considered by this PVT-object.
Definition: WetHumidGasPvt.hpp:584
void setSaturatedGasOilVaporizationFactor(unsigned regionIdx, const SamplingPoints &samplePoints)
Initialize the function for the oil vaporization factor .
Definition: WetHumidGasPvt.hpp:486
Evaluation viscosity(unsigned regionIdx, const Evaluation &, const Evaluation &pressure, const Evaluation &Rv, const Evaluation &Rvw) const
Returns the dynamic viscosity [Pa s] of the fluid phase given a set of parameters.
Definition: WetHumidGasPvt.hpp:603
Evaluation saturatedWaterVaporizationFactor(unsigned regionIdx, const Evaluation &, const Evaluation &pressure, const Evaluation &saltConcentration) const
Returns the water vaporization factor [m^3/m^3] of the water phase.
Definition: WetHumidGasPvt.hpp:692
const Scalar waterReferenceDensity(unsigned regionIdx) const
Definition: WetHumidGasPvt.hpp:819
Evaluation saturatedInverseFormationVolumeFactor(unsigned regionIdx, const Evaluation &, const Evaluation &pressure) const
Returns the formation volume factor [-] of water saturated gas at a given pressure.
Definition: WetHumidGasPvt.hpp:672
void setNumRegions(size_t numRegions)
Definition: WetHumidGasPvt.hpp:441
const Scalar oilReferenceDensity(unsigned regionIdx) const
Definition: WetHumidGasPvt.hpp:816
Evaluation saturatedWaterVaporizationFactor(unsigned regionIdx, const Evaluation &, const Evaluation &pressure) const
Returns the water vaporization factor [m^3/m^3] of the water phase.
Definition: WetHumidGasPvt.hpp:681
bool operator==(const WetHumidGasPvt< Scalar > &data) const
Definition: WetHumidGasPvt.hpp:862
WetHumidGasPvt()
Definition: WetHumidGasPvt.hpp:59
Evaluation saturatedViscosity(unsigned regionIdx, const Evaluation &, const Evaluation &pressure) const
Returns the dynamic viscosity [Pa s] of oil saturated gas at a given pressure.
Definition: WetHumidGasPvt.hpp:628
WetHumidGasPvt(const std::vector< Scalar > &gasReferenceDensity, const std::vector< Scalar > &oilReferenceDensity, const std::vector< Scalar > &waterReferenceDensity, const std::vector< TabulatedTwoDFunction > &inverseGasBRvwSat, const std::vector< TabulatedTwoDFunction > &inverseGasBRvSat, const std::vector< TabulatedOneDFunction > &inverseSaturatedGasB, const std::vector< TabulatedTwoDFunction > &gasMuRvwSat, const std::vector< TabulatedTwoDFunction > &gasMuRvSat, const std::vector< TabulatedTwoDFunction > &inverseGasBMuRvwSat, const std::vector< TabulatedTwoDFunction > &inverseGasBMuRvSat, const std::vector< TabulatedOneDFunction > &inverseSaturatedGasBMu, const std::vector< TabulatedOneDFunction > &saturatedWaterVaporizationFactorTable, const std::vector< TabulatedTwoDFunction > &saturatedWaterVaporizationSaltFactorTable, const std::vector< TabulatedOneDFunction > &saturatedOilVaporizationFactorTable, const std::vector< TabulatedOneDFunction > &saturationPressure, Scalar vapPar1)
Definition: WetHumidGasPvt.hpp:64
Evaluation internalEnergy(unsigned, const Evaluation &, const Evaluation &, const Evaluation &) const
Returns the specific enthalpy [J/kg] of gas given a set of parameters.
Definition: WetHumidGasPvt.hpp:591
Evaluation diffusionCoefficient(const Evaluation &, const Evaluation &, unsigned) const
Definition: WetHumidGasPvt.hpp:806
Evaluation saturatedOilVaporizationFactor(unsigned regionIdx, const Evaluation &, const Evaluation &pressure, const Evaluation &oilSaturation, Evaluation maxOilSaturation) const
Returns the oil vaporization factor [m^3/m^3] of the gas phase.
Definition: WetHumidGasPvt.hpp:721
Scalar vapPar1() const
Definition: WetHumidGasPvt.hpp:858
void setReferenceDensities(unsigned regionIdx, Scalar rhoRefOil, Scalar rhoRefGas, Scalar rhoRefWater)
Initialize the reference densities of all fluids for a given PVT region.
Definition: WetHumidGasPvt.hpp:463
Evaluation inverseFormationVolumeFactor(unsigned regionIdx, const Evaluation &, const Evaluation &pressure, const Evaluation &Rv, const Evaluation &Rvw) const
Returns the formation volume factor [-] of the fluid phase.
Definition: WetHumidGasPvt.hpp:649
const Scalar gasReferenceDensity(unsigned regionIdx) const
Definition: WetHumidGasPvt.hpp:813
const std::vector< TabulatedTwoDFunction > & inverseGasBMu() const
Definition: WetHumidGasPvt.hpp:834
const std::vector< TabulatedOneDFunction > & saturatedOilVaporizationFactorTable() const
Definition: WetHumidGasPvt.hpp:850
const std::vector< TabulatedTwoDFunction > & saturatedWaterVaporizationSaltFactorTable() const
Definition: WetHumidGasPvt.hpp:846
Evaluation saturatedOilVaporizationFactor(unsigned regionIdx, const Evaluation &, const Evaluation &pressure) const
Definition: WetHumidGasPvt.hpp:706
const std::vector< TabulatedOneDFunction > & saturationPressure() const
Definition: WetHumidGasPvt.hpp:854
void initEnd()
Finish initializing the gas phase PVT properties.
Definition: WetHumidGasPvt.hpp:493
const std::vector< TabulatedOneDFunction > & inverseSaturatedGasBMu() const
Definition: WetHumidGasPvt.hpp:838
void setSaturatedGasWaterVaporizationFactor(unsigned regionIdx, const SamplingPoints &samplePoints)
Initialize the function for the water vaporization factor .
Definition: WetHumidGasPvt.hpp:478
const std::vector< TabulatedOneDFunction > & inverseSaturatedGasB() const
Definition: WetHumidGasPvt.hpp:826
const std::vector< TabulatedOneDFunction > & saturatedWaterVaporizationFactorTable() const
Definition: WetHumidGasPvt.hpp:842
Definition: Air_Mesitylene.hpp:34
ReturnEval_< Evaluation1, Evaluation2 >::type min(const Evaluation1 &arg1, const Evaluation2 &arg2)
Definition: MathToolbox.hpp:346
ReturnEval_< Evaluation1, Evaluation2 >::type max(const Evaluation1 &arg1, const Evaluation2 &arg2)
Definition: MathToolbox.hpp:341
auto scalarValue(const Evaluation &val) -> decltype(MathToolbox< Evaluation >::scalarValue(val))
Definition: MathToolbox.hpp:335
Evaluation abs(const Evaluation &value)
Definition: MathToolbox.hpp:350
ReturnEval_< Evaluation1, Evaluation2 >::type pow(const Evaluation1 &base, const Evaluation2 &exp)
Definition: MathToolbox.hpp:416