blackoilfoammodules.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*/
28#ifndef EWOMS_BLACK_OIL_FOAM_MODULE_HH
29#define EWOMS_BLACK_OIL_FOAM_MODULE_HH
30
31#include <dune/common/fvector.hh>
32
33#include <opm/common/ErrorMacros.hpp>
34#include <opm/common/OpmLog/OpmLog.hpp>
35#include <opm/common/utility/gpuDecorators.hpp>
36
37#include <opm/input/eclipse/EclipseState/Phase.hpp>
38
42
45
46#include <cassert>
47#include <istream>
48#include <numbers>
49#include <ostream>
50#include <stdexcept>
51#include <string>
52
53namespace Opm {
54
55
56template <class TypeTag, bool enableFoamV>
58
64template <class TypeTag>
65class BlackOilFoamModule<TypeTag, true>
66{
78
79 using Toolbox = MathToolbox<Evaluation>;
80
81 using TabulatedFunction = typename BlackOilFoamParams<Scalar>::TabulatedFunction;
82
83 static constexpr unsigned foamConcentrationIdx = Indices::foamConcentrationIdx;
84 static constexpr unsigned contiFoamEqIdx = Indices::contiFoamEqIdx;
85 static constexpr unsigned gasPhaseIdx = FluidSystem::gasPhaseIdx;
86 static constexpr unsigned waterPhaseIdx = FluidSystem::waterPhaseIdx;
87
88 static constexpr bool enableFoam = true;
89
90 static constexpr unsigned numEq = getPropValue<TypeTag, Properties::NumEq>();
91
92 static constexpr bool enableSolvent = getPropValue<TypeTag, Properties::EnableSolvent>();
93
94public:
97 {
98 params_ = params;
99 }
100
104 static void registerParameters()
105 {}
106
110 static void registerOutputModules(Model&,
111 Simulator&)
112 {
113 if (Parameters::Get<Parameters::EnableVtkOutput>()) {
114 OpmLog::warning("VTK output requested, currently unsupported by the foam module.");
115 }
116 //model.addOutputModule(new VtkBlackOilFoamModule<TypeTag>(simulator));
117 }
118
119 static bool primaryVarApplies(unsigned pvIdx)
120 {
121 return pvIdx == foamConcentrationIdx;
122 }
123
124 static std::string primaryVarName([[maybe_unused]] unsigned pvIdx)
125 {
126 assert(primaryVarApplies(pvIdx));
127 return "foam_concentration";
128 }
129
130 static Scalar primaryVarWeight([[maybe_unused]] unsigned pvIdx)
131 {
132 assert(primaryVarApplies(pvIdx));
133
134 // TODO: it may be beneficial to chose this differently.
135 return static_cast<Scalar>(1.0);
136 }
137
138 static bool eqApplies(unsigned eqIdx)
139 {
140 return eqIdx == contiFoamEqIdx;
141 }
142
143 static std::string eqName([[maybe_unused]] unsigned eqIdx)
144 {
145 assert(eqApplies(eqIdx));
146
147 return "conti^foam";
148 }
149
150 static Scalar eqWeight([[maybe_unused]] unsigned eqIdx)
151 {
152 assert(eqApplies(eqIdx));
153
154 // TODO: it may be beneficial to chose this differently.
155 return static_cast<Scalar>(1.0);
156 }
157
158 // must be called after water storage is computed
159 template <class StorageType>
160 OPM_HOST_DEVICE static void addStorage(StorageType& storage,
161 const IntensiveQuantities& intQuants)
162 {
163 using LhsEval = typename StorageType::value_type;
164
165 const auto& fs = intQuants.fluidState();
166
167 LhsEval surfaceVolume = Toolbox::template decay<LhsEval>(intQuants.porosity());
168 if (params_.transport_phase_ == Phase::WATER) {
169 surfaceVolume *= Toolbox::template decay<LhsEval>(fs.saturation(waterPhaseIdx)) *
170 Toolbox::template decay<LhsEval>(fs.invB(waterPhaseIdx));
171 } else if (params_.transport_phase_ == Phase::GAS) {
172 surfaceVolume *= Toolbox::template decay<LhsEval>(fs.saturation(gasPhaseIdx)) *
173 Toolbox::template decay<LhsEval>(fs.invB(gasPhaseIdx));
174 } else if (params_.transport_phase_ == Phase::SOLVENT) {
175 if constexpr (enableSolvent) {
176 surfaceVolume *= Toolbox::template decay<LhsEval>( intQuants.solventSaturation()) *
177 Toolbox::template decay<LhsEval>(intQuants.solventInverseFormationVolumeFactor());
178 }
179 } else {
180 OPM_THROW(std::runtime_error, "Transport phase is GAS/WATER/SOLVENT");
181 }
182
183 // Avoid singular matrix if no gas is present.
184 surfaceVolume = max(surfaceVolume, 1e-10);
185
186 // Foam/surfactant in free phase.
187 const LhsEval freeFoam = surfaceVolume *
188 Toolbox::template decay<LhsEval>(intQuants.foamConcentration());
189
190 // Adsorbed foam/surfactant.
191 const LhsEval adsorbedFoam =
192 Toolbox::template decay<LhsEval>(1.0 - intQuants.porosity()) *
193 Toolbox::template decay<LhsEval>(intQuants.foamRockDensity()) *
194 Toolbox::template decay<LhsEval>(intQuants.foamAdsorbed());
195
196 const LhsEval accumulationFoam = freeFoam + adsorbedFoam;
197 storage[contiFoamEqIdx] += accumulationFoam;
198 }
199
200 static void computeFlux(RateVector& flux,
201 const ElementContext& elemCtx,
202 unsigned scvfIdx,
203 unsigned timeIdx)
204 {
205 const auto& extQuants = elemCtx.extensiveQuantities(scvfIdx, timeIdx);
206 const unsigned inIdx = extQuants.interiorIndex();
207
208 flux[contiFoamEqIdx] = 0.0;
209
210 // The effect of the mobility reduction factor is
211 // incorporated in the mobility for the relevant phase,
212 // so fluxes do not need modification here.
213 switch (transportPhase()) {
214 case Phase::WATER: {
215 const unsigned upIdx = extQuants.upstreamIndex(waterPhaseIdx);
216 const auto& up = elemCtx.intensiveQuantities(upIdx, timeIdx);
217 if (upIdx == inIdx) {
218 addFoamFluxes_<Evaluation>(
219 flux, waterPhaseIdx, extQuants.volumeFlux(waterPhaseIdx), up);
220 } else {
221 addFoamFluxes_<Scalar>(
222 flux, waterPhaseIdx, extQuants.volumeFlux(waterPhaseIdx), up);
223 }
224 break;
225 }
226 case Phase::GAS: {
227 const unsigned upIdx = extQuants.upstreamIndex(gasPhaseIdx);
228 const auto& up = elemCtx.intensiveQuantities(upIdx, timeIdx);
229 if (upIdx == inIdx) {
230 addFoamFluxes_<Evaluation>(
231 flux, gasPhaseIdx, extQuants.volumeFlux(gasPhaseIdx), up);
232 } else {
233 addFoamFluxes_<Scalar>(
234 flux, gasPhaseIdx, extQuants.volumeFlux(gasPhaseIdx), up);
235 }
236 break;
237 }
238 case Phase::SOLVENT:
239 if constexpr (enableSolvent) {
240 const unsigned upIdx = extQuants.solventUpstreamIndex();
241 const auto& up = elemCtx.intensiveQuantities(upIdx, timeIdx);
242 if (upIdx == inIdx) {
243 addFoamSolventFluxes_<Evaluation>(flux, extQuants.solventVolumeFlux(), up);
244 } else {
245 addFoamSolventFluxes_<Scalar>(flux, extQuants.solventVolumeFlux(), up);
246 }
247 } else {
248 throw std::runtime_error("Foam transport phase is SOLVENT but SOLVENT is not activated.");
249 }
250 break;
251 default:
252 throw std::runtime_error("Foam transport phase must be GAS/WATER/SOLVENT.");
253 }
254 }
255
267 template <class UpEval>
268 static void addFoamFluxes_(RateVector& flux,
269 const unsigned phaseIdx,
270 const Evaluation& volumeFlux,
271 const IntensiveQuantities& up)
272 {
273 if ((phaseIdx == waterPhaseIdx && transportPhase() == Phase::WATER)
274 || (phaseIdx == gasPhaseIdx && transportPhase() == Phase::GAS)) {
275 flux[contiFoamEqIdx] += volumeFlux
276 * decay<UpEval>(up.fluidState().invB(phaseIdx))
277 * decay<UpEval>(up.foamConcentration());
278 }
279 }
280
291 template <class UpEval>
292 static void addFoamSolventFluxes_(RateVector& flux,
293 const Evaluation& solventVolumeFlux,
294 const IntensiveQuantities& up)
295 {
296 if (transportPhase() == Phase::SOLVENT) {
297 flux[contiFoamEqIdx] += solventVolumeFlux
298 * decay<UpEval>(up.solventInverseFormationVolumeFactor())
299 * decay<UpEval>(up.foamConcentration());
300 }
301 }
302
306 static Scalar computeUpdateError(const PrimaryVariables&,
307 const EqVector&)
308 {
309 // do not consider the change of foam primary variables for convergence
310 // TODO: maybe this should be changed
311 return static_cast<Scalar>(0.0);
312 }
313
314 template <class DofEntity>
315 static void serializeEntity([[maybe_unused]] const Model& model,
316 [[maybe_unused]] std::ostream& outstream,
317 [[maybe_unused]] const DofEntity& dof)
318 {
319 const unsigned dofIdx = model.dofMapper().index(dof);
320 const PrimaryVariables& priVars = model.solution(/*timeIdx=*/0)[dofIdx];
321 outstream << priVars[foamConcentrationIdx];
322 }
323
324 template <class DofEntity>
325 static void deserializeEntity([[maybe_unused]] Model& model,
326 [[maybe_unused]] std::istream& instream,
327 [[maybe_unused]] const DofEntity& dof)
328 {
329 const unsigned dofIdx = model.dofMapper().index(dof);
330 PrimaryVariables& priVars0 = model.solution(/*timeIdx=*/0)[dofIdx];
331 PrimaryVariables& priVars1 = model.solution(/*timeIdx=*/1)[dofIdx];
332
333 instream >> priVars0[foamConcentrationIdx];
334
335 // set the primary variables for the beginning of the current time step.
336 priVars1[foamConcentrationIdx] = priVars0[foamConcentrationIdx];
337 }
338
339 static const Scalar foamRockDensity(const ElementContext& elemCtx,
340 unsigned scvIdx,
341 unsigned timeIdx)
342 {
343 const unsigned satnumRegionIdx = elemCtx.problem().satnumRegionIndex(elemCtx, scvIdx, timeIdx);
344 return params_.foamRockDensity_[satnumRegionIdx];
345 }
346
347 static bool foamAllowDesorption(const ElementContext& elemCtx,
348 unsigned scvIdx,
349 unsigned timeIdx)
350 {
351 const unsigned satnumRegionIdx = elemCtx.problem().satnumRegionIndex(elemCtx, scvIdx, timeIdx);
352 return params_.foamAllowDesorption_[satnumRegionIdx];
353 }
354
355 static const TabulatedFunction& adsorbedFoamTable(const ElementContext& elemCtx,
356 unsigned scvIdx,
357 unsigned timeIdx)
358 {
359 const unsigned satnumRegionIdx = elemCtx.problem().satnumRegionIndex(elemCtx, scvIdx, timeIdx);
360 return params_.adsorbedFoamTable_[satnumRegionIdx];
361 }
362
363 static const TabulatedFunction& gasMobilityMultiplierTable(const ElementContext& elemCtx,
364 unsigned scvIdx,
365 unsigned timeIdx)
366 {
367 const unsigned pvtnumRegionIdx = elemCtx.problem().pvtRegionIndex(elemCtx, scvIdx, timeIdx);
368 return params_.gasMobilityMultiplierTable_[pvtnumRegionIdx];
369 }
370
372 foamCoefficients(const ElementContext& elemCtx,
373 const unsigned scvIdx,
374 const unsigned timeIdx)
375 {
376 const unsigned satnumRegionIdx = elemCtx.problem().satnumRegionIndex(elemCtx, scvIdx, timeIdx);
377 return params_.foamCoefficients_[satnumRegionIdx];
378 }
379
380 static Scalar foamRockDensity(unsigned satnumRegionIdx)
381 { return params_.foamRockDensity_[satnumRegionIdx]; }
382
383 static bool foamAllowDesorption(unsigned satnumRegionIdx)
384 { return params_.foamAllowDesorption_[satnumRegionIdx]; }
385
386 static const TabulatedFunction& adsorbedFoamTable(unsigned satnumRegionIdx)
387 { return params_.adsorbedFoamTable_[satnumRegionIdx]; }
388
389 static const TabulatedFunction& gasMobilityMultiplierTable(unsigned pvtnumRegionIdx)
390 { return params_.gasMobilityMultiplierTable_[pvtnumRegionIdx]; }
391
393 foamCoefficients(unsigned satnumRegionIdx)
394 { return params_.foamCoefficients_[satnumRegionIdx]; }
395
397 { return params_.transport_phase_; }
398
399private:
400 static BlackOilFoamParams<Scalar> params_;
401};
402
403template <class TypeTag>
404BlackOilFoamParams<typename BlackOilFoamModule<TypeTag, true>::Scalar>
405BlackOilFoamModule<TypeTag, true>::params_;
406
414template <class TypeTag>
415class BlackOilFoamIntensiveQuantities<TypeTag, /*enableFoam=*/true>
416{
418
427
429
430 static constexpr bool enableSolvent = getPropValue<TypeTag, Properties::EnableSolvent>();
431
432 static constexpr unsigned foamConcentrationIdx = Indices::foamConcentrationIdx;
433 static constexpr unsigned waterPhaseIdx = FluidSystem::waterPhaseIdx;
434 static constexpr unsigned oilPhaseIdx = FluidSystem::oilPhaseIdx;
435 static constexpr int gasPhaseIdx = FluidSystem::gasPhaseIdx;
436
437public:
443 void foamPropertiesUpdate_(const Problem& problem,
444 const PrimaryVariables& priVars,
445 const unsigned globalSpaceIdx,
446 const unsigned timeIdx)
447 {
448 const auto linearizationType = problem.model().linearizer().getLinearizationType();
449 const unsigned satnumRegionIdx = problem.satnumRegionIndex(globalSpaceIdx);
450 foamConcentration_
451 = priVars.makeEvaluation(foamConcentrationIdx, timeIdx, linearizationType);
452 const auto& fs = asImp_().fluidState_;
453
454 // Compute gas mobility reduction factor
455 Evaluation mobilityReductionFactor = 1.0;
456 if constexpr (false) {
457 // The functional model is used.
458 // TODO: allow this model.
459 // In order to do this we must allow transport to be in the water phase, not just the gas phase.
460 const auto& foamCoefficients = FoamModule::foamCoefficients(satnumRegionIdx);
461
462 const Scalar fm_mob = foamCoefficients.fm_mob;
463
464 const Scalar fm_surf = foamCoefficients.fm_surf;
465 const Scalar ep_surf = foamCoefficients.ep_surf;
466
467 const Scalar fm_oil = foamCoefficients.fm_oil;
468 const Scalar fl_oil = foamCoefficients.fl_oil;
469 const Scalar ep_oil = foamCoefficients.ep_oil;
470
471 const Scalar fm_dry = foamCoefficients.fm_dry;
472 const Scalar ep_dry = foamCoefficients.ep_dry;
473
474 const Scalar fm_cap = foamCoefficients.fm_cap;
475 const Scalar ep_cap = foamCoefficients.ep_cap;
476
477 const Evaluation C_surf = foamConcentration_;
478 const Evaluation Ca = 1e10; // TODO: replace with proper capillary number.
479 const Evaluation S_o = fs.saturation(oilPhaseIdx);
480 const Evaluation S_w = fs.saturation(waterPhaseIdx);
481
482 const Evaluation F1 = pow(C_surf / fm_surf, ep_surf);
483 const Evaluation F2 = pow((fm_oil - S_o) / (fm_oil - fl_oil), ep_oil);
484 const Evaluation F3 = pow(fm_cap / Ca, ep_cap);
485 const Evaluation F7 = 0.5 + atan(ep_dry * (S_w - fm_dry)) / std::numbers::pi_v<Scalar>;
486
487 mobilityReductionFactor = 1. / (1. + fm_mob * F1 * F2 * F3 * F7);
488 } else {
489 // The tabular model is used.
490 // Note that the current implementation only includes the effect of foam concentration (FOAMMOB),
491 // and not the optional pressure dependence (FOAMMOBP) or shear dependence (FOAMMOBS).
492 const auto& gasMobilityMultiplier
493 = FoamModule::gasMobilityMultiplierTable(problem.pvtRegionIndex(globalSpaceIdx));
494 mobilityReductionFactor = gasMobilityMultiplier.eval(foamConcentration_, /* extrapolate = */ true);
495 }
496
497 // adjust mobility
498 switch (FoamModule::transportPhase()) {
499 case Phase::WATER:
500 asImp_().mobility_[waterPhaseIdx] *= mobilityReductionFactor;
501 break;
502 case Phase::GAS:
503 asImp_().mobility_[gasPhaseIdx] *= mobilityReductionFactor;
504 break;
505 case Phase::SOLVENT:
506 if constexpr (enableSolvent) {
507 asImp_().solventMobility_ *= mobilityReductionFactor;
508 } else {
509 throw std::runtime_error("Foam transport phase is SOLVENT but SOLVENT is not activated.");
510 }
511 break;
512 default:
513 throw std::runtime_error("Foam transport phase must be GAS/WATER/SOLVENT.");
514 }
515
516 foamRockDensity_ = FoamModule::foamRockDensity(satnumRegionIdx);
517
518 const auto& adsorbedFoamTable = FoamModule::adsorbedFoamTable(satnumRegionIdx);
519 foamAdsorbed_ = adsorbedFoamTable.eval(foamConcentration_, /*extrapolate=*/true);
520 if (!FoamModule::foamAllowDesorption(satnumRegionIdx)) {
521 throw std::runtime_error("Foam module does not support the 'no desorption' option.");
522 }
523 }
524
525 void foamPropertiesUpdate_(const ElementContext& elemCtx,
526 unsigned dofIdx,
527 unsigned timeIdx)
528 {
529 foamPropertiesUpdate_(elemCtx.problem(),
530 elemCtx.primaryVars(dofIdx, timeIdx),
531 elemCtx.globalSpaceIndex(dofIdx, timeIdx),
532 timeIdx);
533 }
534
535 const Evaluation& foamConcentration() const
536 { return foamConcentration_; }
537
538 Scalar foamRockDensity() const
539 { return foamRockDensity_; }
540
541 const Evaluation& foamAdsorbed() const
542 { return foamAdsorbed_; }
543
544protected:
545 Implementation& asImp_()
546 { return *static_cast<Implementation*>(this); }
547
550 Evaluation foamAdsorbed_;
551};
552
553} // namespace Opm
554
555#endif
Contains the parameters to extend the black-oil model to include the effects of foam.
Contains classes extending the black-oil model. \detail This file holds dummy definitions,...
Declares the properties required by the black oil model.
Evaluation foamConcentration_
Definition: blackoilfoammodules.hh:548
void foamPropertiesUpdate_(const Problem &problem, const PrimaryVariables &priVars, const unsigned globalSpaceIdx, const unsigned timeIdx)
Update the intensive properties needed to handle polymers from the primary variables.
Definition: blackoilfoammodules.hh:443
void foamPropertiesUpdate_(const ElementContext &elemCtx, unsigned dofIdx, unsigned timeIdx)
Definition: blackoilfoammodules.hh:525
const Evaluation & foamAdsorbed() const
Definition: blackoilfoammodules.hh:541
Scalar foamRockDensity() const
Definition: blackoilfoammodules.hh:538
Evaluation foamAdsorbed_
Definition: blackoilfoammodules.hh:550
Implementation & asImp_()
Definition: blackoilfoammodules.hh:545
const Evaluation & foamConcentration() const
Definition: blackoilfoammodules.hh:535
Scalar foamRockDensity_
Definition: blackoilfoammodules.hh:549
Provides the volumetric quantities required for the equations needed by the polymers extension of the...
Contains the high level supplements required to extend the black oil model to include the effects of ...
Definition: blackoilfoammodules.hh:66
static const TabulatedFunction & adsorbedFoamTable(const ElementContext &elemCtx, unsigned scvIdx, unsigned timeIdx)
Definition: blackoilfoammodules.hh:355
static bool foamAllowDesorption(unsigned satnumRegionIdx)
Definition: blackoilfoammodules.hh:383
static Scalar primaryVarWeight(unsigned pvIdx)
Definition: blackoilfoammodules.hh:130
static void deserializeEntity(Model &model, std::istream &instream, const DofEntity &dof)
Definition: blackoilfoammodules.hh:325
static const TabulatedFunction & gasMobilityMultiplierTable(const ElementContext &elemCtx, unsigned scvIdx, unsigned timeIdx)
Definition: blackoilfoammodules.hh:363
static void registerParameters()
Register all run-time parameters for the black-oil foam module.
Definition: blackoilfoammodules.hh:104
static Phase transportPhase()
Definition: blackoilfoammodules.hh:396
static void serializeEntity(const Model &model, std::ostream &outstream, const DofEntity &dof)
Definition: blackoilfoammodules.hh:315
static bool primaryVarApplies(unsigned pvIdx)
Definition: blackoilfoammodules.hh:119
static void computeFlux(RateVector &flux, const ElementContext &elemCtx, unsigned scvfIdx, unsigned timeIdx)
Definition: blackoilfoammodules.hh:200
static const BlackOilFoamParams< Scalar >::FoamCoefficients & foamCoefficients(unsigned satnumRegionIdx)
Definition: blackoilfoammodules.hh:393
static bool eqApplies(unsigned eqIdx)
Definition: blackoilfoammodules.hh:138
static Scalar eqWeight(unsigned eqIdx)
Definition: blackoilfoammodules.hh:150
static Scalar foamRockDensity(unsigned satnumRegionIdx)
Definition: blackoilfoammodules.hh:380
static const TabulatedFunction & gasMobilityMultiplierTable(unsigned pvtnumRegionIdx)
Definition: blackoilfoammodules.hh:389
static Scalar computeUpdateError(const PrimaryVariables &, const EqVector &)
Return how much a Newton-Raphson update is considered an error.
Definition: blackoilfoammodules.hh:306
static void registerOutputModules(Model &, Simulator &)
Register all foam specific VTK and ECL output modules.
Definition: blackoilfoammodules.hh:110
static std::string primaryVarName(unsigned pvIdx)
Definition: blackoilfoammodules.hh:124
static OPM_HOST_DEVICE void addStorage(StorageType &storage, const IntensiveQuantities &intQuants)
Definition: blackoilfoammodules.hh:160
static void addFoamSolventFluxes_(RateVector &flux, const Evaluation &solventVolumeFlux, const IntensiveQuantities &up)
Add the foam flux carried by the solvent over a face.
Definition: blackoilfoammodules.hh:292
static std::string eqName(unsigned eqIdx)
Definition: blackoilfoammodules.hh:143
static const Scalar foamRockDensity(const ElementContext &elemCtx, unsigned scvIdx, unsigned timeIdx)
Definition: blackoilfoammodules.hh:339
static void setParams(BlackOilFoamParams< Scalar > &&params)
Set parameters.
Definition: blackoilfoammodules.hh:96
static const BlackOilFoamParams< Scalar >::FoamCoefficients & foamCoefficients(const ElementContext &elemCtx, const unsigned scvIdx, const unsigned timeIdx)
Definition: blackoilfoammodules.hh:372
static const TabulatedFunction & adsorbedFoamTable(unsigned satnumRegionIdx)
Definition: blackoilfoammodules.hh:386
static void addFoamFluxes_(RateVector &flux, const unsigned phaseIdx, const Evaluation &volumeFlux, const IntensiveQuantities &up)
Add the foam flux carried by the water or gas phase over a face.
Definition: blackoilfoammodules.hh:268
static bool foamAllowDesorption(const ElementContext &elemCtx, unsigned scvIdx, unsigned timeIdx)
Definition: blackoilfoammodules.hh:347
Definition: blackoilfoammodules.hh:57
Declare the properties used by the infrastructure code of the finite volume discretizations.
Declare the properties used by the infrastructure code of the finite volume discretizations.
Phase
Phase indices for reservoir coupling, we currently only support black-oil phases (oil,...
Definition: ReservoirCoupling.hpp:184
Definition: blackoilbioeffectsmodules.hh:45
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: blackoilfoamparams.hpp:60
Struct holding the parameters for the BlackoilFoamModule class.
Definition: blackoilfoamparams.hpp:44
Tabulated1DFunction< Scalar > TabulatedFunction
Definition: blackoilfoamparams.hpp:45