blackoilextbomodules.hh
Go to the documentation of this file.
1// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2// vi: set et ts=4 sw=4 sts=4:
3/*
4 This file is part of the Open Porous Media project (OPM).
5
6 OPM is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 2 of the License, or
9 (at your option) any later version.
10
11 OPM is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with OPM. If not, see <http://www.gnu.org/licenses/>.
18
19 Consult the COPYING file in the top-level source directory of this
20 module for the precise wording of the license and the list of
21 copyright holders.
22*/
32#ifndef EWOMS_BLACK_OIL_EXTBO_MODULE_HH
33#define EWOMS_BLACK_OIL_EXTBO_MODULE_HH
34
35#include <dune/common/fvector.hh>
36
39
41
43
44//#include <opm/models/io/vtkBlackOilExtboModule.hh> //TODO: Missing ...
45
46#include <cassert>
47#include <cmath>
48#include <istream>
49#include <ostream>
50#include <stdexcept>
51#include <string>
52
53namespace Opm {
54
60template <class TypeTag, bool enableExtboV = getPropValue<TypeTag, Properties::EnableExtbo>()>
62{
74
75 using Toolbox = MathToolbox<Evaluation>;
76
77 static constexpr unsigned zFractionIdx = Indices::zFractionIdx;
78 static constexpr unsigned contiZfracEqIdx = Indices::contiZfracEqIdx;
79 static constexpr unsigned enableExtbo = enableExtboV;
80 static constexpr unsigned numEq = getPropValue<TypeTag, Properties::NumEq>();
81 static constexpr unsigned gasPhaseIdx = FluidSystem::gasPhaseIdx;
82 static constexpr unsigned oilPhaseIdx = FluidSystem::oilPhaseIdx;
83 static constexpr bool blackoilConserveSurfaceVolume = getPropValue<TypeTag, Properties::BlackoilConserveSurfaceVolume>();
84
85public:
88 {
89 params_ = params;
90 }
91
95 static void registerParameters()
96 {}
97
101 static void registerOutputModules(Model&,
102 Simulator&)
103 {}
104
105 static bool primaryVarApplies(unsigned pvIdx)
106 {
107 if constexpr (enableExtbo) {
108 return pvIdx == zFractionIdx;
109 }
110 else {
111 return false;
112 }
113 }
114
115 static std::string primaryVarName([[maybe_unused]] unsigned pvIdx)
116 {
117 assert(primaryVarApplies(pvIdx));
118
119 return "z_fraction";
120 }
121
122 static Scalar primaryVarWeight([[maybe_unused]] unsigned pvIdx)
123 {
124 assert(primaryVarApplies(pvIdx));
125
126 // TODO: it may be beneficial to chose this differently.
127 return static_cast<Scalar>(1.0);
128 }
129
130 static bool eqApplies(unsigned eqIdx)
131 {
132 if constexpr (enableExtbo) {
133 return eqIdx == contiZfracEqIdx;
134 }
135 else {
136 return false;
137 }
138 }
139
140 static std::string eqName([[maybe_unused]] unsigned eqIdx)
141 {
142 assert(eqApplies(eqIdx));
143
144 return "conti^solvent";
145 }
146
147 static Scalar eqWeight([[maybe_unused]] unsigned eqIdx)
148 {
149 assert(eqApplies(eqIdx));
150
151 // TODO: it may be beneficial to chose this differently.
152 return static_cast<Scalar>(1.0);
153 }
154
155 template <class LhsEval>
156 static void addStorage(Dune::FieldVector<LhsEval, numEq>& storage,
157 const IntensiveQuantities& intQuants)
158 {
159 if constexpr (enableExtbo) {
160 if constexpr (blackoilConserveSurfaceVolume) {
161 storage[contiZfracEqIdx] =
162 Toolbox::template decay<LhsEval>(intQuants.porosity()) *
163 Toolbox::template decay<LhsEval>(intQuants.yVolume()) *
164 Toolbox::template decay<LhsEval>(intQuants.fluidState().saturation(gasPhaseIdx)) *
165 Toolbox::template decay<LhsEval>(intQuants.fluidState().invB(gasPhaseIdx));
166 if (FluidSystem::enableDissolvedGas()) { // account for dissolved z in oil phase
167 storage[contiZfracEqIdx] +=
168 Toolbox::template decay<LhsEval>(intQuants.porosity()) *
169 Toolbox::template decay<LhsEval>(intQuants.xVolume()) *
170 Toolbox::template decay<LhsEval>(intQuants.fluidState().Rs()) *
171 Toolbox::template decay<LhsEval>(intQuants.fluidState().saturation(oilPhaseIdx)) *
172 Toolbox::template decay<LhsEval>(intQuants.fluidState().invB(oilPhaseIdx));
173 }
174 // Reg. terms: Preliminary attempt to avoid singular behaviour when solvent is invading a pure water
175 // region. Results seems insensitive to the weighting factor.
176 // TODO: Further investigations ...
177 const Scalar regWghtFactor = 1.0e-6;
178 storage[contiZfracEqIdx] +=
179 regWghtFactor* (1.0 - Toolbox::template decay<LhsEval>(intQuants.zFraction())) +
180 regWghtFactor*Toolbox::template decay<LhsEval>(intQuants.porosity()) *
181 Toolbox::template decay<LhsEval>(intQuants.fluidState().saturation(gasPhaseIdx)) *
182 Toolbox::template decay<LhsEval>(intQuants.fluidState().invB(gasPhaseIdx));
183 storage[contiZfracEqIdx - 1] += regWghtFactor*Toolbox::template decay<LhsEval>(intQuants.zFraction());
184 }
185 else {
186 throw std::runtime_error("Only component conservation in terms of surface volumes is implemented. ");
187 }
188 }
189 }
190
191 static void computeFlux([[maybe_unused]] RateVector& flux,
192 [[maybe_unused]] const ElementContext& elemCtx,
193 [[maybe_unused]] unsigned scvfIdx,
194 [[maybe_unused]] unsigned timeIdx)
195 {
196 if constexpr (enableExtbo) {
197 const auto& extQuants = elemCtx.extensiveQuantities(scvfIdx, timeIdx);
198
199 if constexpr (blackoilConserveSurfaceVolume) {
200 const unsigned inIdx = extQuants.interiorIndex();
201
202 const unsigned upIdxGas = static_cast<unsigned>(extQuants.upstreamIndex(gasPhaseIdx));
203 const auto& upGas = elemCtx.intensiveQuantities(upIdxGas, timeIdx);
204 const auto& fsGas = upGas.fluidState();
205 if (upIdxGas == inIdx) {
206 flux[contiZfracEqIdx] =
207 extQuants.volumeFlux(gasPhaseIdx) *
208 upGas.yVolume() *
209 fsGas.invB(gasPhaseIdx);
210 }
211 else {
212 flux[contiZfracEqIdx] =
213 extQuants.volumeFlux(gasPhaseIdx) *
214 decay<Scalar>(upGas.yVolume()) *
215 decay<Scalar>(fsGas.invB(gasPhaseIdx));
216 }
217 if (FluidSystem::enableDissolvedGas()) { // account for dissolved z in oil phase
218 const unsigned upIdxOil = static_cast<unsigned>(extQuants.upstreamIndex(oilPhaseIdx));
219 const auto& upOil = elemCtx.intensiveQuantities(upIdxOil, timeIdx);
220 const auto& fsOil = upOil.fluidState();
221 if (upIdxOil == inIdx) {
222 flux[contiZfracEqIdx] +=
223 extQuants.volumeFlux(oilPhaseIdx) *
224 upOil.xVolume() *
225 fsOil.Rs() *
226 fsOil.invB(oilPhaseIdx);
227 }
228 else {
229 flux[contiZfracEqIdx] +=
230 extQuants.volumeFlux(oilPhaseIdx) *
231 decay<Scalar>(upOil.xVolume()) *
232 decay<Scalar>(fsOil.Rs()) *
233 decay<Scalar>(fsOil.invB(oilPhaseIdx));
234 }
235 }
236 }
237 else {
238 throw std::runtime_error("Only component conservation in terms of surface volumes is implemented. ");
239 }
240 }
241 }
242
246 static void assignPrimaryVars(PrimaryVariables& priVars,
247 Scalar zFraction)
248 {
249 if constexpr (enableExtbo) {
250 priVars[zFractionIdx] = zFraction;
251 }
252 }
253
257 static void updatePrimaryVars(PrimaryVariables& newPv,
258 const PrimaryVariables& oldPv,
259 const EqVector& delta)
260 {
261 if constexpr (enableExtbo) {
262 // do a plain unchopped Newton update
263 newPv[zFractionIdx] = oldPv[zFractionIdx] - delta[zFractionIdx];
264 }
265 }
266
270 static Scalar computeUpdateError(const PrimaryVariables&,
271 const EqVector&)
272 {
273 // do not consider consider the cange of solvent primary variables for
274 // convergence
275 // TODO: maybe this should be changed
276 return static_cast<Scalar>(0.0);
277 }
278
282 static Scalar computeResidualError(const EqVector& resid)
283 {
284 // do not weight the residual of solvents when it comes to convergence
285 return std::abs(Toolbox::scalarValue(resid[contiZfracEqIdx]));
286 }
287
288 template <class DofEntity>
289 static void serializeEntity(const Model& model, std::ostream& outstream, const DofEntity& dof)
290 {
291 if constexpr (enableExtbo) {
292 const unsigned dofIdx = model.dofMapper().index(dof);
293
294 const PrimaryVariables& priVars = model.solution(/*timeIdx=*/0)[dofIdx];
295 outstream << priVars[zFractionIdx];
296 }
297 }
298
299 template <class DofEntity>
300 static void deserializeEntity(Model& model, std::istream& instream, const DofEntity& dof)
301 {
302 if constexpr (enableExtbo) {
303 const unsigned dofIdx = model.dofMapper().index(dof);
304
305 PrimaryVariables& priVars0 = model.solution(/*timeIdx=*/0)[dofIdx];
306 PrimaryVariables& priVars1 = model.solution(/*timeIdx=*/1)[dofIdx];
307
308 instream >> priVars0[zFractionIdx];
309
310 // set the primary variables for the beginning of the current time step.
311 priVars1 = priVars0[zFractionIdx];
312 }
313 }
314
315 template <typename Value>
316 static Value xVolume(unsigned pvtRegionIdx, const Value& pressure, const Value& z)
317 { return params_.X_[pvtRegionIdx].eval(z, pressure, true); }
318
319 template <typename Value>
320 static Value yVolume(unsigned pvtRegionIdx, const Value& pressure, const Value& z)
321 { return params_.Y_[pvtRegionIdx].eval(z, pressure, true); }
322
323 template <typename Value>
324 static Value pbubRs(unsigned pvtRegionIdx, const Value& z, const Value& rs)
325 { return params_.PBUB_RS_[pvtRegionIdx].eval(z, rs, true); }
326
327 template <typename Value>
328 static Value pbubRv(unsigned pvtRegionIdx, const Value& z, const Value& rv)
329 { return params_.PBUB_RV_[pvtRegionIdx].eval(z, rv, true); }
330
331 template <typename Value>
332 static Value oilViscosity(unsigned pvtRegionIdx, const Value& pressure, const Value& z)
333 { return params_.VISCO_[pvtRegionIdx].eval(z, pressure, true); }
334
335 template <typename Value>
336 static Value gasViscosity(unsigned pvtRegionIdx, const Value& pressure, const Value& z)
337 { return params_.VISCG_[pvtRegionIdx].eval(z, pressure, true); }
338
339 template <typename Value>
340 static Value bo(unsigned pvtRegionIdx, const Value& pressure, const Value& z)
341 { return params_.BO_[pvtRegionIdx].eval(z, pressure, true); }
342
343 template <typename Value>
344 static Value bg(unsigned pvtRegionIdx, const Value& pressure, const Value& z)
345 { return params_.BG_[pvtRegionIdx].eval(z, pressure, true); }
346
347 template <typename Value>
348 static Value rs(unsigned pvtRegionIdx, const Value& pressure, const Value& z)
349 { return params_.RS_[pvtRegionIdx].eval(z, pressure, true); }
350
351 template <typename Value>
352 static Value rv(unsigned pvtRegionIdx, const Value& pressure, const Value& z)
353 { return params_.RV_[pvtRegionIdx].eval(z, pressure, true); }
354
355 static Scalar referenceDensity(unsigned regionIdx)
356 { return params_.zReferenceDensity_[regionIdx]; }
357
358 static Scalar zLim(unsigned regionIdx)
359 { return params_.zLim_[regionIdx]; }
360
361 template <typename Value>
362 static Value oilCmp(unsigned pvtRegionIdx, const Value& z)
363 { return params_.oilCmp_[pvtRegionIdx].eval(z, true); }
364
365 template <typename Value>
366 static Value gasCmp(unsigned pvtRegionIdx, const Value& z)
367 { return params_.gasCmp_[pvtRegionIdx].eval(z, true); }
368
369private:
370 static BlackOilExtboParams<Scalar> params_;
371};
372
373template <class TypeTag, bool enableExtboV>
374BlackOilExtboParams<typename BlackOilExtboModule<TypeTag, enableExtboV>::Scalar>
375BlackOilExtboModule<TypeTag, enableExtboV>::params_;
376
377template <class TypeTag, bool enableExtboV>
379
387template <class TypeTag>
388class BlackOilExtboIntensiveQuantities<TypeTag, /*enableExtboV=*/true>
389{
391
398
400
401 static constexpr int zFractionIdx = Indices::zFractionIdx;
402 static constexpr int oilPhaseIdx = FluidSystem::oilPhaseIdx;
403 static constexpr int gasPhaseIdx = FluidSystem::gasPhaseIdx;
404
405public:
411 void zFractionUpdate_(const ElementContext& elemCtx,
412 unsigned dofIdx,
413 unsigned timeIdx)
414 {
415 zFractionUpdate_(elemCtx.primaryVars(dofIdx, timeIdx), timeIdx);
416 }
417
423 void zFractionUpdate_(const PrimaryVariables& priVars,
424 unsigned timeIdx)
425 {
426 const unsigned pvtRegionIdx = priVars.pvtRegionIndex();
427 const auto& fs = asImp_().fluidState_;
428
429 zFraction_ = priVars.makeEvaluation(zFractionIdx, timeIdx);
430
431 oilViscosity_ = ExtboModule::oilViscosity(pvtRegionIdx, fs.pressure(oilPhaseIdx), zFraction_);
432 gasViscosity_ = ExtboModule::gasViscosity(pvtRegionIdx, fs.pressure(gasPhaseIdx), zFraction_);
433
434 bo_ = ExtboModule::bo(pvtRegionIdx, fs.pressure(oilPhaseIdx), zFraction_);
435 bg_ = ExtboModule::bg(pvtRegionIdx, fs.pressure(gasPhaseIdx), zFraction_);
436
437 bz_ = ExtboModule::bg(pvtRegionIdx, fs.pressure(oilPhaseIdx), Evaluation{0.99});
438
439 if (FluidSystem::enableDissolvedGas()) {
440 rs_ = ExtboModule::rs(pvtRegionIdx, fs.pressure(oilPhaseIdx), zFraction_);
441 }
442 else {
443 rs_ = 0.0;
444 }
445
446 if (FluidSystem::enableVaporizedOil()) {
447 rv_ = ExtboModule::rv(pvtRegionIdx, fs.pressure(gasPhaseIdx), zFraction_);
448 }
449 else {
450 rv_ = 0.0;
451 }
452
453 xVolume_ = ExtboModule::xVolume(pvtRegionIdx, fs.pressure(oilPhaseIdx), zFraction_);
454 yVolume_ = ExtboModule::yVolume(pvtRegionIdx, fs.pressure(oilPhaseIdx), zFraction_);
455
456 Evaluation pbub = fs.pressure(oilPhaseIdx);
457
458 if (priVars.primaryVarsMeaningWater() == PrimaryVariables::WaterMeaning::Sw) {
459 static const Scalar thresholdWaterFilledCell = 1.0 - 1e-6;
460 Scalar sw = priVars.makeEvaluation(Indices::waterSwitchIdx, timeIdx).value();
461 if (sw >= thresholdWaterFilledCell) {
462 rs_ = 0.0; // water only, zero rs_ ...
463 }
464 }
465
466 if (priVars.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Rs) {
467 rs_ = priVars.makeEvaluation(Indices::compositionSwitchIdx, timeIdx);
468 const Evaluation zLim = ExtboModule::zLim(pvtRegionIdx);
469 if (zFraction_ > zLim) {
470 pbub = ExtboModule::pbubRs(pvtRegionIdx, zLim, rs_);
471 } else {
472 pbub = ExtboModule::pbubRs(pvtRegionIdx, zFraction_, rs_);
473 }
474 bo_ = ExtboModule::bo(pvtRegionIdx, pbub, zFraction_) +
475 ExtboModule::oilCmp(pvtRegionIdx, zFraction_) * (fs.pressure(oilPhaseIdx) - pbub);
476
477 xVolume_ = ExtboModule::xVolume(pvtRegionIdx, pbub, zFraction_);
478 }
479
480 if (priVars.primaryVarsMeaningGas() == PrimaryVariables::GasMeaning::Rv) {
481 rv_ = priVars.makeEvaluation(Indices::compositionSwitchIdx, timeIdx);
482 const Evaluation rvsat = ExtboModule::rv(pvtRegionIdx, pbub, zFraction_);
483 bg_ = ExtboModule::bg(pvtRegionIdx, pbub, zFraction_) +
484 ExtboModule::gasCmp(pvtRegionIdx, zFraction_) * (rv_ - rvsat);
485
486 yVolume_ = ExtboModule::yVolume(pvtRegionIdx, pbub, zFraction_);
487 }
488 }
489
496 {
497 const auto& iq = asImp_();
498 auto& fs = asImp_().fluidState_;
499
500 const unsigned pvtRegionIdx = iq.pvtRegionIndex();
501 zRefDensity_ = ExtboModule::referenceDensity(pvtRegionIdx);
502
503 fs.setInvB(oilPhaseIdx, 1.0 / bo_);
504 fs.setInvB(gasPhaseIdx, 1.0 / bg_);
505
506 fs.setDensity(oilPhaseIdx,
507 fs.invB(oilPhaseIdx) *
508 (FluidSystem::referenceDensity(oilPhaseIdx, pvtRegionIdx) +
509 (1.0 - xVolume_) * fs.Rs() * FluidSystem::referenceDensity(gasPhaseIdx, pvtRegionIdx) +
510 xVolume_ * fs.Rs() * zRefDensity_));
511 fs.setDensity(gasPhaseIdx,
512 fs.invB(gasPhaseIdx) *
513 (FluidSystem::referenceDensity(gasPhaseIdx, pvtRegionIdx) *
514 (1.0 - yVolume_) + yVolume_* zRefDensity_ +
515 FluidSystem::referenceDensity(oilPhaseIdx, pvtRegionIdx) * fs.Rv()));
516 }
517
518 const Evaluation& zFraction() const
519 { return zFraction_; }
520
521 const Evaluation& xVolume() const
522 { return xVolume_; }
523
524 const Evaluation& yVolume() const
525 { return yVolume_; }
526
527 const Evaluation& oilViscosity() const
528 { return oilViscosity_; }
529
530 const Evaluation& gasViscosity() const
531 { return gasViscosity_; }
532
533 const Evaluation& bo() const
534 { return bo_; }
535
536 const Evaluation& bg() const
537 { return bg_; }
538
539 const Evaluation& rs() const
540 { return rs_; }
541
542 const Evaluation& rv() const
543 { return rv_; }
544
545 const Evaluation zPureInvFormationVolumeFactor() const
546 { return 1.0 / bz_; }
547
548 Scalar zRefDensity() const
549 { return zRefDensity_; }
550
551protected:
552 Implementation& asImp_()
553 { return *static_cast<Implementation*>(this); }
554
555 // Abstract "mass fraction" accounting for the solvent component. The relation between this
556 // quantity and the actual mass fraction of solvent, is implicitly defined from the specific
557 // pvt measurements as provided by kw PVTSOL.
558 Evaluation zFraction_;
559
560 // The solvent component is assumed gas at surface conditions
561 Evaluation xVolume_; // Solvent volume fraction of Rs
562 Evaluation yVolume_; // Solvent volume fraction of Sg/Bg
563
564 // Standard black oil parameters modified for presence of solvent
565 Evaluation oilViscosity_;
566 Evaluation gasViscosity_;
567 Evaluation bo_;
568 Evaluation bg_;
569 Evaluation rs_;
570 Evaluation rv_;
571
572 // Properties of pure solvent
573 Evaluation bz_;
575};
576
577template <class TypeTag>
579{
583
584public:
586 {}
587
588 void zFractionUpdate_(const ElementContext&,
589 unsigned,
590 unsigned)
591 {}
592
593 const Evaluation& xVolume() const
594 { throw std::runtime_error("xVolume() called but extbo is disabled"); }
595
596 const Evaluation& yVolume() const
597 { throw std::runtime_error("yVolume() called but extbo is disabled"); }
598
599 const Evaluation& oilViscosity() const
600 { throw std::runtime_error("oilViscosity() called but extbo is disabled"); }
601
602 const Evaluation& gasViscosity() const
603 { throw std::runtime_error("gasViscosity() called but extbo is disabled"); }
604
605 const Evaluation& rs() const
606 { throw std::runtime_error("rs() called but extbo is disabled"); }
607
608 const Evaluation& rv() const
609 { throw std::runtime_error("rv() called but extbo is disabled"); }
610
611 const Evaluation& zPureInvFormationVolumeFactor() const
612 { throw std::runtime_error("zPureInvFormationVolumeFactor() called but extbo is disabled"); }
613
614 const Evaluation& zFraction() const
615 { throw std::runtime_error("zFraction() called but extbo is disabled"); }
616
617 const Evaluation& zInverseFormationVolumeFactor() const
618 { throw std::runtime_error("zInverseFormationVolumeFactor() called but extbo is disabled"); }
619
620 Scalar zRefDensity() const
621 { throw std::runtime_error("zRefDensity() called but extbo is disabled"); }
622};
623
631template <class TypeTag, bool enableExtboV = getPropValue<TypeTag, Properties::EnableExtbo>()>
633{
635
636 Implementation& asImp_()
637 { return *static_cast<Implementation*>(this); }
638};
639
640template <class TypeTag>
642{
643};
644
645} // namespace Opm
646
647#endif
Defines a type tags and some fundamental properties all models.
Contains the parameters required to extend the black-oil model by solvent component....
Declares the properties required by the black oil model.
Provides the solvent specific extensive quantities to the generic black-oil module's extensive quanti...
Definition: blackoilextbomodules.hh:633
const Evaluation & xVolume() const
Definition: blackoilextbomodules.hh:593
const Evaluation & rs() const
Definition: blackoilextbomodules.hh:605
const Evaluation & zInverseFormationVolumeFactor() const
Definition: blackoilextbomodules.hh:617
const Evaluation & zPureInvFormationVolumeFactor() const
Definition: blackoilextbomodules.hh:611
const Evaluation & oilViscosity() const
Definition: blackoilextbomodules.hh:599
void zFractionUpdate_(const ElementContext &, unsigned, unsigned)
Definition: blackoilextbomodules.hh:588
const Evaluation & zFraction() const
Definition: blackoilextbomodules.hh:614
void zPvtUpdate_()
Definition: blackoilextbomodules.hh:585
const Evaluation & rv() const
Definition: blackoilextbomodules.hh:608
const Evaluation & gasViscosity() const
Definition: blackoilextbomodules.hh:602
const Evaluation & yVolume() const
Definition: blackoilextbomodules.hh:596
Scalar zRefDensity() const
Definition: blackoilextbomodules.hh:620
void zFractionUpdate_(const ElementContext &elemCtx, unsigned dofIdx, unsigned timeIdx)
Compute extended pvt properties from table lookups.
Definition: blackoilextbomodules.hh:411
Evaluation xVolume_
Definition: blackoilextbomodules.hh:561
Evaluation bo_
Definition: blackoilextbomodules.hh:567
void zPvtUpdate_()
Re-compute face densities to account for zFraction dependency.
Definition: blackoilextbomodules.hh:495
const Evaluation & oilViscosity() const
Definition: blackoilextbomodules.hh:527
const Evaluation & xVolume() const
Definition: blackoilextbomodules.hh:521
const Evaluation & zFraction() const
Definition: blackoilextbomodules.hh:518
Scalar zRefDensity_
Definition: blackoilextbomodules.hh:574
void zFractionUpdate_(const PrimaryVariables &priVars, unsigned timeIdx)
Compute extended pvt properties from table lookups.
Definition: blackoilextbomodules.hh:423
const Evaluation & gasViscosity() const
Definition: blackoilextbomodules.hh:530
const Evaluation & yVolume() const
Definition: blackoilextbomodules.hh:524
Evaluation oilViscosity_
Definition: blackoilextbomodules.hh:565
const Evaluation & rv() const
Definition: blackoilextbomodules.hh:542
Evaluation bg_
Definition: blackoilextbomodules.hh:568
Evaluation bz_
Definition: blackoilextbomodules.hh:573
const Evaluation & bg() const
Definition: blackoilextbomodules.hh:536
Evaluation yVolume_
Definition: blackoilextbomodules.hh:562
Evaluation gasViscosity_
Definition: blackoilextbomodules.hh:566
Scalar zRefDensity() const
Definition: blackoilextbomodules.hh:548
const Evaluation & rs() const
Definition: blackoilextbomodules.hh:539
const Evaluation zPureInvFormationVolumeFactor() const
Definition: blackoilextbomodules.hh:545
Evaluation rs_
Definition: blackoilextbomodules.hh:569
const Evaluation & bo() const
Definition: blackoilextbomodules.hh:533
Implementation & asImp_()
Definition: blackoilextbomodules.hh:552
Evaluation rv_
Definition: blackoilextbomodules.hh:570
Evaluation zFraction_
Definition: blackoilextbomodules.hh:558
Provides the volumetric quantities required for the equations needed by the solvents extension of the...
Definition: blackoilextbomodules.hh:378
Contains the high level supplements required to extend the black oil model.
Definition: blackoilextbomodules.hh:62
static void addStorage(Dune::FieldVector< LhsEval, numEq > &storage, const IntensiveQuantities &intQuants)
Definition: blackoilextbomodules.hh:156
static bool primaryVarApplies(unsigned pvIdx)
Definition: blackoilextbomodules.hh:105
static Scalar zLim(unsigned regionIdx)
Definition: blackoilextbomodules.hh:358
static Scalar computeResidualError(const EqVector &resid)
Return how much a residual is considered an error.
Definition: blackoilextbomodules.hh:282
static Value yVolume(unsigned pvtRegionIdx, const Value &pressure, const Value &z)
Definition: blackoilextbomodules.hh:320
static void updatePrimaryVars(PrimaryVariables &newPv, const PrimaryVariables &oldPv, const EqVector &delta)
Do a Newton-Raphson update the primary variables of the solvents.
Definition: blackoilextbomodules.hh:257
static Value gasViscosity(unsigned pvtRegionIdx, const Value &pressure, const Value &z)
Definition: blackoilextbomodules.hh:336
static std::string eqName(unsigned eqIdx)
Definition: blackoilextbomodules.hh:140
static bool eqApplies(unsigned eqIdx)
Definition: blackoilextbomodules.hh:130
static Value pbubRv(unsigned pvtRegionIdx, const Value &z, const Value &rv)
Definition: blackoilextbomodules.hh:328
static Scalar primaryVarWeight(unsigned pvIdx)
Definition: blackoilextbomodules.hh:122
static Value rs(unsigned pvtRegionIdx, const Value &pressure, const Value &z)
Definition: blackoilextbomodules.hh:348
static void registerOutputModules(Model &, Simulator &)
Register all solvent specific VTK and ECL output modules.
Definition: blackoilextbomodules.hh:101
static Scalar computeUpdateError(const PrimaryVariables &, const EqVector &)
Return how much a Newton-Raphson update is considered an error.
Definition: blackoilextbomodules.hh:270
static Value xVolume(unsigned pvtRegionIdx, const Value &pressure, const Value &z)
Definition: blackoilextbomodules.hh:316
static void serializeEntity(const Model &model, std::ostream &outstream, const DofEntity &dof)
Definition: blackoilextbomodules.hh:289
static void computeFlux(RateVector &flux, const ElementContext &elemCtx, unsigned scvfIdx, unsigned timeIdx)
Definition: blackoilextbomodules.hh:191
static void registerParameters()
Register all run-time parameters for the black-oil solvent module.
Definition: blackoilextbomodules.hh:95
static void deserializeEntity(Model &model, std::istream &instream, const DofEntity &dof)
Definition: blackoilextbomodules.hh:300
static std::string primaryVarName(unsigned pvIdx)
Definition: blackoilextbomodules.hh:115
static Value rv(unsigned pvtRegionIdx, const Value &pressure, const Value &z)
Definition: blackoilextbomodules.hh:352
static void setParams(BlackOilExtboParams< Scalar > &&params)
Set parameters.
Definition: blackoilextbomodules.hh:87
static Value pbubRs(unsigned pvtRegionIdx, const Value &z, const Value &rs)
Definition: blackoilextbomodules.hh:324
static Value oilCmp(unsigned pvtRegionIdx, const Value &z)
Definition: blackoilextbomodules.hh:362
static Scalar referenceDensity(unsigned regionIdx)
Definition: blackoilextbomodules.hh:355
static Value bg(unsigned pvtRegionIdx, const Value &pressure, const Value &z)
Definition: blackoilextbomodules.hh:344
static Value oilViscosity(unsigned pvtRegionIdx, const Value &pressure, const Value &z)
Definition: blackoilextbomodules.hh:332
static void assignPrimaryVars(PrimaryVariables &priVars, Scalar zFraction)
Assign the solvent specific primary variables to a PrimaryVariables object.
Definition: blackoilextbomodules.hh:246
static Scalar eqWeight(unsigned eqIdx)
Definition: blackoilextbomodules.hh:147
static Value bo(unsigned pvtRegionIdx, const Value &pressure, const Value &z)
Definition: blackoilextbomodules.hh:340
static Value gasCmp(unsigned pvtRegionIdx, const Value &z)
Definition: blackoilextbomodules.hh:366
Declare the properties used by the infrastructure code of the finite volume discretizations.
Definition: blackoilbioeffectsmodules.hh:43
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
Struct holding the parameters for the BlackoilExtboModule class.
Definition: blackoilextboparams.hpp:49