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/BCState.hpp>
34#include <opm/material/common/ConditionalStorage.hpp>
35#include <opm/material/common/MathToolbox.hpp>
36#include <opm/material/fluidstates/BlackOilFluidState.hpp>
45#include <opm/common/ErrorMacros.hpp>
46#include <opm/common/utility/gpuDecorators.hpp>
47#include <opm/common/utility/gpuistl_if_available.hpp>
55#include <opm/common/utility/gpuistl_if_available.hpp>
65template <
class TypeTag>
78 using FluidState =
typename IntensiveQuantities::FluidState;
80 enum { conti0EqIdx = Indices::conti0EqIdx };
81 enum { numEq = getPropValue<TypeTag, Properties::NumEq>() };
82 enum { numPhases = getPropValue<TypeTag, Properties::NumPhases>() };
83 enum { numComponents = getPropValue<TypeTag, Properties::NumComponents>() };
85 enum { dimWorld = GridView::dimensionworld };
86 enum { gasPhaseIdx = FluidSystem::gasPhaseIdx };
87 enum { oilPhaseIdx = FluidSystem::oilPhaseIdx };
88 enum { waterPhaseIdx = FluidSystem::waterPhaseIdx };
90 enum { gasCompIdx = FluidSystem::gasCompIdx };
91 enum { oilCompIdx = FluidSystem::oilCompIdx };
92 enum { waterCompIdx = FluidSystem::waterCompIdx };
93 static constexpr unsigned compositionSwitchIdx = Indices::compositionSwitchIdx;
95 static constexpr bool waterEnabled = Indices::waterEnabled;
96 static constexpr bool gasEnabled = Indices::gasEnabled;
97 static constexpr bool oilEnabled = Indices::oilEnabled;
98 static constexpr bool compositionSwitchEnabled =
99 compositionSwitchIdx != std::numeric_limits<unsigned>::max();
101 static constexpr bool blackoilConserveSurfaceVolume
102 = getPropValue<TypeTag, Properties::BlackoilConserveSurfaceVolume>();
104 static constexpr bool enableSolvent = getPropValue<TypeTag, Properties::EnableSolvent>();
105 static constexpr bool enableExtbo = getPropValue<TypeTag, Properties::EnableExtbo>();
106 static constexpr bool enablePolymer = getPropValue<TypeTag, Properties::EnablePolymer>();
107 static constexpr EnergyModules energyModuleType =
108 getPropValue<TypeTag, Properties::EnergyModuleType>();
109 static constexpr bool enableFullyImplicitThermal =
110 energyModuleType == EnergyModules::FullyImplicitThermal;
111 static constexpr bool enableFoam = getPropValue<TypeTag, Properties::EnableFoam>();
112 static constexpr bool enableBrine = getPropValue<TypeTag, Properties::EnableBrine>();
113 static constexpr bool enableDiffusion = getPropValue<TypeTag, Properties::EnableDiffusion>();
114 static constexpr bool enableDispersion = getPropValue<TypeTag, Properties::EnableDispersion>();
115 static constexpr bool enableConvectiveMixing
116 = getPropValue<TypeTag, Properties::EnableConvectiveMixing>();
117 static constexpr bool enableBioeffects = getPropValue<TypeTag, Properties::EnableBioeffects>();
118 static constexpr bool enableSaltPrecipitation
119 = getPropValue<TypeTag, Properties::EnableSaltPrecipitation>();
120 static constexpr bool enableMICP = Indices::enableMICP;
121 static constexpr bool runAssemblyOnGpu = getPropValue<TypeTag, Properties::RunAssemblyOnGpu>();
123 using BioeffectsModule = BlackOilBioeffectsModule<TypeTag, enableBioeffects>;
124 using BrineModule = BlackOilBrineModule<TypeTag, enableBrine>;
125 using ConvectiveMixingModule = BlackOilConvectiveMixingModule<TypeTag, enableConvectiveMixing>;
129 using ExtboModule = BlackOilExtboModule<TypeTag, enableExtbo>;
131 using SolventModule = BlackOilSolventModule<TypeTag, enableSolvent>;
132 using PolymerModule = BlackOilPolymerModule<TypeTag, enablePolymer>;
135 using Toolbox = MathToolbox<Evaluation>;
147 ConditionalStorage<enableFullyImplicitThermal, double>
inAlpha;
148 ConditionalStorage<enableFullyImplicitThermal, double>
outAlpha;
151 ConditionalStorage<enablePolymer, double>
dist;
157 template <
class LhsEval>
159 const ElementContext& elemCtx,
161 unsigned timeIdx)
const
163 const IntensiveQuantities& intQuants = elemCtx.intensiveQuantities(dofIdx, timeIdx);
164 computeStorage<LhsEval>(storage, intQuants);
167 template <
class LhsEval,
class StorageType,
class IntensiveQuantitiesType = IntensiveQuantities>
169 const IntensiveQuantitiesType& intQuants)
173 const auto& fs = intQuants.fluidState();
176 const FluidSystem& fsys = intQuants.getFluidSystem();
178 for (
unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
179 if (!fsys.phaseIsActive(phaseIdx)) {
182 unsigned activeCompIdx
183 = fsys.canonicalToActiveCompIdx(fsys.solventComponentIndex(phaseIdx));
184 LhsEval surfaceVolume = Toolbox::template decay<LhsEval>(fs.saturation(phaseIdx))
185 * Toolbox::template decay<LhsEval>(fs.invB(phaseIdx))
186 * Toolbox::template decay<LhsEval>(intQuants.porosity());
188 storage[conti0EqIdx + activeCompIdx] += surfaceVolume;
191 if (phaseIdx == oilPhaseIdx && fsys.enableDissolvedGas()) {
192 unsigned activeGasCompIdx = fsys.canonicalToActiveCompIdx(gasCompIdx);
193 storage[conti0EqIdx + activeGasCompIdx]
194 += Toolbox::template decay<LhsEval>(intQuants.fluidState().Rs())
199 if (phaseIdx == waterPhaseIdx && fsys.enableDissolvedGasInWater()) {
200 unsigned activeGasCompIdx = fsys.canonicalToActiveCompIdx(gasCompIdx);
201 storage[conti0EqIdx + activeGasCompIdx]
202 += Toolbox::template decay<LhsEval>(intQuants.fluidState().Rsw())
207 if (phaseIdx == gasPhaseIdx && fsys.enableVaporizedOil()) {
208 unsigned activeOilCompIdx = fsys.canonicalToActiveCompIdx(oilCompIdx);
209 storage[conti0EqIdx + activeOilCompIdx]
210 += Toolbox::template decay<LhsEval>(intQuants.fluidState().Rv())
215 if (phaseIdx == gasPhaseIdx && fsys.enableVaporizedWater()) {
216 unsigned activeWaterCompIdx = fsys.canonicalToActiveCompIdx(waterCompIdx);
217 storage[conti0EqIdx + activeWaterCompIdx]
218 += Toolbox::template decay<LhsEval>(intQuants.fluidState().Rvw())
226 if constexpr (enableSolvent) {
227 SolventModule::addStorage(storage, intQuants);
231 if constexpr (enableExtbo) {
232 ExtboModule::addStorage(storage, intQuants);
236 if constexpr (enablePolymer) {
237 PolymerModule::addStorage(storage, intQuants);
241 if constexpr (enableFullyImplicitThermal) {
242 EnergyModule::addStorage(storage, intQuants);
246 if constexpr (enableFoam) {
247 FoamModule::addStorage(storage, intQuants);
251 if constexpr (enableBrine) {
252 BrineModule::addStorage(storage, intQuants);
256 if constexpr (enableBioeffects) {
257 BioeffectsModule::addStorage(storage, intQuants);
266 template <
class ModuleParamsT,
268 class IntensiveQuantitiesT,
269 class ResidualNBInfoT>
272 const unsigned globalIndexIn,
273 const unsigned globalIndexEx,
274 const IntensiveQuantitiesT& intQuantsIn,
275 const IntensiveQuantitiesT& intQuantsEx,
276 const ResidualNBInfoT& nbInfo,
277 const ModuleParamsT& moduleParams)
279 OPM_TIMEBLOCK_LOCAL(
computeFlux, Subsystem::Assembly);
297 computeFlux(RateVector& flux,
const ElementContext& elemCtx,
unsigned scvfIdx,
unsigned timeIdx)
299 OPM_TIMEBLOCK_LOCAL(
computeFlux, Subsystem::Assembly);
300 assert(timeIdx == 0);
303 RateVector darcy = 0.0;
305 const auto& problem = elemCtx.problem();
306 const auto& stencil = elemCtx.stencil(timeIdx);
307 const auto& scvf = stencil.interiorFace(scvfIdx);
309 unsigned interiorDofIdx = scvf.interiorIndex();
310 unsigned exteriorDofIdx = scvf.exteriorIndex();
311 assert(interiorDofIdx != exteriorDofIdx);
315 Scalar Vin = elemCtx.dofVolume(interiorDofIdx, 0);
316 Scalar Vex = elemCtx.dofVolume(exteriorDofIdx, 0);
317 const auto& globalIndexIn = stencil.globalSpaceIndex(interiorDofIdx);
318 const auto& globalIndexEx = stencil.globalSpaceIndex(exteriorDofIdx);
319 Scalar trans = problem.transmissibility(elemCtx, interiorDofIdx, exteriorDofIdx);
320 Scalar faceArea = scvf.area();
322 Scalar thpresInToEx = problem.thresholdPressure(globalIndexIn, globalIndexEx);
323 Scalar thpresExToIn = problem.thresholdPressure(globalIndexEx, globalIndexIn);
328 const Scalar g = problem.gravity()[dimWorld - 1];
329 const auto& intQuantsIn = elemCtx.intensiveQuantities(interiorDofIdx, timeIdx);
330 const auto& intQuantsEx = elemCtx.intensiveQuantities(exteriorDofIdx, timeIdx);
337 const Scalar zIn = problem.dofCenterDepth(elemCtx, interiorDofIdx, timeIdx);
338 const Scalar zEx = problem.dofCenterDepth(elemCtx, exteriorDofIdx, timeIdx);
341 const Scalar distZ = zIn - zEx;
343 const Scalar inAlpha = problem.thermalHalfTransmissibility(globalIndexIn, globalIndexEx);
344 const Scalar outAlpha = problem.thermalHalfTransmissibility(globalIndexEx, globalIndexIn);
345 const Scalar diffusivity = problem.diffusivity(globalIndexEx, globalIndexIn);
346 const Scalar dispersivity = problem.dispersivity(globalIndexEx, globalIndexIn);
349 if constexpr (enablePolymer) {
350 dist = (elemCtx.pos(interiorDofIdx, timeIdx) - elemCtx.pos(exteriorDofIdx, timeIdx))
375 problem.moduleParams());
378 template <
class RateVectorT,
379 class IntensiveQuantitiesT,
380 class ResidualNBInfoT,
384 const IntensiveQuantitiesT& intQuantsIn,
385 const IntensiveQuantitiesT& intQuantsEx,
386 const unsigned& globalIndexIn,
387 const unsigned& globalIndexEx,
388 const ResidualNBInfoT& nbInfo,
389 const ModuleParamsT& moduleParams)
391 OPM_TIMEBLOCK_LOCAL(calculateFluxes, Subsystem::Assembly);
392 const Scalar Vin = nbInfo.Vin;
393 const Scalar Vex = nbInfo.Vex;
394 const Scalar distZg = nbInfo.dZg;
395 const Scalar thpresInToEx = nbInfo.thpresInToEx;
396 const Scalar thpresExToIn = nbInfo.thpresExToIn;
397 const Scalar trans = nbInfo.trans;
398 const Scalar faceArea = nbInfo.faceArea;
399 FaceDir::DirEnum facedir = nbInfo.faceDir;
401 const FluidSystem& fsys = intQuantsIn.getFluidSystem();
405 ConditionalStorage<enableSolvent || enablePolymer, Evaluation> waterVolumeFlux(0.0);
406 ConditionalStorage<enablePolymer, bool> waterUpIsIn(
true);
408 for (
unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
409 if (!fsys.phaseIsActive(phaseIdx)) {
417 short interiorDofIdx = 0;
418 short exteriorDofIdx = 1;
419 Evaluation pressureDifference;
420 ExtensiveQuantities::calculatePhasePressureDiff_(upIdx,
437 const IntensiveQuantities& up = (upIdx == interiorDofIdx) ? intQuantsIn : intQuantsEx;
438 unsigned globalUpIndex = (upIdx == interiorDofIdx) ? globalIndexIn : globalIndexEx;
441 Evaluation transMult = (intQuantsIn.rockCompTransMultiplier()
442 + Toolbox::value(intQuantsEx.rockCompTransMultiplier()))
444 if constexpr (enableBioeffects || enableSaltPrecipitation) {
446 *= (intQuantsIn.permFactor() + Toolbox::value(intQuantsEx.permFactor())) / 2;
449 Evaluation darcyFlux;
450 if (globalUpIndex == globalIndexIn) {
451 darcyFlux = pressureDifference * up.mobility(phaseIdx, facedir) * transMult
452 * (-trans / faceArea);
454 darcyFlux = pressureDifference
455 * (Toolbox::value(up.mobility(phaseIdx, facedir)) * transMult
456 * (-trans / faceArea));
459 if constexpr (enableSolvent) {
460 if (phaseIdx == waterPhaseIdx) {
461 *waterVolumeFlux = darcyFlux;
465 unsigned activeCompIdx
466 = fsys.canonicalToActiveCompIdx(fsys.solventComponentIndex(phaseIdx));
468 darcy[conti0EqIdx + activeCompIdx] = darcyFlux.value() * faceArea;
470 if constexpr (enablePolymer) {
471 if (phaseIdx == waterPhaseIdx) {
472 *waterVolumeFlux = darcyFlux;
473 *waterUpIsIn = (globalUpIndex == globalIndexIn);
477 unsigned pvtRegionIdx = up.pvtRegionIndex();
479 if (globalUpIndex == globalIndexIn) {
480 const auto& invB = getInvB_<FluidSystem, FluidState, Evaluation>(
481 up.fluidState(), phaseIdx, pvtRegionIdx, fsys);
482 const auto& surfaceVolumeFlux = invB * darcyFlux;
484 evalPhaseFluxes_<Evaluation>(
485 flux, phaseIdx, pvtRegionIdx, surfaceVolumeFlux, up.fluidState());
486 if constexpr (enableFullyImplicitThermal) {
487 EnergyModule::template addPhaseEnthalpyFluxes_<Evaluation>(
488 flux, phaseIdx, darcyFlux, up.fluidState());
490 if constexpr (enableBioeffects) {
491 BioeffectsModule::template addBioeffectsFluxes_<Evaluation>(
492 flux, phaseIdx, darcyFlux, up);
494 if constexpr (enableBrine) {
495 BrineModule::template addBrineFluxes_<Evaluation, FluidState>(
496 flux, phaseIdx, darcyFlux, up.fluidState());
498 if constexpr (enableExtbo) {
499 ExtboModule::template addExtboFluxes_<Evaluation>(
500 flux, phaseIdx, darcyFlux, up);
502 if constexpr (enableFoam) {
503 FoamModule::template addFoamFluxes_<Evaluation>(flux, phaseIdx, darcyFlux, up);
506 const auto& invB = getInvB_<FluidSystem, FluidState, Scalar>(
507 up.fluidState(), phaseIdx, pvtRegionIdx, fsys);
508 const auto& surfaceVolumeFlux = invB * darcyFlux;
509 evalPhaseFluxes_<Scalar>(
510 flux, phaseIdx, pvtRegionIdx, surfaceVolumeFlux, up.fluidState());
511 if constexpr (enableFullyImplicitThermal) {
512 EnergyModule::template addPhaseEnthalpyFluxes_<Scalar>(
513 flux, phaseIdx, darcyFlux, up.fluidState());
515 if constexpr (enableBioeffects) {
516 BioeffectsModule::template addBioeffectsFluxes_<Scalar>(
517 flux, phaseIdx, darcyFlux, up);
519 if constexpr (enableBrine) {
520 BrineModule::template addBrineFluxes_<Scalar, FluidState>(
521 flux, phaseIdx, darcyFlux, up.fluidState());
523 if constexpr (enableExtbo) {
524 ExtboModule::template addExtboFluxes_<Scalar>(flux, phaseIdx, darcyFlux, up);
526 if constexpr (enableFoam) {
527 FoamModule::template addFoamFluxes_<Scalar>(flux, phaseIdx, darcyFlux, up);
533 if constexpr (enableSolvent) {
534 constexpr unsigned interiorDofIdx = 0;
535 constexpr unsigned exteriorDofIdx = 1;
536 unsigned solventUpIdx;
537 unsigned solventDnIdx;
538 Evaluation solventVolumeFlux;
539 ExtensiveQuantities::updateSolventVolumeFlux(solventVolumeFlux,
551 if (solventUpIdx == interiorDofIdx) {
552 SolventModule::template addSolventFluxes_<Evaluation>(
553 flux, solventVolumeFlux, *waterVolumeFlux, intQuantsIn);
555 SolventModule::template addSolventFluxes_<Scalar>(
556 flux, solventVolumeFlux, *waterVolumeFlux, intQuantsEx);
561 if constexpr (enablePolymer) {
562 const IntensiveQuantities& up = *waterUpIsIn ? intQuantsIn : intQuantsEx;
563 Evaluation waterShearFactor = 1.0;
564 Evaluation polymerShearFactor = 1.0;
565 if (PolymerModule::hasPlyshlog()) {
566 ExtensiveQuantities::updateShearMultipliers(waterShearFactor,
577 PolymerModule::template addPolymerFluxes_<Evaluation>(
578 flux, *waterVolumeFlux, waterShearFactor, polymerShearFactor, up);
580 PolymerModule::template addPolymerFluxes_<Scalar>(
581 flux, *waterVolumeFlux, waterShearFactor, polymerShearFactor, up);
586 if constexpr (enableConvectiveMixing) {
587 ConvectiveMixingModule::addConvectiveMixingFlux(
596 moduleParams.convectiveMixingModuleParam);
600 if constexpr (enableFullyImplicitThermal) {
601 const Scalar inAlpha = nbInfo.inAlpha;
602 const Scalar outAlpha = nbInfo.outAlpha;
605 short interiorDofIdx = 0;
606 short exteriorDofIdx = 1;
608 EnergyModule::ExtensiveQuantities::updateEnergy(heatFlux,
614 intQuantsIn.fluidState(),
615 intQuantsEx.fluidState(),
619 EnergyModule::addHeatFlux(flux, heatFlux);
626 !(enableFoam && enableSolvent),
627 "Foam flux with SOLVENT transport phase must be implemented before enabling.");
634 if constexpr (enableDiffusion) {
635 if (FluidSystem::enableDiffusion()) {
636 typename DiffusionModule::ExtensiveQuantities::EvaluationArray
637 effectiveDiffusionCoefficient;
638 DiffusionModule::ExtensiveQuantities::update(
639 effectiveDiffusionCoefficient, intQuantsIn, intQuantsEx);
640 const Scalar diffusivity = nbInfo.diffusivity;
641 const Scalar tmpdiffusivity = diffusivity / faceArea;
642 DiffusionModule::addDiffusiveFlux(
643 flux, intQuantsIn, intQuantsEx, tmpdiffusivity, effectiveDiffusionCoefficient);
650 if constexpr (enableDispersion) {
651 if (FluidSystem::enableDispersion()) {
652 typename DispersionModule::ExtensiveQuantities::ScalarArray normVelocityAvg;
653 DispersionModule::ExtensiveQuantities::update(
654 normVelocityAvg, intQuantsIn, intQuantsEx);
655 const Scalar dispersivity = nbInfo.dispersivity;
656 const Scalar tmpdispersivity = dispersivity / faceArea;
657 DispersionModule::addDispersiveFlux(
658 flux, intQuantsIn, intQuantsEx, tmpdispersivity, normVelocityAvg);
663 if constexpr (enableMICP) {
664 BioeffectsModule::applyScaling(flux);
668 template <
class BoundaryConditionData>
674 template <
class BoundaryConditionData>
678 const IntensiveQuantities& insideIntQuants,
679 unsigned globalSpaceIdx)
682 std::array<short, numPhases> upIdx;
683 std::array<short, numPhases> dnIdx;
684 std::array<Evaluation, numPhases> volumeFlux;
685 std::array<Evaluation, numPhases> pressureDifference;
687 ExtensiveQuantities::calculateBoundaryGradients_(problem,
703 for (
unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
704 if (!FluidSystem::phaseIsActive(phaseIdx)) {
707 const auto& pBoundary = bdyInfo.
exFluidState.pressure(phaseIdx);
708 const Evaluation& pInside = insideIntQuants.fluidState().pressure(phaseIdx);
709 const unsigned pvtRegionIdx = insideIntQuants.pvtRegionIndex();
712 const auto& darcyFlux = volumeFlux[phaseIdx];
714 if (pBoundary < pInside) {
716 const auto& invB = getInvB_<FluidSystem, FluidState, Evaluation>(
717 insideIntQuants.fluidState(), phaseIdx, pvtRegionIdx);
718 Evaluation surfaceVolumeFlux = invB * darcyFlux;
719 evalPhaseFluxes_<Evaluation>(tmp,
721 insideIntQuants.pvtRegionIndex(),
723 insideIntQuants.fluidState());
724 if constexpr (enableFullyImplicitThermal) {
725 EnergyModule::template addPhaseEnthalpyFluxes_<Evaluation>(
726 tmp, phaseIdx, darcyFlux, insideIntQuants.fluidState());
728 }
else if (pBoundary > pInside) {
730 using ScalarFluidState =
decltype(bdyInfo.
exFluidState);
731 const auto& invB = getInvB_<FluidSystem, ScalarFluidState, Scalar>(
733 Evaluation surfaceVolumeFlux = invB * darcyFlux;
734 evalPhaseFluxes_<Scalar>(tmp,
736 insideIntQuants.pvtRegionIndex(),
739 if constexpr (enableFullyImplicitThermal) {
740 EnergyModule::template addPhaseEnthalpyFluxes_<Scalar>(
745 for (
unsigned i = 0; i < tmp.size(); ++i) {
746 bdyFlux[i] += tmp[i];
751 if constexpr (enableFullyImplicitThermal) {
754 Scalar alpha = problem.eclTransmissibilities().thermalHalfTransBoundary(
758 EnergyModule::ExtensiveQuantities::updateEnergyBoundary(heatFlux,
764 EnergyModule::addHeatFlux(bdyFlux, heatFlux);
767 if constexpr (enableSolvent) {
771 const Evaluation solventVolumeFlux
772 = (upIdx[gasPhaseIdx] == 0) ? volumeFlux[gasPhaseIdx] : Evaluation(0.0);
773 SolventModule::template addSolventFluxes_<Evaluation>(
774 bdyFlux, solventVolumeFlux, Evaluation(0.0), insideIntQuants);
777 if constexpr (enablePolymer) {
778 bdyFlux[Indices::contiPolymerEqIdx]
779 = volumeFlux[waterPhaseIdx] * insideIntQuants.polymerConcentration();
782 const FluidSystem& fsys = insideIntQuants.getFluidSystem();
788 for (
unsigned i = 0; i < numEq; ++i) {
789 Valgrind::CheckDefined(bdyFlux[i]);
791 Valgrind::CheckDefined(bdyFlux);
795 template <
class ProblemLocal,
class BoundaryConditionData,
class RateVectorLocal>
797 RateVectorLocal& bdyFlux,
799 const IntensiveQuantities& insideIntQuants,
800 [[maybe_unused]]
unsigned globalSpaceIdx)
807 if constexpr (enableFullyImplicitThermal) {
811 if constexpr (!std::is_empty_v<GetPropType<TypeTag, Properties::FluidSystem>>) {
814 alpha = problem.eclTransmissibilities().thermalHalfTransBoundary(globalSpaceIdx, bdyInfo.
boundaryFaceIndex);
818 EnergyModule::ExtensiveQuantities::updateEnergyBoundary(heatFlux,
824 EnergyModule::addHeatFlux(bdyFlux, heatFlux);
828 for (
unsigned i = 0; i < numEq; ++i) {
829 Valgrind::CheckDefined(bdyFlux[i]);
831 Valgrind::CheckDefined(bdyFlux);
835 template <
class BoundaryConditionData,
class RateVectorLocal,
class LocalProblem>
837 const LocalProblem& problem,
839 const IntensiveQuantities& insideIntQuants,
840 unsigned globalSpaceIdx)
842 if constexpr (std::is_empty_v<GetPropType<TypeTag, Properties::FluidSystem>>) {
843 switch (bdyInfo.
type) {
851 case BCType::DIRICHLET:
854 case BCType::THERMAL:
858 OPM_THROW(std::logic_error,
"Unknown boundary condition type "
860 +
" in computeBoundaryFlux().");
863 switch (bdyInfo.
type) {
867 case BCType::THERMAL:
871 OPM_THROW(std::logic_error,
873 +
" is not supported for GPU fluid systems in computeBoundaryFlux().");
879 const Problem& problem,
880 const IntensiveQuantities& insideIntQuants,
881 unsigned globalSpaceIdex,
886 problem.source(source, globalSpaceIdex, timeIdx);
889 if constexpr (enableBioeffects) {
890 BioeffectsModule::addSource(source, problem, insideIntQuants, globalSpaceIdex);
894 if constexpr (enableFullyImplicitThermal) {
895 source[Indices::contiEnergyEqIdx]
896 *= getPropValue<TypeTag, Properties::BlackOilEnergyScalingFactor>();
901 const Problem& problem,
902 const IntensiveQuantities& insideIntQuants,
903 unsigned globalSpaceIdex,
907 problem.addToSourceDense(source, globalSpaceIdex, timeIdx);
910 if constexpr (enableBioeffects) {
911 BioeffectsModule::addSource(source, problem, insideIntQuants, globalSpaceIdex);
915 if constexpr (enableFullyImplicitThermal) {
916 source[Indices::contiEnergyEqIdx]
917 *= getPropValue<TypeTag, Properties::BlackOilEnergyScalingFactor>();
925 const ElementContext& elemCtx,
927 unsigned timeIdx)
const
931 elemCtx.problem().source(source, elemCtx, dofIdx, timeIdx);
934 if constexpr (enableBioeffects) {
935 BioeffectsModule::addSource(source, elemCtx, dofIdx, timeIdx);
939 if constexpr (enableFullyImplicitThermal) {
940 source[Indices::contiEnergyEqIdx]
941 *= getPropValue<TypeTag, Properties::BlackOilEnergyScalingFactor>();
945 template <
class UpEval,
class Flu
idState>
948 unsigned pvtRegionIdx,
949 const ExtensiveQuantities& extQuants,
950 const FluidState& upFs)
952 const auto& invB = getInvB_<FluidSystem, FluidState, UpEval>(upFs, phaseIdx, pvtRegionIdx);
953 const auto& surfaceVolumeFlux = invB * extQuants.volumeFlux(phaseIdx);
954 evalPhaseFluxes_<UpEval>(flux, phaseIdx, pvtRegionIdx, surfaceVolumeFlux, upFs);
961 template <
class UpEval,
class Eval,
class Flu
idState,
class RateVectorT = RateVector>
964 unsigned pvtRegionIdx,
965 const Eval& surfaceVolumeFlux,
966 const FluidState& upFs)
968 const FluidSystem& fsys = upFs.fluidSystem();
970 unsigned activeCompIdx
971 = fsys.canonicalToActiveCompIdx(fsys.solventComponentIndex(phaseIdx));
973 if constexpr (blackoilConserveSurfaceVolume) {
974 flux[conti0EqIdx + activeCompIdx] += surfaceVolumeFlux;
976 flux[conti0EqIdx + activeCompIdx]
977 += surfaceVolumeFlux * fsys.referenceDensity(phaseIdx, pvtRegionIdx);
980 if (phaseIdx == oilPhaseIdx) {
982 if (fsys.enableDissolvedGas()) {
984 = BlackOil::getRs_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
986 const unsigned activeGasCompIdx = fsys.canonicalToActiveCompIdx(gasCompIdx);
987 if constexpr (blackoilConserveSurfaceVolume) {
988 flux[conti0EqIdx + activeGasCompIdx] += Rs * surfaceVolumeFlux;
990 flux[conti0EqIdx + activeGasCompIdx] += Rs * surfaceVolumeFlux
991 * fsys.referenceDensity(gasPhaseIdx, pvtRegionIdx);
994 }
else if (phaseIdx == waterPhaseIdx) {
996 if (fsys.enableDissolvedGasInWater()) {
998 = BlackOil::getRsw_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
1000 const unsigned activeGasCompIdx = fsys.canonicalToActiveCompIdx(gasCompIdx);
1001 if constexpr (blackoilConserveSurfaceVolume) {
1002 flux[conti0EqIdx + activeGasCompIdx] += Rsw * surfaceVolumeFlux;
1004 flux[conti0EqIdx + activeGasCompIdx] += Rsw * surfaceVolumeFlux
1005 * fsys.referenceDensity(gasPhaseIdx, pvtRegionIdx);
1008 }
else if (phaseIdx == gasPhaseIdx) {
1010 if (fsys.enableVaporizedOil()) {
1012 = BlackOil::getRv_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
1014 const unsigned activeOilCompIdx = fsys.canonicalToActiveCompIdx(oilCompIdx);
1015 if constexpr (blackoilConserveSurfaceVolume) {
1016 flux[conti0EqIdx + activeOilCompIdx] += Rv * surfaceVolumeFlux;
1018 flux[conti0EqIdx + activeOilCompIdx] += Rv * surfaceVolumeFlux
1019 * fsys.referenceDensity(oilPhaseIdx, pvtRegionIdx);
1023 if (fsys.enableVaporizedWater()) {
1025 = BlackOil::getRvw_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
1027 const unsigned activeWaterCompIdx = fsys.canonicalToActiveCompIdx(waterCompIdx);
1028 if constexpr (blackoilConserveSurfaceVolume) {
1029 flux[conti0EqIdx + activeWaterCompIdx] += Rvw * surfaceVolumeFlux;
1031 flux[conti0EqIdx + activeWaterCompIdx] += Rvw * surfaceVolumeFlux
1032 * fsys.referenceDensity(waterPhaseIdx, pvtRegionIdx);
1041 template <
class ScalarVector>
1043 unsigned pvtRegionIdx)
1064 template <
class ScalarVector,
class FsysType>
1066 unsigned pvtRegionIdx,
1067 const FsysType& fsys)
1069 if constexpr (!blackoilConserveSurfaceVolume) {
1074 if constexpr (waterEnabled) {
1075 const unsigned activeWaterCompIdx = fsys.canonicalToActiveCompIdx(waterCompIdx);
1076 container[conti0EqIdx + activeWaterCompIdx]
1077 *= fsys.referenceDensity(waterPhaseIdx, pvtRegionIdx);
1080 if constexpr (gasEnabled) {
1081 const unsigned activeGasCompIdx = fsys.canonicalToActiveCompIdx(gasCompIdx);
1082 container[conti0EqIdx + activeGasCompIdx]
1083 *= fsys.referenceDensity(gasPhaseIdx, pvtRegionIdx);
1086 if constexpr (oilEnabled) {
1087 const unsigned activeOilCompIdx = fsys.canonicalToActiveCompIdx(oilCompIdx);
1088 container[conti0EqIdx + activeOilCompIdx]
1089 *= fsys.referenceDensity(oilPhaseIdx, pvtRegionIdx);
1097 return dirId < 0 ? FaceDir::DirEnum::Unknown : FaceDir::FromIntersectionIndex(dirId);
Classes required for dynamic convective mixing.
Contains classes extending the black-oil model. \detail This file holds dummy definitions,...
Declares the properties required by the black oil model.
Provides the auxiliary methods required for consideration of the diffusion equation.
Provides the auxiliary methods required for consideration of the dispersion equation.
Definition: blackoilmodules.hpp:63
Definition: blackoilfoammodules.hh:57
Calculates the local residual of the black oil model.
Definition: blackoillocalresidualtpfa.hh:67
void computeSource(RateVector &source, const ElementContext &elemCtx, unsigned dofIdx, unsigned timeIdx) const
Calculate the source term of the equation.
Definition: blackoillocalresidualtpfa.hh:924
static OPM_HOST_DEVICE void adaptMassConservationQuantities_(ScalarVector &container, unsigned pvtRegionIdx)
Definition: blackoillocalresidualtpfa.hh:1042
static void computeBoundaryFluxFree(const Problem &problem, RateVector &bdyFlux, const BoundaryConditionData &bdyInfo, const IntensiveQuantities &insideIntQuants, unsigned globalSpaceIdx)
Definition: blackoillocalresidualtpfa.hh:675
static OPM_HOST_DEVICE void computeStorage(StorageType &storage, const IntensiveQuantitiesType &intQuants)
Definition: blackoillocalresidualtpfa.hh:168
static void computeBoundaryFluxRate(RateVector &bdyFlux, const BoundaryConditionData &bdyInfo)
Definition: blackoillocalresidualtpfa.hh:669
static FaceDir::DirEnum faceDirFromDirId(const int dirId)
Definition: blackoillocalresidualtpfa.hh:1095
static OPM_HOST_DEVICE void computeBoundaryThermal(const ProblemLocal &problem, RateVectorLocal &bdyFlux, const BoundaryConditionData &bdyInfo, const IntensiveQuantities &insideIntQuants, unsigned globalSpaceIdx)
Definition: blackoillocalresidualtpfa.hh:796
static OPM_HOST_DEVICE void calculateFluxes_(RateVectorT &flux, RateVectorT &darcy, const IntensiveQuantitiesT &intQuantsIn, const IntensiveQuantitiesT &intQuantsEx, const unsigned &globalIndexIn, const unsigned &globalIndexEx, const ResidualNBInfoT &nbInfo, const ModuleParamsT &moduleParams)
Definition: blackoillocalresidualtpfa.hh:382
static void evalPhaseFluxes_(RateVector &flux, unsigned phaseIdx, unsigned pvtRegionIdx, const ExtensiveQuantities &extQuants, const FluidState &upFs)
Definition: blackoillocalresidualtpfa.hh:946
static void computeFlux(RateVector &flux, const ElementContext &elemCtx, unsigned scvfIdx, unsigned timeIdx)
Definition: blackoillocalresidualtpfa.hh:297
static OPM_HOST_DEVICE void evalPhaseFluxes_(RateVectorT &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:962
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:158
static OPM_HOST_DEVICE void computeFlux(RateVectorT &flux, RateVectorT &darcy, const unsigned globalIndexIn, const unsigned globalIndexEx, const IntensiveQuantitiesT &intQuantsIn, const IntensiveQuantitiesT &intQuantsEx, const ResidualNBInfoT &nbInfo, const ModuleParamsT &moduleParams)
Definition: blackoillocalresidualtpfa.hh:270
static OPM_HOST_DEVICE void computeBoundaryFlux(RateVectorLocal &bdyFlux, const LocalProblem &problem, const BoundaryConditionData &bdyInfo, const IntensiveQuantities &insideIntQuants, unsigned globalSpaceIdx)
Definition: blackoillocalresidualtpfa.hh:836
static void computeSource(RateVector &source, const Problem &problem, const IntensiveQuantities &insideIntQuants, unsigned globalSpaceIdex, unsigned timeIdx)
Definition: blackoillocalresidualtpfa.hh:878
static void computeSourceDense(RateVector &source, const Problem &problem, const IntensiveQuantities &insideIntQuants, unsigned globalSpaceIdex, unsigned timeIdx)
Definition: blackoillocalresidualtpfa.hh:900
static OPM_HOST_DEVICE void adaptMassConservationQuantities_(ScalarVector &container, unsigned pvtRegionIdx, const FsysType &fsys)
Helper function to convert the mass-related parts of a vector that stores conservation quantities in ...
Definition: blackoillocalresidualtpfa.hh:1065
Declare the properties used by the infrastructure code of the finite volume discretizations.
@ NONE
Definition: DeferredLogger.hpp:46
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
std::string to_string(const ConvergenceReport::ReservoirFailure::Type t)
Definition: blackoillocalresidualtpfa.hh:138
ConditionalStorage< enablePolymer, double > dist
Definition: blackoillocalresidualtpfa.hh:151
FaceDir::DirEnum faceDir
Definition: blackoillocalresidualtpfa.hh:144
double faceArea
Definition: blackoillocalresidualtpfa.hh:140
double thpresInToEx
Definition: blackoillocalresidualtpfa.hh:141
ConditionalStorage< enableFullyImplicitThermal, double > outAlpha
Definition: blackoillocalresidualtpfa.hh:148
ConditionalStorage< enableFullyImplicitThermal, double > inAlpha
Definition: blackoillocalresidualtpfa.hh:147
ConditionalStorage< enableDiffusion, double > diffusivity
Definition: blackoillocalresidualtpfa.hh:149
double thpresExToIn
Definition: blackoillocalresidualtpfa.hh:142
double dZg
Definition: blackoillocalresidualtpfa.hh:143
double Vin
Definition: blackoillocalresidualtpfa.hh:145
ConditionalStorage< enableDispersion, double > dispersivity
Definition: blackoillocalresidualtpfa.hh:150
double trans
Definition: blackoillocalresidualtpfa.hh:139
double Vex
Definition: blackoillocalresidualtpfa.hh:146
Definition: tpfalinearizerstructs.hh:89
double faceArea
Definition: tpfalinearizerstructs.hh:94
VectorBlock massRate
Definition: tpfalinearizerstructs.hh:91
BCType type
Definition: tpfalinearizerstructs.hh:90
unsigned boundaryFaceIndex
Definition: tpfalinearizerstructs.hh:93
double faceZCoord
Definition: tpfalinearizerstructs.hh:95
ScalarFluidState exFluidState
Definition: tpfalinearizerstructs.hh:96
unsigned pvtRegionIdx
Definition: tpfalinearizerstructs.hh:92