28#ifndef EWOMS_BLACK_OIL_LOCAL_TPFA_RESIDUAL_HH
29#define EWOMS_BLACK_OIL_LOCAL_TPFA_RESIDUAL_HH
31#include <opm/input/eclipse/EclipseState/Grid/FaceDir.hpp>
32#include <opm/input/eclipse/Schedule/BCProp.hpp>
34#include <opm/material/common/MathToolbox.hpp>
35#include <opm/material/fluidstates/BlackOilFluidState.hpp>
36#include <opm/material/common/ConditionalStorage.hpp>
61template <
class TypeTag>
74 using FluidState =
typename IntensiveQuantities::FluidState;
76 enum { conti0EqIdx = Indices::conti0EqIdx };
77 enum { numEq = getPropValue<TypeTag, Properties::NumEq>() };
78 enum { numPhases = getPropValue<TypeTag, Properties::NumPhases>() };
79 enum { numComponents = getPropValue<TypeTag, Properties::NumComponents>() };
81 enum { dimWorld = GridView::dimensionworld };
82 enum { gasPhaseIdx = FluidSystem::gasPhaseIdx };
83 enum { oilPhaseIdx = FluidSystem::oilPhaseIdx };
84 enum { waterPhaseIdx = FluidSystem::waterPhaseIdx };
86 enum { gasCompIdx = FluidSystem::gasCompIdx };
87 enum { oilCompIdx = FluidSystem::oilCompIdx };
88 enum { waterCompIdx = FluidSystem::waterCompIdx };
89 enum { compositionSwitchIdx = Indices::compositionSwitchIdx };
91 static constexpr bool waterEnabled = Indices::waterEnabled;
92 static constexpr bool gasEnabled = Indices::gasEnabled;
93 static constexpr bool oilEnabled = Indices::oilEnabled;
94 static constexpr bool compositionSwitchEnabled = compositionSwitchIdx >= 0;
96 static constexpr bool blackoilConserveSurfaceVolume =
97 getPropValue<TypeTag, Properties::BlackoilConserveSurfaceVolume>();
99 static constexpr bool enableSolvent = getPropValue<TypeTag, Properties::EnableSolvent>();
100 static constexpr bool enableExtbo = getPropValue<TypeTag, Properties::EnableExtbo>();
101 static constexpr bool enablePolymer = getPropValue<TypeTag, Properties::EnablePolymer>();
102 static constexpr bool enableEnergy = getPropValue<TypeTag, Properties::EnableEnergy>();
103 static constexpr bool enableFoam = getPropValue<TypeTag, Properties::EnableFoam>();
104 static constexpr bool enableBrine = getPropValue<TypeTag, Properties::EnableBrine>();
105 static constexpr bool enableDiffusion = getPropValue<TypeTag, Properties::EnableDiffusion>();
106 static constexpr bool enableDispersion = getPropValue<TypeTag, Properties::EnableDispersion>();
107 static constexpr bool enableConvectiveMixing = getPropValue<TypeTag, Properties::EnableConvectiveMixing>();
108 static constexpr bool enableBioeffects = getPropValue<TypeTag, Properties::EnableBioeffects>();
109 static constexpr bool enableMICP = Indices::enableMICP;
119 using ConvectiveMixingModuleParam =
typename ConvectiveMixingModule::ConvectiveMixingModuleParam;
124 using Toolbox = MathToolbox<Evaluation>;
136 ConditionalStorage<enableEnergy, double>
inAlpha;
150 template <
class LhsEval>
152 const ElementContext& elemCtx,
154 unsigned timeIdx)
const
156 const IntensiveQuantities& intQuants = elemCtx.intensiveQuantities(dofIdx, timeIdx);
160 template <
class LhsEval>
162 const IntensiveQuantities& intQuants)
166 const auto& fs = intQuants.fluidState();
169 for (
unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
170 if (!FluidSystem::phaseIsActive(phaseIdx)) {
173 unsigned activeCompIdx =
174 FluidSystem::canonicalToActiveCompIdx(FluidSystem::solventComponentIndex(phaseIdx));
175 LhsEval surfaceVolume =
176 Toolbox::template decay<LhsEval>(fs.saturation(phaseIdx)) *
177 Toolbox::template decay<LhsEval>(fs.invB(phaseIdx)) *
178 Toolbox::template decay<LhsEval>(intQuants.porosity());
180 storage[conti0EqIdx + activeCompIdx] += surfaceVolume;
183 if (phaseIdx == oilPhaseIdx && FluidSystem::enableDissolvedGas()) {
184 unsigned activeGasCompIdx = FluidSystem::canonicalToActiveCompIdx(gasCompIdx);
185 storage[conti0EqIdx + activeGasCompIdx] +=
186 Toolbox::template decay<LhsEval>(intQuants.fluidState().Rs()) *
191 if (phaseIdx == waterPhaseIdx && FluidSystem::enableDissolvedGasInWater()) {
192 unsigned activeGasCompIdx = FluidSystem::canonicalToActiveCompIdx(gasCompIdx);
193 storage[conti0EqIdx + activeGasCompIdx] +=
194 Toolbox::template decay<LhsEval>(intQuants.fluidState().Rsw()) *
199 if (phaseIdx == gasPhaseIdx && FluidSystem::enableVaporizedOil()) {
200 unsigned activeOilCompIdx = FluidSystem::canonicalToActiveCompIdx(oilCompIdx);
201 storage[conti0EqIdx + activeOilCompIdx] +=
202 Toolbox::template decay<LhsEval>(intQuants.fluidState().Rv()) *
207 if (phaseIdx == gasPhaseIdx && FluidSystem::enableVaporizedWater()) {
208 unsigned activeWaterCompIdx = FluidSystem::canonicalToActiveCompIdx(waterCompIdx);
209 storage[conti0EqIdx + activeWaterCompIdx] +=
210 Toolbox::template decay<LhsEval>(intQuants.fluidState().Rvw()) *
246 const unsigned globalIndexIn,
247 const unsigned globalIndexEx,
248 const IntensiveQuantities& intQuantsIn,
249 const IntensiveQuantities& intQuantsEx,
253 OPM_TIMEBLOCK_LOCAL(
computeFlux, Subsystem::Assembly);
271 const ElementContext& elemCtx,
275 OPM_TIMEBLOCK_LOCAL(
computeFlux, Subsystem::Assembly);
276 assert(timeIdx == 0);
279 RateVector darcy = 0.0;
281 const auto& problem = elemCtx.problem();
282 const auto& stencil = elemCtx.stencil(timeIdx);
283 const auto& scvf = stencil.interiorFace(scvfIdx);
285 unsigned interiorDofIdx = scvf.interiorIndex();
286 unsigned exteriorDofIdx = scvf.exteriorIndex();
287 assert(interiorDofIdx != exteriorDofIdx);
291 Scalar Vin = elemCtx.dofVolume(interiorDofIdx, 0);
292 Scalar Vex = elemCtx.dofVolume(exteriorDofIdx, 0);
293 const auto& globalIndexIn = stencil.globalSpaceIndex(interiorDofIdx);
294 const auto& globalIndexEx = stencil.globalSpaceIndex(exteriorDofIdx);
295 Scalar trans = problem.transmissibility(elemCtx, interiorDofIdx, exteriorDofIdx);
296 Scalar faceArea = scvf.area();
298 Scalar thpres = problem.thresholdPressure(globalIndexIn, globalIndexEx);
303 const Scalar g = problem.gravity()[dimWorld - 1];
304 const auto& intQuantsIn = elemCtx.intensiveQuantities(interiorDofIdx, timeIdx);
305 const auto& intQuantsEx = elemCtx.intensiveQuantities(exteriorDofIdx, timeIdx);
312 const Scalar zIn = problem.dofCenterDepth(elemCtx, interiorDofIdx, timeIdx);
313 const Scalar zEx = problem.dofCenterDepth(elemCtx, exteriorDofIdx, timeIdx);
316 const Scalar distZ = zIn - zEx;
318 const Scalar inAlpha = problem.thermalHalfTransmissibility(globalIndexIn, globalIndexEx);
319 const Scalar outAlpha = problem.thermalHalfTransmissibility(globalIndexEx, globalIndexIn);
320 const Scalar diffusivity = problem.diffusivity(globalIndexEx, globalIndexIn);
321 const Scalar dispersivity = problem.dispersivity(globalIndexEx, globalIndexIn);
324 trans, faceArea, thpres, distZ * g, faceDir, Vin, Vex,
325 inAlpha, outAlpha, diffusivity, dispersivity
335 problem.moduleParams());
340 const IntensiveQuantities& intQuantsIn,
341 const IntensiveQuantities& intQuantsEx,
342 const unsigned& globalIndexIn,
343 const unsigned& globalIndexEx,
347 OPM_TIMEBLOCK_LOCAL(calculateFluxes, Subsystem::Assembly);
348 const Scalar Vin = nbInfo.
Vin;
349 const Scalar Vex = nbInfo.
Vex;
350 const Scalar distZg = nbInfo.
dZg;
351 const Scalar thpres = nbInfo.
thpres;
352 const Scalar trans = nbInfo.
trans;
353 const Scalar faceArea = nbInfo.
faceArea;
354 FaceDir::DirEnum facedir = nbInfo.
faceDir;
356 for (
unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
357 if (!FluidSystem::phaseIsActive(phaseIdx)) {
365 short interiorDofIdx = 0;
366 short exteriorDofIdx = 1;
367 Evaluation pressureDifference;
368 ExtensiveQuantities::calculatePhasePressureDiff_(upIdx,
384 const IntensiveQuantities& up = (upIdx == interiorDofIdx) ? intQuantsIn : intQuantsEx;
385 unsigned globalUpIndex = (upIdx == interiorDofIdx) ? globalIndexIn : globalIndexEx;
387 Evaluation transMult = (intQuantsIn.rockCompTransMultiplier() +
388 Toolbox::value(intQuantsEx.rockCompTransMultiplier())) / 2;
389 if constexpr (enableBioeffects) {
390 transMult *= (intQuantsIn.permFactor() + Toolbox::value(intQuantsEx.permFactor())) / 2;
392 Evaluation darcyFlux;
393 if (globalUpIndex == globalIndexIn) {
394 darcyFlux = pressureDifference * up.mobility(phaseIdx, facedir) * transMult * (-trans / faceArea);
396 darcyFlux = pressureDifference *
397 (Toolbox::value(up.mobility(phaseIdx, facedir)) * transMult * (-trans / faceArea));
400 unsigned activeCompIdx =
401 FluidSystem::canonicalToActiveCompIdx(FluidSystem::solventComponentIndex(phaseIdx));
403 darcy[conti0EqIdx + activeCompIdx] = darcyFlux.value() * faceArea;
405 unsigned pvtRegionIdx = up.pvtRegionIndex();
407 if (globalUpIndex == globalIndexIn) {
409 = getInvB_<FluidSystem, FluidState, Evaluation>(up.fluidState(), phaseIdx, pvtRegionIdx);
410 const auto& surfaceVolumeFlux = invB * darcyFlux;
411 evalPhaseFluxes_<Evaluation>(flux, phaseIdx, pvtRegionIdx, surfaceVolumeFlux, up.fluidState());
412 if constexpr (enableEnergy) {
413 EnergyModule::template
414 addPhaseEnthalpyFluxes_<Evaluation>(flux, phaseIdx, darcyFlux, up.fluidState());
416 if constexpr (enableBioeffects) {
417 BioeffectsModule::template
418 addBioeffectsFluxes_<Evaluation>(flux, phaseIdx, darcyFlux, up);
420 if constexpr (enableBrine) {
421 BrineModule::template
422 addBrineFluxes_<Evaluation, FluidState>(flux, phaseIdx, darcyFlux, up.fluidState());
425 const auto& invB = getInvB_<FluidSystem, FluidState, Scalar>(up.fluidState(), phaseIdx, pvtRegionIdx);
426 const auto& surfaceVolumeFlux = invB * darcyFlux;
427 evalPhaseFluxes_<Scalar>(flux, phaseIdx, pvtRegionIdx, surfaceVolumeFlux, up.fluidState());
428 if constexpr (enableEnergy) {
429 EnergyModule::template
430 addPhaseEnthalpyFluxes_<Scalar>(flux, phaseIdx, darcyFlux, up.fluidState());
432 if constexpr (enableBioeffects) {
433 BioeffectsModule::template
434 addBioeffectsFluxes_<Scalar>(flux, phaseIdx, darcyFlux, up);
436 if constexpr (enableBrine) {
437 BrineModule::template
438 addBrineFluxes_<Scalar, FluidState>(flux, phaseIdx, darcyFlux, up.fluidState());
444 static_assert(!enableSolvent,
445 "Relevant computeFlux() method must be implemented for this module before enabling.");
449 static_assert(!enableExtbo,
450 "Relevant computeFlux() method must be implemented for this module before enabling.");
454 static_assert(!enablePolymer,
455 "Relevant computeFlux() method must be implemented for this module before enabling.");
459 if constexpr (enableConvectiveMixing) {
460 ConvectiveMixingModule::addConvectiveMixingFlux(flux,
472 if constexpr (enableEnergy) {
473 const Scalar inAlpha = nbInfo.
inAlpha;
474 const Scalar outAlpha = nbInfo.
outAlpha;
477 short interiorDofIdx = 0;
478 short exteriorDofIdx = 1;
480 EnergyModule::ExtensiveQuantities::updateEnergy(heatFlux,
486 intQuantsIn.fluidState(),
487 intQuantsEx.fluidState(),
497 static_assert(!enableFoam,
498 "Relevant computeFlux() method must be implemented for this module before enabling.");
502 if constexpr (enableDiffusion) {
503 typename DiffusionModule::ExtensiveQuantities::EvaluationArray effectiveDiffusionCoefficient;
504 DiffusionModule::ExtensiveQuantities::update(effectiveDiffusionCoefficient, intQuantsIn, intQuantsEx);
506 const Scalar tmpdiffusivity = diffusivity / faceArea;
507 DiffusionModule::addDiffusiveFlux(flux,
511 effectiveDiffusionCoefficient);
515 if constexpr (enableDispersion) {
516 typename DispersionModule::ExtensiveQuantities::ScalarArray normVelocityAvg;
517 DispersionModule::ExtensiveQuantities::update(normVelocityAvg, intQuantsIn, intQuantsEx);
519 const Scalar tmpdispersivity = dispersivity / faceArea;
520 DispersionModule::addDispersiveFlux(flux,
528 if constexpr (enableMICP) {
533 template <
class BoundaryConditionData>
535 const Problem& problem,
536 const BoundaryConditionData& bdyInfo,
537 const IntensiveQuantities& insideIntQuants,
538 unsigned globalSpaceIdx)
540 switch (bdyInfo.type) {
548 case BCType::DIRICHLET:
551 case BCType::THERMAL:
555 throw std::logic_error(
"Unknown boundary condition type " +
557 " in computeBoundaryFlux()." );
561 template <
class BoundaryConditionData>
563 const BoundaryConditionData& bdyInfo)
565 bdyFlux.setMassRate(bdyInfo.massRate, bdyInfo.pvtRegionIdx);
568 template <
class BoundaryConditionData>
571 const BoundaryConditionData& bdyInfo,
572 const IntensiveQuantities& insideIntQuants,
573 unsigned globalSpaceIdx)
576 std::array<short, numPhases> upIdx;
577 std::array<short, numPhases> dnIdx;
578 std::array<Evaluation, numPhases> volumeFlux;
579 std::array<Evaluation, numPhases> pressureDifference;
581 ExtensiveQuantities::calculateBoundaryGradients_(problem,
584 bdyInfo.boundaryFaceIndex,
587 bdyInfo.exFluidState,
597 for (
unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
598 if (!FluidSystem::phaseIsActive(phaseIdx)) {
601 const auto& pBoundary = bdyInfo.exFluidState.pressure(phaseIdx);
602 const Evaluation& pInside = insideIntQuants.fluidState().pressure(phaseIdx);
603 const unsigned pvtRegionIdx = insideIntQuants.pvtRegionIndex();
606 const auto& darcyFlux = volumeFlux[phaseIdx];
608 if (pBoundary < pInside) {
611 getInvB_<FluidSystem, FluidState, Evaluation>(insideIntQuants.fluidState(), phaseIdx, pvtRegionIdx);
612 Evaluation surfaceVolumeFlux = invB * darcyFlux;
613 evalPhaseFluxes_<Evaluation>(tmp,
615 insideIntQuants.pvtRegionIndex(),
617 insideIntQuants.fluidState());
618 if constexpr (enableEnergy) {
619 EnergyModule::template
620 addPhaseEnthalpyFluxes_<Evaluation>(tmp, phaseIdx, darcyFlux, insideIntQuants.fluidState());
622 }
else if (pBoundary > pInside) {
624 using ScalarFluidState =
decltype(bdyInfo.exFluidState);
626 getInvB_<FluidSystem, ScalarFluidState, Scalar>(bdyInfo.exFluidState, phaseIdx, pvtRegionIdx);
627 Evaluation surfaceVolumeFlux = invB * darcyFlux;
628 evalPhaseFluxes_<Scalar>(tmp,
630 insideIntQuants.pvtRegionIndex(),
632 bdyInfo.exFluidState);
633 if constexpr (enableEnergy) {
634 EnergyModule::template
635 addPhaseEnthalpyFluxes_<Scalar>(tmp, phaseIdx, darcyFlux, bdyInfo.exFluidState);
639 for (
unsigned i = 0; i < tmp.size(); ++i) {
640 bdyFlux[i] += tmp[i];
645 if constexpr (enableEnergy) {
649 problem.eclTransmissibilities().thermalHalfTransBoundary(globalSpaceIdx, bdyInfo.boundaryFaceIndex);
652 EnergyModule::ExtensiveQuantities::updateEnergyBoundary(heatFlux,
657 bdyInfo.exFluidState);
661 static_assert(!enableSolvent,
662 "Relevant treatment of boundary conditions must be implemented before enabling.");
663 static_assert(!enablePolymer,
664 "Relevant treatment of boundary conditions must be implemented before enabling.");
670 for (
unsigned i = 0; i < numEq; ++i) {
671 Valgrind::CheckDefined(bdyFlux[i]);
673 Valgrind::CheckDefined(bdyFlux);
677 template <
class BoundaryConditionData>
680 const BoundaryConditionData& bdyInfo,
681 const IntensiveQuantities& insideIntQuants,
682 [[maybe_unused]]
unsigned globalSpaceIdx)
689 if constexpr (enableEnergy) {
693 problem.eclTransmissibilities().thermalHalfTransBoundary(globalSpaceIdx, bdyInfo.boundaryFaceIndex);
696 EnergyModule::ExtensiveQuantities::updateEnergyBoundary(heatFlux,
701 bdyInfo.exFluidState);
706 for (
unsigned i = 0; i < numEq; ++i) {
707 Valgrind::CheckDefined(bdyFlux[i]);
709 Valgrind::CheckDefined(bdyFlux);
714 const Problem& problem,
715 const IntensiveQuantities& insideIntQuants,
716 unsigned globalSpaceIdex,
721 problem.source(source, globalSpaceIdex, timeIdx);
727 if constexpr (enableEnergy) {
728 source[Indices::contiEnergyEqIdx] *= getPropValue<TypeTag, Properties::BlackOilEnergyScalingFactor>();
733 const Problem& problem,
734 const IntensiveQuantities& insideIntQuants,
735 unsigned globalSpaceIdex,
739 problem.addToSourceDense(source, globalSpaceIdex, timeIdx);
745 if constexpr (enableEnergy) {
746 source[Indices::contiEnergyEqIdx] *= getPropValue<TypeTag, Properties::BlackOilEnergyScalingFactor>();
754 const ElementContext& elemCtx,
756 unsigned timeIdx)
const
760 elemCtx.problem().source(source, elemCtx, dofIdx, timeIdx);
766 if constexpr (enableEnergy) {
767 source[Indices::contiEnergyEqIdx] *= getPropValue<TypeTag, Properties::BlackOilEnergyScalingFactor>();
771 template <
class UpEval,
class Flu
idState>
774 unsigned pvtRegionIdx,
775 const ExtensiveQuantities& extQuants,
776 const FluidState& upFs)
778 const auto& invB = getInvB_<FluidSystem, FluidState, UpEval>(upFs, phaseIdx, pvtRegionIdx);
779 const auto& surfaceVolumeFlux = invB * extQuants.volumeFlux(phaseIdx);
780 evalPhaseFluxes_<UpEval>(flux, phaseIdx, pvtRegionIdx, surfaceVolumeFlux, upFs);
787 template <
class UpEval,
class Eval,
class Flu
idState>
790 unsigned pvtRegionIdx,
791 const Eval& surfaceVolumeFlux,
792 const FluidState& upFs)
794 unsigned activeCompIdx =
795 FluidSystem::canonicalToActiveCompIdx(FluidSystem::solventComponentIndex(phaseIdx));
797 if constexpr (blackoilConserveSurfaceVolume) {
798 flux[conti0EqIdx + activeCompIdx] += surfaceVolumeFlux;
801 flux[conti0EqIdx + activeCompIdx] += surfaceVolumeFlux *
802 FluidSystem::referenceDensity(phaseIdx, pvtRegionIdx);
805 if (phaseIdx == oilPhaseIdx) {
807 if (FluidSystem::enableDissolvedGas()) {
808 const auto& Rs = BlackOil::getRs_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
810 const unsigned activeGasCompIdx = FluidSystem::canonicalToActiveCompIdx(gasCompIdx);
811 if constexpr (blackoilConserveSurfaceVolume) {
812 flux[conti0EqIdx + activeGasCompIdx] += Rs * surfaceVolumeFlux;
815 flux[conti0EqIdx + activeGasCompIdx] +=
816 Rs * surfaceVolumeFlux *
817 FluidSystem::referenceDensity(gasPhaseIdx, pvtRegionIdx);
821 else if (phaseIdx == waterPhaseIdx) {
823 if (FluidSystem::enableDissolvedGasInWater()) {
824 const auto& Rsw = BlackOil::getRsw_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
826 const unsigned activeGasCompIdx = FluidSystem::canonicalToActiveCompIdx(gasCompIdx);
827 if constexpr (blackoilConserveSurfaceVolume) {
828 flux[conti0EqIdx + activeGasCompIdx] += Rsw * surfaceVolumeFlux;
831 flux[conti0EqIdx + activeGasCompIdx] +=
832 Rsw * surfaceVolumeFlux *
833 FluidSystem::referenceDensity(gasPhaseIdx, pvtRegionIdx);
837 else if (phaseIdx == gasPhaseIdx) {
839 if (FluidSystem::enableVaporizedOil()) {
840 const auto& Rv = BlackOil::getRv_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
842 const unsigned activeOilCompIdx = FluidSystem::canonicalToActiveCompIdx(oilCompIdx);
843 if constexpr (blackoilConserveSurfaceVolume) {
844 flux[conti0EqIdx + activeOilCompIdx] += Rv * surfaceVolumeFlux;
847 flux[conti0EqIdx + activeOilCompIdx] +=
848 Rv * surfaceVolumeFlux *
849 FluidSystem::referenceDensity(oilPhaseIdx, pvtRegionIdx);
853 if (FluidSystem::enableVaporizedWater()) {
854 const auto& Rvw = BlackOil::getRvw_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
856 const unsigned activeWaterCompIdx = FluidSystem::canonicalToActiveCompIdx(waterCompIdx);
857 if constexpr (blackoilConserveSurfaceVolume) {
858 flux[conti0EqIdx + activeWaterCompIdx] += Rvw * surfaceVolumeFlux;
861 flux[conti0EqIdx + activeWaterCompIdx] +=
862 Rvw * surfaceVolumeFlux *
863 FluidSystem::referenceDensity(waterPhaseIdx, pvtRegionIdx);
880 template <
class Scalar>
882 unsigned pvtRegionIdx)
884 if constexpr (!blackoilConserveSurfaceVolume) {
889 if constexpr (waterEnabled) {
890 const unsigned activeWaterCompIdx = FluidSystem::canonicalToActiveCompIdx(waterCompIdx);
891 container[conti0EqIdx + activeWaterCompIdx] *=
892 FluidSystem::referenceDensity(waterPhaseIdx, pvtRegionIdx);
895 if constexpr (gasEnabled) {
896 const unsigned activeGasCompIdx = FluidSystem::canonicalToActiveCompIdx(gasCompIdx);
897 container[conti0EqIdx + activeGasCompIdx] *=
898 FluidSystem::referenceDensity(gasPhaseIdx, pvtRegionIdx);
901 if constexpr (oilEnabled) {
902 const unsigned activeOilCompIdx = FluidSystem::canonicalToActiveCompIdx(oilCompIdx);
903 container[conti0EqIdx + activeOilCompIdx] *=
904 FluidSystem::referenceDensity(oilPhaseIdx, pvtRegionIdx);
911 {
return dirId < 0 ? FaceDir::DirEnum::Unknown : FaceDir::FromIntersectionIndex(dirId); }
Contains the classes required to extend the black-oil model by bioeffects.
Contains the classes required to extend the black-oil model by brine.
Classes required for dynamic convective mixing.
Classes required for molecular diffusion.
Classes required for mechanical dispersion.
Contains the classes required to extend the black-oil model by energy.
Contains the classes required to extend the black-oil model by solvent component. For details,...
Contains the classes required to extend the black-oil model to include the effects of foam.
Contains the classes required to extend the black-oil model by polymer.
Declares the properties required by the black oil model.
Contains the classes required to extend the black-oil model by solvents.
Contains the high level supplements required to extend the black oil model by bioeffects.
Definition: blackoilbioeffectsmodules.hh:93
static void applyScaling(RateVector &flux)
Definition: blackoilbioeffectsmodules.hh:235
static void addStorage(Dune::FieldVector< LhsEval, numEq > &storage, const IntensiveQuantities &intQuants)
Definition: blackoilbioeffectsmodules.hh:177
static void addSource(RateVector &source, const Problem &problem, const IntensiveQuantities &intQuants, unsigned globalSpaceIdex)
Definition: blackoilbioeffectsmodules.hh:276
Contains the high level supplements required to extend the black oil model by brine.
Definition: blackoilbrinemodules.hh:56
static void addStorage(Dune::FieldVector< LhsEval, numEq > &storage, const IntensiveQuantities &intQuants)
Definition: blackoilbrinemodules.hh:163
Definition: blackoilconvectivemixingmodule.hh:64
Provides the auxiliary methods required for consideration of the diffusion equation.
Definition: blackoildiffusionmodule.hh:50
Provides the auxiliary methods required for consideration of the dispersion equation.
Definition: blackoildispersionmodule.hh:58
Contains the high level supplements required to extend the black oil model by energy.
Definition: blackoilenergymodules.hh:58
static void addStorage(Dune::FieldVector< LhsEval, numEq > &storage, const IntensiveQuantities &intQuants)
Definition: blackoilenergymodules.hh:153
static void addHeatFlux(RateVector &flux, const Evaluation &heatFlux)
Definition: blackoilenergymodules.hh:211
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
Contains the high level supplements required to extend the black oil model to include the effects of ...
Definition: blackoilfoammodules.hh:58
static void addStorage(Dune::FieldVector< LhsEval, numEq > &storage, const IntensiveQuantities &intQuants)
Definition: blackoilfoammodules.hh:164
Calculates the local residual of the black oil model.
Definition: blackoillocalresidualtpfa.hh:63
void computeSource(RateVector &source, const ElementContext &elemCtx, unsigned dofIdx, unsigned timeIdx) const
Calculate the source term of the equation.
Definition: blackoillocalresidualtpfa.hh:753
static void computeBoundaryFlux(RateVector &bdyFlux, const Problem &problem, const BoundaryConditionData &bdyInfo, const IntensiveQuantities &insideIntQuants, unsigned globalSpaceIdx)
Definition: blackoillocalresidualtpfa.hh:534
static void computeBoundaryFluxFree(const Problem &problem, RateVector &bdyFlux, const BoundaryConditionData &bdyInfo, const IntensiveQuantities &insideIntQuants, unsigned globalSpaceIdx)
Definition: blackoillocalresidualtpfa.hh:569
static void computeBoundaryFluxRate(RateVector &bdyFlux, const BoundaryConditionData &bdyInfo)
Definition: blackoillocalresidualtpfa.hh:562
static FaceDir::DirEnum faceDirFromDirId(const int dirId)
Definition: blackoillocalresidualtpfa.hh:910
static void evalPhaseFluxes_(RateVector &flux, unsigned phaseIdx, unsigned pvtRegionIdx, const ExtensiveQuantities &extQuants, const FluidState &upFs)
Definition: blackoillocalresidualtpfa.hh:772
static void computeFlux(RateVector &flux, const ElementContext &elemCtx, unsigned scvfIdx, unsigned timeIdx)
Definition: blackoillocalresidualtpfa.hh:270
static void computeStorage(Dune::FieldVector< LhsEval, numEq > &storage, const IntensiveQuantities &intQuants)
Definition: blackoillocalresidualtpfa.hh:161
static void computeFlux(RateVector &flux, RateVector &darcy, const unsigned globalIndexIn, const unsigned globalIndexEx, const IntensiveQuantities &intQuantsIn, const IntensiveQuantities &intQuantsEx, const ResidualNBInfo &nbInfo, const ModuleParams &moduleParams)
Definition: blackoillocalresidualtpfa.hh:244
static void computeBoundaryThermal(const Problem &problem, RateVector &bdyFlux, const BoundaryConditionData &bdyInfo, const IntensiveQuantities &insideIntQuants, unsigned globalSpaceIdx)
Definition: blackoillocalresidualtpfa.hh:678
static void adaptMassConservationQuantities_(Dune::FieldVector< Scalar, numEq > &container, unsigned pvtRegionIdx)
Helper function to convert the mass-related parts of a Dune::FieldVector that stores conservation qua...
Definition: blackoillocalresidualtpfa.hh:881
static void evalPhaseFluxes_(RateVector &flux, unsigned phaseIdx, unsigned pvtRegionIdx, const Eval &surfaceVolumeFlux, const FluidState &upFs)
Helper function to calculate the flux of mass in terms of conservation quantities via specific fluid ...
Definition: blackoillocalresidualtpfa.hh:788
void computeStorage(Dune::FieldVector< LhsEval, numEq > &storage, const ElementContext &elemCtx, unsigned dofIdx, unsigned timeIdx) const
Evaluate the amount all conservation quantities (e.g. phase mass) within a finite sub-control volume.
Definition: blackoillocalresidualtpfa.hh:151
static void calculateFluxes_(RateVector &flux, RateVector &darcy, const IntensiveQuantities &intQuantsIn, const IntensiveQuantities &intQuantsEx, const unsigned &globalIndexIn, const unsigned &globalIndexEx, const ResidualNBInfo &nbInfo, const ModuleParams &moduleParams)
Definition: blackoillocalresidualtpfa.hh:338
static void computeSource(RateVector &source, const Problem &problem, const IntensiveQuantities &insideIntQuants, unsigned globalSpaceIdex, unsigned timeIdx)
Definition: blackoillocalresidualtpfa.hh:713
static void computeSourceDense(RateVector &source, const Problem &problem, const IntensiveQuantities &insideIntQuants, unsigned globalSpaceIdex, unsigned timeIdx)
Definition: blackoillocalresidualtpfa.hh:732
Contains the high level supplements required to extend the black oil model by polymer.
Definition: blackoilpolymermodules.hh:64
static void addStorage(Dune::FieldVector< LhsEval, numEq > &storage, const IntensiveQuantities &intQuants)
Definition: blackoilpolymermodules.hh:236
Contains the high level supplements required to extend the black oil model by solvents.
Definition: blackoilsolventmodules.hh:68
static void addStorage(Dune::FieldVector< LhsEval, numEq > &storage, const IntensiveQuantities &intQuants)
Definition: blackoilsolventmodules.hh:183
@ NONE
Definition: DeferredLogger.hpp:46
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
std::string to_string(const ConvergenceReport::ReservoirFailure::Type t)
Definition: blackoillocalresidualtpfa.hh:143
ConvectiveMixingModuleParam convectiveMixingModuleParam
Definition: blackoillocalresidualtpfa.hh:144
Definition: blackoillocalresidualtpfa.hh:128
FaceDir::DirEnum faceDir
Definition: blackoillocalresidualtpfa.hh:133
double faceArea
Definition: blackoillocalresidualtpfa.hh:130
ConditionalStorage< enableEnergy, double > inAlpha
Definition: blackoillocalresidualtpfa.hh:136
ConditionalStorage< enableDiffusion, double > diffusivity
Definition: blackoillocalresidualtpfa.hh:138
double dZg
Definition: blackoillocalresidualtpfa.hh:132
double Vin
Definition: blackoillocalresidualtpfa.hh:134
ConditionalStorage< enableDispersion, double > dispersivity
Definition: blackoillocalresidualtpfa.hh:139
double thpres
Definition: blackoillocalresidualtpfa.hh:131
ConditionalStorage< enableEnergy, double > outAlpha
Definition: blackoillocalresidualtpfa.hh:137
double trans
Definition: blackoillocalresidualtpfa.hh:129
double Vex
Definition: blackoillocalresidualtpfa.hh:135