My Project
Loading...
Searching...
No Matches
blackoildiffusionmodule.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 OPM_BLACKOIL_DIFFUSION_MODULE_HH
29#define OPM_BLACKOIL_DIFFUSION_MODULE_HH
30
33
34#include <opm/material/common/Valgrind.hpp>
35
36#include <dune/common/fvector.hh>
37
38#include <stdexcept>
39
40namespace Opm {
41
48template <class TypeTag, bool enableDiffusion>
50
51template <class TypeTag, bool enableDiffusion>
53
57template <class TypeTag>
58class BlackOilDiffusionModule<TypeTag, /*enableDiffusion=*/false>
59{
63
64public:
65
66 #if HAVE_ECL_INPUT
70 static void initFromState(const EclipseState&)
71 {
72 }
73 #endif
74
78 static void registerParameters()
79 {}
80
85 template <class Context>
86 static void addDiffusiveFlux(RateVector&,
87 const Context&,
88 unsigned,
89 unsigned)
90 {}
91};
92
96template <class TypeTag>
97class BlackOilDiffusionModule<TypeTag, /*enableDiffusion=*/true>
98{
105
106 enum { numPhases = FluidSystem::numPhases };
107 enum { numComponents = FluidSystem::numComponents };
108 enum { conti0EqIdx = Indices::conti0EqIdx };
109
110 enum { enableMICP = getPropValue<TypeTag, Properties::EnableMICP>() };
111
112 static constexpr unsigned contiMicrobialEqIdx = Indices::contiMicrobialEqIdx;
113 static constexpr unsigned contiOxygenEqIdx = Indices::contiOxygenEqIdx;
114 static constexpr unsigned waterPhaseIdx = FluidSystem::waterPhaseIdx;
115 static constexpr unsigned contiUreaEqIdx = Indices::contiUreaEqIdx;
116
117 using Toolbox = MathToolbox<Evaluation>;
118
119public:
121
122
123 #if HAVE_ECL_INPUT
127 static void initFromState(const EclipseState& eclState)
128 {
129 use_mole_fraction_ = eclState.getTableManager().diffMoleFraction();
130 }
131 #endif
132
136 static void registerParameters()
137 {}
138
161 template <class Context>
162 static void addDiffusiveFlux(RateVector& flux, const Context& context,
163 unsigned spaceIdx, unsigned timeIdx)
164 {
165 // Only work if diffusion is enabled run-time by DIFFUSE in the deck
166 if(!FluidSystem::enableDiffusion())
167 return;
168 const auto& extQuants = context.extensiveQuantities(spaceIdx, timeIdx);
169 const auto& inIq = context.intensiveQuantities(extQuants.interiorIndex(), timeIdx);
170 const auto& exIq = context.intensiveQuantities(extQuants.exteriorIndex(), timeIdx);
171 const auto& diffusivity = extQuants.diffusivity();
172 const auto& effectiveDiffusionCoefficient = extQuants.effectiveDiffusionCoefficient();
173 addDiffusiveFlux(flux, inIq, exIq, diffusivity, effectiveDiffusionCoefficient);
174 }
175
176 template<class IntensiveQuantities,class EvaluationArray>
177 static void addDiffusiveFlux(RateVector& flux,
178 const IntensiveQuantities& inIq,
179 const IntensiveQuantities& exIq,
180 const Evaluation& diffusivity,
181 const EvaluationArray& effectiveDiffusionCoefficient)
182 {
183 const auto& inFs = inIq.fluidState();
184 const auto& exFs = exIq.fluidState();
185 Evaluation diffR = 0.0;
186 if constexpr(enableMICP) {
187 // The diffusion coefficients are given for mass concentrations
188 Evaluation bAvg = (inFs.invB(waterPhaseIdx) + Toolbox::value(exFs.invB(waterPhaseIdx))) / 2;
189 diffR = inIq.microbialConcentration() - Toolbox::value(exIq.microbialConcentration());
190 flux[contiMicrobialEqIdx] +=
191 bAvg
192 * diffR
193 * diffusivity
194 * effectiveDiffusionCoefficient[waterPhaseIdx][contiMicrobialEqIdx - 1];
195 diffR = inIq.oxygenConcentration() - Toolbox::value(exIq.oxygenConcentration());
196 flux[contiOxygenEqIdx] +=
197 bAvg
198 * diffR
199 * diffusivity
200 * effectiveDiffusionCoefficient[waterPhaseIdx][contiOxygenEqIdx - 1];
201 diffR = inIq.ureaConcentration() - Toolbox::value(exIq.ureaConcentration());
202 flux[contiUreaEqIdx] +=
203 bAvg
204 * diffR
205 * diffusivity
206 * effectiveDiffusionCoefficient[waterPhaseIdx][contiUreaEqIdx - 1];
207 return;
208 }
209
210 unsigned pvtRegionIndex = inFs.pvtRegionIndex();
211 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
212 if (!FluidSystem::phaseIsActive(phaseIdx)) {
213 continue;
214 }
215
216 // no diffusion in water for blackoil models
217 if (!FluidSystem::enableDissolvedGasInWater() && FluidSystem::waterPhaseIdx == phaseIdx) {
218 continue;
219 }
220
221 // no diffusion in gas phase in water + gas system.
222 if (FluidSystem::gasPhaseIdx == phaseIdx && !FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx)) {
223 continue;
224 }
225
226 // arithmetic mean of the phase's b factor weighed by saturation
227 Evaluation bSAvg = inFs.saturation(phaseIdx) * inFs.invB(phaseIdx);
228 bSAvg += Toolbox::value(exFs.saturation(phaseIdx)) * Toolbox::value(exFs.invB(phaseIdx));
229 bSAvg /= 2;
230
231 // phase not present, skip
232 if(bSAvg < 1.0e-6)
233 continue;
234 Evaluation convFactor = 1.0;
235 if (FluidSystem::enableDissolvedGas() && FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx) && phaseIdx == FluidSystem::oilPhaseIdx) {
236 Evaluation rsAvg = (inFs.Rs() + Toolbox::value(exFs.Rs())) / 2;
237 convFactor = 1.0 / (toFractionGasOil(pvtRegionIndex) + rsAvg);
238 diffR = inFs.Rs() - Toolbox::value(exFs.Rs());
239 }
240 if (FluidSystem::enableVaporizedOil() && FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx) && phaseIdx == FluidSystem::gasPhaseIdx) {
241 Evaluation rvAvg = (inFs.Rv() + Toolbox::value(exFs.Rv())) / 2;
242 convFactor = toFractionGasOil(pvtRegionIndex) / (1.0 + rvAvg*toFractionGasOil(pvtRegionIndex));
243 diffR = inFs.Rv() - Toolbox::value(exFs.Rv());
244 }
245 if (FluidSystem::enableDissolvedGasInWater() && phaseIdx == FluidSystem::waterPhaseIdx) {
246 Evaluation rsAvg = (inFs.Rsw() + Toolbox::value(exFs.Rsw())) / 2;
247 convFactor = 1.0 / (toFractionGasWater(pvtRegionIndex) + rsAvg);
248 diffR = inFs.Rsw() - Toolbox::value(exFs.Rsw());
249 }
250 if (FluidSystem::enableVaporizedWater() && phaseIdx == FluidSystem::gasPhaseIdx) {
251 Evaluation rvAvg = (inFs.Rvw() + Toolbox::value(exFs.Rvw())) / 2;
252 convFactor = toFractionGasWater(pvtRegionIndex)/ (1.0 + rvAvg*toFractionGasWater(pvtRegionIndex));
253 diffR = inFs.Rvw() - Toolbox::value(exFs.Rvw());
254 }
255
256 // mass flux of solvent component (oil in oil or gas in gas)
257 unsigned solventCompIdx = FluidSystem::solventComponentIndex(phaseIdx);
258 unsigned activeSolventCompIdx = Indices::canonicalToActiveComponentIndex(solventCompIdx);
259 flux[conti0EqIdx + activeSolventCompIdx] +=
260 - bSAvg
261 * convFactor
262 * diffR
263 * diffusivity
264 * effectiveDiffusionCoefficient[phaseIdx][solventCompIdx];
265
266 // mass flux of solute component (gas in oil or oil in gas)
267 unsigned soluteCompIdx = FluidSystem::soluteComponentIndex(phaseIdx);
268 unsigned activeSoluteCompIdx = Indices::canonicalToActiveComponentIndex(soluteCompIdx);
269 flux[conti0EqIdx + activeSoluteCompIdx] +=
270 bSAvg
271 * diffR
272 * convFactor
273 * diffusivity
274 * effectiveDiffusionCoefficient[phaseIdx][soluteCompIdx];
275 }
276 }
277
278private:
279 static Scalar toFractionGasOil (unsigned regionIdx) {
280 Scalar mMOil = use_mole_fraction_? FluidSystem::molarMass(FluidSystem::oilCompIdx, regionIdx) : 1;
281 Scalar rhoO = FluidSystem::referenceDensity(FluidSystem::oilPhaseIdx, regionIdx);
282 Scalar mMGas = use_mole_fraction_? FluidSystem::molarMass(FluidSystem::gasCompIdx, regionIdx) : 1;
283 Scalar rhoG = FluidSystem::referenceDensity(FluidSystem::gasPhaseIdx, regionIdx);
284 return rhoO * mMGas / (rhoG * mMOil);
285 }
286 static Scalar toFractionGasWater (unsigned regionIdx) {
287 Scalar mMWater = use_mole_fraction_? FluidSystem::molarMass(FluidSystem::waterCompIdx, regionIdx) : 1;
288 Scalar rhoW = FluidSystem::referenceDensity(FluidSystem::waterPhaseIdx, regionIdx);
289 Scalar mMGas = use_mole_fraction_? FluidSystem::molarMass(FluidSystem::gasCompIdx, regionIdx) : 1;
290 Scalar rhoG = FluidSystem::referenceDensity(FluidSystem::gasPhaseIdx, regionIdx);
291 return rhoW * mMGas / (rhoG * mMWater);
292 }
293
294 static bool use_mole_fraction_;
295};
296
297template <typename TypeTag>
298bool
299BlackOilDiffusionModule<TypeTag, true>::use_mole_fraction_;
300
308template <class TypeTag, bool enableDiffusion>
310
314template <class TypeTag>
315class BlackOilDiffusionIntensiveQuantities<TypeTag, /*enableDiffusion=*/false>
316{
320
321public:
326 Scalar tortuosity(unsigned) const
327 {
328 throw std::logic_error("Method tortuosity() does not make sense "
329 "if diffusion is disabled");
330 }
331
336 Scalar diffusionCoefficient(unsigned, unsigned) const
337 {
338 throw std::logic_error("Method diffusionCoefficient() does not "
339 "make sense if diffusion is disabled");
340 }
341
346 Scalar effectiveDiffusionCoefficient(unsigned, unsigned) const
347 {
348 throw std::logic_error("Method effectiveDiffusionCoefficient() "
349 "does not make sense if diffusion is disabled");
350 }
351
352protected:
357 template <class FluidState>
358 void update_(FluidState&,
359 typename FluidSystem::template ParameterCache<typename FluidState::Scalar>&,
360 const ElementContext&,
361 unsigned,
362 unsigned)
363 { }
364};
365
369template <class TypeTag>
370class BlackOilDiffusionIntensiveQuantities<TypeTag, /*enableDiffusion=*/true>
371{
378
379 enum { numPhases = FluidSystem::numPhases };
380 enum { numComponents = FluidSystem::numComponents };
381 enum { enableMICP = getPropValue<TypeTag, Properties::EnableMICP>() };
382
383 static constexpr unsigned waterPhaseIdx = FluidSystem::waterPhaseIdx;
384
385public:
389
391
393 operator=(const BlackOilDiffusionIntensiveQuantities& rhs)
394 {
395 if (this == &rhs) return *this;
396
397 if (FluidSystem::enableDiffusion()) {
398 std::copy(rhs.tortuosity_, rhs.tortuosity_ + numPhases, tortuosity_);
399 for (size_t i = 0; i < numPhases; ++i) {
400 std::copy(rhs.diffusionCoefficient_[i],
401 rhs.diffusionCoefficient_[i]+numComponents,
402 diffusionCoefficient_[i]);
403 }
404 }
405 return *this;
406 }
411 Evaluation diffusionCoefficient(unsigned phaseIdx, unsigned compIdx) const
412 { return diffusionCoefficient_[phaseIdx][compIdx]; }
413
418 Evaluation tortuosity(unsigned phaseIdx) const
419 { return tortuosity_[phaseIdx]; }
420
425 Evaluation effectiveDiffusionCoefficient(unsigned phaseIdx, unsigned compIdx) const
426 {
427 // For the blackoil model tortuosity is disabled.
428 // TODO add a run-time parameter to enable tortuosity
429 static bool enableTortuosity = false;
431 return tortuosity_[phaseIdx] * diffusionCoefficient_[phaseIdx][compIdx];
432
433 return diffusionCoefficient_[phaseIdx][compIdx];
434 }
435
436protected:
441 template <class FluidState>
442 void update_(FluidState& fluidState,
443 typename FluidSystem::template ParameterCache<typename FluidState::Scalar>& paramCache,
444 const ElementContext& elemCtx,
445 unsigned dofIdx,
446 unsigned timeIdx)
447 {
448 // Only work if diffusion is enabled run-time by DIFFUSE in the deck
449 if(!FluidSystem::enableDiffusion())
450 return;
451 const auto& intQuants = elemCtx.intensiveQuantities(dofIdx, timeIdx);
452 update_(fluidState, paramCache, intQuants);
453 }
454
455 template<class FluidState>
456 void update_(FluidState& fluidState,
457 typename FluidSystem::template ParameterCache<typename FluidState::Scalar>& paramCache,
458 const IntensiveQuantities& intQuants) {
459 using Toolbox = MathToolbox<Evaluation>;
460
461 if constexpr(enableMICP) {
462 unsigned pvtRegionIndex = intQuants.fluidState().pvtRegionIndex();
463 diffusionCoefficient_[waterPhaseIdx][0] = MICPModule::microbialDiffusion(pvtRegionIndex);
464 diffusionCoefficient_[waterPhaseIdx][1] = MICPModule::oxygenDiffusion(pvtRegionIndex);
465 diffusionCoefficient_[waterPhaseIdx][2] = MICPModule::ureaDiffusion(pvtRegionIndex);
466 return;
467 }
468
469 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
470 if (!FluidSystem::phaseIsActive(phaseIdx)) {
471 continue;
472 }
473
474 // no diffusion in water for blackoil models
475 if (!FluidSystem::enableDissolvedGasInWater() && FluidSystem::waterPhaseIdx == phaseIdx) {
476 continue;
477 }
478
479 // Based on Millington, R. J., & Quirk, J. P. (1961).
480 // \Note: it is possible to use NumericalConstants later
481 // constexpr auto& numconst = GetPropValue<TypeTag, Properties::NumericalConstants>;
482 constexpr double myeps = 0.0001; //numconst.blackoildiffusionmoduleeps;
483 const Evaluation& base =
484 Toolbox::max(myeps, //0.0001,
485 intQuants.porosity()
486 * intQuants.fluidState().saturation(phaseIdx));
487 tortuosity_[phaseIdx] =
488 1.0 / (intQuants.porosity() * intQuants.porosity())
489 * Toolbox::pow(base, 10.0/3.0);
490
491 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
492 diffusionCoefficient_[phaseIdx][compIdx] =
493 FluidSystem::diffusionCoefficient(fluidState,
495 phaseIdx,
496 compIdx);
497 }
498 }
499 }
500
501private:
502 Evaluation tortuosity_[numPhases];
503 Evaluation diffusionCoefficient_[numPhases][numComponents];
504};
505
512template <class TypeTag, bool enableDiffusion>
513class BlackOilDiffusionExtensiveQuantities;
514
518template <class TypeTag>
519class BlackOilDiffusionExtensiveQuantities<TypeTag, /*enableDiffusion=*/false>
520{
524
525protected:
530 void update_(const ElementContext&,
531 unsigned,
532 unsigned)
533 {}
534
535 template <class Context, class FluidState>
536 void updateBoundary_(const Context&,
537 unsigned,
538 unsigned,
539 const FluidState&)
540 {}
541
542public:
547 const Scalar& diffusivity() const
548 {
549 throw std::logic_error("The method diffusivity() does not "
550 "make sense if diffusion is disabled.");
551 }
552
560 const Evaluation& effectiveDiffusionCoefficient(unsigned,
561 unsigned) const
562 {
563 throw std::logic_error("The method effectiveDiffusionCoefficient() "
564 "does not make sense if diffusion is disabled.");
565 }
566
567};
568
572template <class TypeTag>
573class BlackOilDiffusionExtensiveQuantities<TypeTag, /*enableDiffusion=*/true>
574{
580 using Toolbox = MathToolbox<Evaluation>;
582
583 enum { dimWorld = GridView::dimensionworld };
585 enum { numComponents = getPropValue<TypeTag, Properties::NumComponents>() };
586 enum { enableMICP = getPropValue<TypeTag, Properties::EnableMICP>() };
587
588 static constexpr unsigned waterPhaseIdx = FluidSystem::waterPhaseIdx;
589
590 using DimVector = Dune::FieldVector<Scalar, dimWorld>;
591 using DimEvalVector = Dune::FieldVector<Evaluation, dimWorld>;
592public:
593 using EvaluationArray = Evaluation[numPhases][numComponents];
594protected:
599 void update_(const ElementContext& elemCtx, unsigned faceIdx, unsigned timeIdx)
600 {
601 // Only work if diffusion is enabled run-time by DIFFUSE in the deck
602 if(!FluidSystem::enableDiffusion())
603 return;
604
605 const auto& stencil = elemCtx.stencil(timeIdx);
606 const auto& face = stencil.interiorFace(faceIdx);
607 const auto& extQuants = elemCtx.extensiveQuantities(faceIdx, timeIdx);
608 const auto& intQuantsInside = elemCtx.intensiveQuantities(extQuants.interiorIndex(), timeIdx);
609 const auto& intQuantsOutside = elemCtx.intensiveQuantities(extQuants.exteriorIndex(), timeIdx);
610
611 const Scalar diffusivity = elemCtx.problem().diffusivity(elemCtx, face.interiorIndex(), face.exteriorIndex());
612 const Scalar faceArea = face.area();
613 diffusivity_ = diffusivity / faceArea;
614 update(effectiveDiffusionCoefficient_, intQuantsInside, intQuantsOutside);
615 Valgrind::CheckDefined(diffusivity_);
616 }
617
618public:
619 static void update(EvaluationArray& effectiveDiffusionCoefficient,
620 const IntensiveQuantities& intQuantsInside,
621 const IntensiveQuantities& intQuantsOutside) {
622 // opm-models expects per area flux
623 // use the arithmetic average for the effective
624 // diffusion coefficients.
625 if constexpr(enableMICP) {
626 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
627 effectiveDiffusionCoefficient[waterPhaseIdx][compIdx] = 0.5 *
628 ( intQuantsInside.effectiveDiffusionCoefficient(waterPhaseIdx, compIdx) +
629 intQuantsOutside.effectiveDiffusionCoefficient(waterPhaseIdx, compIdx) );
630 }
631 return;
632 }
633
634 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
635 if (!FluidSystem::phaseIsActive(phaseIdx)) {
636 continue;
637 }
638 // no diffusion in water for blackoil models
639 if (!FluidSystem::enableDissolvedGasInWater() && FluidSystem::waterPhaseIdx == phaseIdx) {
640 continue;
641 }
642 for (unsigned compIdx = 0; compIdx < numComponents; ++compIdx) {
643 effectiveDiffusionCoefficient[phaseIdx][compIdx] = 0.5 *
644 ( intQuantsInside.effectiveDiffusionCoefficient(phaseIdx, compIdx) +
645 intQuantsOutside.effectiveDiffusionCoefficient(phaseIdx, compIdx) );
646 Valgrind::CheckDefined(effectiveDiffusionCoefficient[phaseIdx][compIdx]);
647 }
648 }
649 }
650protected:
651 template <class Context, class FluidState>
652 void updateBoundary_(const Context&,
653 unsigned,
654 unsigned,
655 const FluidState&)
656 {
657 throw std::runtime_error("Not implemented: Diffusion across boundary not implemented for blackoil");
658 }
659
660public:
667 const Scalar& diffusivity() const
668 { return diffusivity_; }
669
677 const Evaluation& effectiveDiffusionCoefficient(unsigned phaseIdx, unsigned compIdx) const
678 { return effectiveDiffusionCoefficient_[phaseIdx][compIdx]; }
679
680 const auto& effectiveDiffusionCoefficient() const{
681 return effectiveDiffusionCoefficient_;
682 }
683
684private:
685 Scalar diffusivity_;
686 EvaluationArray effectiveDiffusionCoefficient_;
687};
688
689} // namespace Opm
690
691#endif
Contains the classes required to extend the black-oil model by MICP.
const Evaluation & effectiveDiffusionCoefficient(unsigned, unsigned) const
The effective diffusion coeffcient of a component in a fluid phase at the face's integration point.
Definition blackoildiffusionmodule.hh:560
const Scalar & diffusivity() const
The diffusivity the face.
Definition blackoildiffusionmodule.hh:547
void update_(const ElementContext &, unsigned, unsigned)
Update the quantities required to calculate the diffusive mass fluxes.
Definition blackoildiffusionmodule.hh:530
Provides the quantities required to calculate diffusive mass fluxes.
Definition blackoildiffusionmodule.hh:574
const Evaluation & effectiveDiffusionCoefficient(unsigned phaseIdx, unsigned compIdx) const
The effective diffusion coefficient of a component in a fluid phase at the face's integration point.
Definition blackoildiffusionmodule.hh:677
void update_(const ElementContext &elemCtx, unsigned faceIdx, unsigned timeIdx)
Update the quantities required to calculate the diffusive mass fluxes.
Definition blackoildiffusionmodule.hh:599
const Scalar & diffusivity() const
The diffusivity of the face.
Definition blackoildiffusionmodule.hh:667
Provides the quantities required to calculate diffusive mass fluxes.
Definition blackoildiffusionmodule.hh:52
Scalar effectiveDiffusionCoefficient(unsigned, unsigned) const
Returns the effective molecular diffusion coefficient of the porous medium for a component in a phase...
Definition blackoildiffusionmodule.hh:346
Scalar diffusionCoefficient(unsigned, unsigned) const
Returns the molecular diffusion coefficient for a component in a phase.
Definition blackoildiffusionmodule.hh:336
void update_(FluidState &, typename FluidSystem::template ParameterCache< typename FluidState::Scalar > &, const ElementContext &, unsigned, unsigned)
Update the quantities required to calculate diffusive mass fluxes.
Definition blackoildiffusionmodule.hh:358
Scalar tortuosity(unsigned) const
Returns the tortuousity of the sub-domain of a fluid phase in the porous medium.
Definition blackoildiffusionmodule.hh:326
void update_(FluidState &fluidState, typename FluidSystem::template ParameterCache< typename FluidState::Scalar > &paramCache, const ElementContext &elemCtx, unsigned dofIdx, unsigned timeIdx)
Update the quantities required to calculate diffusive mass fluxes.
Definition blackoildiffusionmodule.hh:442
Evaluation diffusionCoefficient(unsigned phaseIdx, unsigned compIdx) const
Returns the molecular diffusion coefficient for a component in a phase.
Definition blackoildiffusionmodule.hh:411
Evaluation tortuosity(unsigned phaseIdx) const
Returns the tortuousity of the sub-domain of a fluid phase in the porous medium.
Definition blackoildiffusionmodule.hh:418
Evaluation effectiveDiffusionCoefficient(unsigned phaseIdx, unsigned compIdx) const
Returns the effective molecular diffusion coefficient of the porous medium for a component in a phase...
Definition blackoildiffusionmodule.hh:425
Provides the volumetric quantities required for the calculation of molecular diffusive fluxes.
Definition blackoildiffusionmodule.hh:309
static void registerParameters()
Register all run-time parameters for the diffusion module.
Definition blackoildiffusionmodule.hh:78
static void addDiffusiveFlux(RateVector &, const Context &, unsigned, unsigned)
Adds the diffusive mass flux flux to the flux vector over a flux integration point.
Definition blackoildiffusionmodule.hh:86
static void addDiffusiveFlux(RateVector &flux, const Context &context, unsigned spaceIdx, unsigned timeIdx)
Adds the mass flux due to molecular diffusion to the flux vector over the integration point.
Definition blackoildiffusionmodule.hh:162
static void registerParameters()
Register all run-time parameters for the diffusion module.
Definition blackoildiffusionmodule.hh:136
Provides the auxiliary methods required for consideration of the diffusion equation.
Definition blackoildiffusionmodule.hh:49
Contains the high level supplements required to extend the black oil model by MICP.
Definition blackoilmicpmodules.hh:49
Declare the properties used by the infrastructure code of the finite volume discretizations.
This file contains a set of helper functions used by VFPProd / VFPInj.
Definition blackoilboundaryratevector.hh:37
constexpr auto getPropValue()
get the value data member of a property
Definition propertysystem.hh:242
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:235