blackoillocalresidualtpfa.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_LOCAL_TPFA_RESIDUAL_HH
29#define EWOMS_BLACK_OIL_LOCAL_TPFA_RESIDUAL_HH
30
31#include <opm/input/eclipse/EclipseState/Grid/FaceDir.hpp>
32#include <opm/input/eclipse/Schedule/BCState.hpp>
33
34#include <opm/material/common/ConditionalStorage.hpp>
35#include <opm/material/common/MathToolbox.hpp>
36#include <opm/material/fluidstates/BlackOilFluidState.hpp>
37
42
44
45#include <opm/common/ErrorMacros.hpp>
46#include <opm/common/utility/gpuDecorators.hpp>
47#include <opm/common/utility/gpuistl_if_available.hpp>
48
49#include <array>
50#include <cassert>
51#include <limits>
52#include <stdexcept>
53#include <string>
54
55#include <opm/common/utility/gpuistl_if_available.hpp>
56
57namespace Opm
58{
65template <class TypeTag>
66class BlackOilLocalResidualTPFA : public GetPropType<TypeTag, Properties::DiscLocalResidual>
67{
78 using FluidState = typename IntensiveQuantities::FluidState;
79
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>() };
84
85 enum { dimWorld = GridView::dimensionworld };
86 enum { gasPhaseIdx = FluidSystem::gasPhaseIdx };
87 enum { oilPhaseIdx = FluidSystem::oilPhaseIdx };
88 enum { waterPhaseIdx = FluidSystem::waterPhaseIdx };
89
90 enum { gasCompIdx = FluidSystem::gasCompIdx };
91 enum { oilCompIdx = FluidSystem::oilCompIdx };
92 enum { waterCompIdx = FluidSystem::waterCompIdx };
93 static constexpr unsigned compositionSwitchIdx = Indices::compositionSwitchIdx;
94
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();
100
101 static constexpr bool blackoilConserveSurfaceVolume
102 = getPropValue<TypeTag, Properties::BlackoilConserveSurfaceVolume>();
103
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>();
122
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>;
133
135 using Toolbox = MathToolbox<Evaluation>;
136
137public:
139 double trans;
140 double faceArea;
143 double dZg;
144 FaceDir::DirEnum faceDir;
145 double Vin;
146 double Vex;
147 ConditionalStorage<enableFullyImplicitThermal, double> inAlpha;
148 ConditionalStorage<enableFullyImplicitThermal, double> outAlpha;
149 ConditionalStorage<enableDiffusion, double> diffusivity;
150 ConditionalStorage<enableDispersion, double> dispersivity;
151 ConditionalStorage<enablePolymer, double> dist;
152 };
153
157 template <class LhsEval>
158 void computeStorage(Dune::FieldVector<LhsEval, numEq>& storage,
159 const ElementContext& elemCtx,
160 unsigned dofIdx,
161 unsigned timeIdx) const
162 {
163 const IntensiveQuantities& intQuants = elemCtx.intensiveQuantities(dofIdx, timeIdx);
164 computeStorage<LhsEval>(storage, intQuants);
165 }
166
167 template <class LhsEval, class StorageType, class IntensiveQuantitiesType = IntensiveQuantities>
168 OPM_HOST_DEVICE static void computeStorage(StorageType& storage,
169 const IntensiveQuantitiesType& intQuants)
170 {
171 OPM_TIMEBLOCK_LOCAL(computeStorage, Subsystem::Assembly);
172 // retrieve the intensive quantities for the SCV at the specified point in time
173 const auto& fs = intQuants.fluidState();
174 storage = 0.0;
175
176 const FluidSystem& fsys = intQuants.getFluidSystem();
177
178 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
179 if (!fsys.phaseIsActive(phaseIdx)) {
180 continue;
181 }
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());
187
188 storage[conti0EqIdx + activeCompIdx] += surfaceVolume;
189
190 // account for dissolved gas
191 if (phaseIdx == oilPhaseIdx && fsys.enableDissolvedGas()) {
192 unsigned activeGasCompIdx = fsys.canonicalToActiveCompIdx(gasCompIdx);
193 storage[conti0EqIdx + activeGasCompIdx]
194 += Toolbox::template decay<LhsEval>(intQuants.fluidState().Rs())
195 * surfaceVolume;
196 }
197
198 // account for dissolved gas in water
199 if (phaseIdx == waterPhaseIdx && fsys.enableDissolvedGasInWater()) {
200 unsigned activeGasCompIdx = fsys.canonicalToActiveCompIdx(gasCompIdx);
201 storage[conti0EqIdx + activeGasCompIdx]
202 += Toolbox::template decay<LhsEval>(intQuants.fluidState().Rsw())
203 * surfaceVolume;
204 }
205
206 // account for vaporized oil
207 if (phaseIdx == gasPhaseIdx && fsys.enableVaporizedOil()) {
208 unsigned activeOilCompIdx = fsys.canonicalToActiveCompIdx(oilCompIdx);
209 storage[conti0EqIdx + activeOilCompIdx]
210 += Toolbox::template decay<LhsEval>(intQuants.fluidState().Rv())
211 * surfaceVolume;
212 }
213
214 // account for vaporized water
215 if (phaseIdx == gasPhaseIdx && fsys.enableVaporizedWater()) {
216 unsigned activeWaterCompIdx = fsys.canonicalToActiveCompIdx(waterCompIdx);
217 storage[conti0EqIdx + activeWaterCompIdx]
218 += Toolbox::template decay<LhsEval>(intQuants.fluidState().Rvw())
219 * surfaceVolume;
220 }
221 }
222
223 adaptMassConservationQuantities_(storage, intQuants.pvtRegionIndex(), fsys);
224
225 // deal with solvents (if present)
226 if constexpr (enableSolvent) {
227 SolventModule::addStorage(storage, intQuants);
228 }
229
230 // deal with zFracton (if present)
231 if constexpr (enableExtbo) {
232 ExtboModule::addStorage(storage, intQuants);
233 }
234
235 // deal with polymer (if present)
236 if constexpr (enablePolymer) {
237 PolymerModule::addStorage(storage, intQuants);
238 }
239
240 // deal with energy (if present)
241 if constexpr (enableFullyImplicitThermal) {
242 EnergyModule::addStorage(storage, intQuants);
243 }
244
245 // deal with foam (if present)
246 if constexpr (enableFoam) {
247 FoamModule::addStorage(storage, intQuants);
248 }
249
250 // deal with salt (if present)
251 if constexpr (enableBrine) {
252 BrineModule::addStorage(storage, intQuants);
253 }
254
255 // deal with bioeffects (if present)
256 if constexpr (enableBioeffects) {
257 BioeffectsModule::addStorage(storage, intQuants);
258 }
259 }
260
266 template <class ModuleParamsT,
267 class RateVectorT,
268 class IntensiveQuantitiesT,
269 class ResidualNBInfoT>
270 OPM_HOST_DEVICE static void computeFlux(RateVectorT& flux,
271 RateVectorT& darcy,
272 const unsigned globalIndexIn,
273 const unsigned globalIndexEx,
274 const IntensiveQuantitiesT& intQuantsIn,
275 const IntensiveQuantitiesT& intQuantsEx,
276 const ResidualNBInfoT& nbInfo,
277 const ModuleParamsT& moduleParams)
278 {
279 OPM_TIMEBLOCK_LOCAL(computeFlux, Subsystem::Assembly);
280 flux = 0.0;
281 darcy = 0.0;
282
283 calculateFluxes_(flux,
284 darcy,
285 intQuantsIn,
286 intQuantsEx,
287 globalIndexIn,
288 globalIndexEx,
289 nbInfo,
290 moduleParams);
291 }
292
293 // This function demonstrates compatibility with the ElementContext-based interface.
294 // Actually using it will lead to double work since the element context already contains
295 // fluxes through its stored ExtensiveQuantities.
296 static void
297 computeFlux(RateVector& flux, const ElementContext& elemCtx, unsigned scvfIdx, unsigned timeIdx)
298 {
299 OPM_TIMEBLOCK_LOCAL(computeFlux, Subsystem::Assembly);
300 assert(timeIdx == 0);
301
302 flux = 0.0;
303 RateVector darcy = 0.0;
304 // need for dary flux calculation
305 const auto& problem = elemCtx.problem();
306 const auto& stencil = elemCtx.stencil(timeIdx);
307 const auto& scvf = stencil.interiorFace(scvfIdx);
308
309 unsigned interiorDofIdx = scvf.interiorIndex();
310 unsigned exteriorDofIdx = scvf.exteriorIndex();
311 assert(interiorDofIdx != exteriorDofIdx);
312
313 // unsigned I = stencil.globalSpaceIndex(interiorDofIdx);
314 // unsigned J = stencil.globalSpaceIndex(exteriorDofIdx);
315 Scalar Vin = elemCtx.dofVolume(interiorDofIdx, /*timeIdx=*/0);
316 Scalar Vex = elemCtx.dofVolume(exteriorDofIdx, /*timeIdx=*/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();
321 const auto faceDir = faceDirFromDirId(scvf.dirId());
322 Scalar thpresInToEx = problem.thresholdPressure(globalIndexIn, globalIndexEx);
323 Scalar thpresExToIn = problem.thresholdPressure(globalIndexEx, globalIndexIn);
324
325 // estimate the gravity correction: for performance reasons we use a simplified
326 // approach for this flux module that assumes that gravity is constant and always
327 // acts into the downwards direction. (i.e., no centrifuge experiments, sorry.)
328 const Scalar g = problem.gravity()[dimWorld - 1];
329 const auto& intQuantsIn = elemCtx.intensiveQuantities(interiorDofIdx, timeIdx);
330 const auto& intQuantsEx = elemCtx.intensiveQuantities(exteriorDofIdx, timeIdx);
331
332 // this is quite hacky because the dune grid interface does not provide a
333 // cellCenterDepth() method (so we ask the problem to provide it). The "good"
334 // solution would be to take the Z coordinate of the element centroids, but since
335 // ECL seems to like to be inconsistent on that front, it needs to be done like
336 // here...
337 const Scalar zIn = problem.dofCenterDepth(elemCtx, interiorDofIdx, timeIdx);
338 const Scalar zEx = problem.dofCenterDepth(elemCtx, exteriorDofIdx, timeIdx);
339 // the distances from the DOF's depths. (i.e., the additional depth of the
340 // exterior DOF)
341 const Scalar distZ = zIn - zEx;
342 // for thermal harmonic mean of half trans
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);
347 // distance between cell centers (only needed for polymer)
348 Scalar dist = 0.0;
349 if constexpr (enablePolymer) {
350 dist = (elemCtx.pos(interiorDofIdx, timeIdx) - elemCtx.pos(exteriorDofIdx, timeIdx))
351 .two_norm();
352 }
353
354 const ResidualNBInfo res_nbinfo {trans,
355 faceArea,
356 thpresInToEx,
357 thpresExToIn,
358 distZ * g,
359 faceDir,
360 Vin,
361 Vex,
362 inAlpha,
363 outAlpha,
364 diffusivity,
365 dispersivity,
366 dist};
367
368 calculateFluxes_(flux,
369 darcy,
370 intQuantsIn,
371 intQuantsEx,
372 globalIndexIn,
373 globalIndexEx,
374 res_nbinfo,
375 problem.moduleParams());
376 }
377
378 template <class RateVectorT,
379 class IntensiveQuantitiesT,
380 class ResidualNBInfoT,
381 class ModuleParamsT>
382 OPM_HOST_DEVICE static void calculateFluxes_(RateVectorT& flux,
383 RateVectorT& darcy,
384 const IntensiveQuantitiesT& intQuantsIn,
385 const IntensiveQuantitiesT& intQuantsEx,
386 const unsigned& globalIndexIn,
387 const unsigned& globalIndexEx,
388 const ResidualNBInfoT& nbInfo,
389 const ModuleParamsT& moduleParams)
390 {
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;
400
401 const FluidSystem& fsys = intQuantsIn.getFluidSystem();
402
403 // water volume flux, needed for solvent dissolved in water or polymer flow, which
404 // also needs water phase upstream cell
405 ConditionalStorage<enableSolvent || enablePolymer, Evaluation> waterVolumeFlux(0.0);
406 ConditionalStorage<enablePolymer, bool> waterUpIsIn(true);
407
408 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
409 if (!fsys.phaseIsActive(phaseIdx)) {
410 continue;
411 }
412 // darcy flux calculation
413 short dnIdx;
414 //
415 short upIdx;
416 // fake intices should only be used to get upwind anc compatibility with old functions
417 short interiorDofIdx = 0; // NB
418 short exteriorDofIdx = 1; // NB
419 Evaluation pressureDifference;
420 ExtensiveQuantities::calculatePhasePressureDiff_(upIdx,
421 dnIdx,
422 pressureDifference,
423 intQuantsIn,
424 intQuantsEx,
425 phaseIdx, // input
426 interiorDofIdx, // input
427 exteriorDofIdx, // input
428 Vin,
429 Vex,
430 globalIndexIn,
431 globalIndexEx,
432 distZg,
433 thpresInToEx,
434 thpresExToIn,
435 moduleParams);
436
437 const IntensiveQuantities& up = (upIdx == interiorDofIdx) ? intQuantsIn : intQuantsEx;
438 unsigned globalUpIndex = (upIdx == interiorDofIdx) ? globalIndexIn : globalIndexEx;
439 // Use arithmetic average (more accurate with harmonic, but that requires recomputing
440 // the transmissbility)
441 Evaluation transMult = (intQuantsIn.rockCompTransMultiplier()
442 + Toolbox::value(intQuantsEx.rockCompTransMultiplier()))
443 / 2;
444 if constexpr (enableBioeffects || enableSaltPrecipitation) {
445 transMult
446 *= (intQuantsIn.permFactor() + Toolbox::value(intQuantsEx.permFactor())) / 2;
447 }
448
449 Evaluation darcyFlux;
450 if (globalUpIndex == globalIndexIn) {
451 darcyFlux = pressureDifference * up.mobility(phaseIdx, facedir) * transMult
452 * (-trans / faceArea);
453 } else {
454 darcyFlux = pressureDifference
455 * (Toolbox::value(up.mobility(phaseIdx, facedir)) * transMult
456 * (-trans / faceArea));
457 }
458
459 if constexpr (enableSolvent) {
460 if (phaseIdx == waterPhaseIdx) {
461 *waterVolumeFlux = darcyFlux;
462 }
463 }
464
465 unsigned activeCompIdx
466 = fsys.canonicalToActiveCompIdx(fsys.solventComponentIndex(phaseIdx));
467 // NB! For the FLORES fluxes without derivatives
468 darcy[conti0EqIdx + activeCompIdx] = darcyFlux.value() * faceArea;
469
470 if constexpr (enablePolymer) {
471 if (phaseIdx == waterPhaseIdx) {
472 *waterVolumeFlux = darcyFlux;
473 *waterUpIsIn = (globalUpIndex == globalIndexIn);
474 }
475 }
476
477 unsigned pvtRegionIdx = up.pvtRegionIndex();
478 // if (upIdx == globalFocusDofIdx){
479 if (globalUpIndex == globalIndexIn) {
480 const auto& invB = getInvB_<FluidSystem, FluidState, Evaluation>(
481 up.fluidState(), phaseIdx, pvtRegionIdx, fsys);
482 const auto& surfaceVolumeFlux = invB * darcyFlux;
483
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());
489 }
490 if constexpr (enableBioeffects) {
491 BioeffectsModule::template addBioeffectsFluxes_<Evaluation>(
492 flux, phaseIdx, darcyFlux, up);
493 }
494 if constexpr (enableBrine) {
495 BrineModule::template addBrineFluxes_<Evaluation, FluidState>(
496 flux, phaseIdx, darcyFlux, up.fluidState());
497 }
498 if constexpr (enableExtbo) {
499 ExtboModule::template addExtboFluxes_<Evaluation>(
500 flux, phaseIdx, darcyFlux, up);
501 }
502 if constexpr (enableFoam) {
503 FoamModule::template addFoamFluxes_<Evaluation>(flux, phaseIdx, darcyFlux, up);
504 }
505 } else {
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());
514 }
515 if constexpr (enableBioeffects) {
516 BioeffectsModule::template addBioeffectsFluxes_<Scalar>(
517 flux, phaseIdx, darcyFlux, up);
518 }
519 if constexpr (enableBrine) {
520 BrineModule::template addBrineFluxes_<Scalar, FluidState>(
521 flux, phaseIdx, darcyFlux, up.fluidState());
522 }
523 if constexpr (enableExtbo) {
524 ExtboModule::template addExtboFluxes_<Scalar>(flux, phaseIdx, darcyFlux, up);
525 }
526 if constexpr (enableFoam) {
527 FoamModule::template addFoamFluxes_<Scalar>(flux, phaseIdx, darcyFlux, up);
528 }
529 }
530 }
531
532 // deal with solvents (if present)
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,
540 solventUpIdx,
541 solventDnIdx,
542 interiorDofIdx,
543 exteriorDofIdx,
544 intQuantsIn,
545 intQuantsEx,
546 thpresInToEx,
547 thpresExToIn,
548 trans,
549 faceArea,
550 distZg);
551 if (solventUpIdx == interiorDofIdx) {
552 SolventModule::template addSolventFluxes_<Evaluation>(
553 flux, solventVolumeFlux, *waterVolumeFlux, intQuantsIn);
554 } else {
555 SolventModule::template addSolventFluxes_<Scalar>(
556 flux, solventVolumeFlux, *waterVolumeFlux, intQuantsEx);
557 }
558 }
559
560 // deal with polymer (if present)
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,
567 polymerShearFactor,
568 *waterVolumeFlux,
569 intQuantsIn,
570 intQuantsEx,
571 *waterUpIsIn,
572 trans,
573 faceArea,
574 nbInfo.dist);
575 }
576 if (*waterUpIsIn) {
577 PolymerModule::template addPolymerFluxes_<Evaluation>(
578 flux, *waterVolumeFlux, waterShearFactor, polymerShearFactor, up);
579 } else {
580 PolymerModule::template addPolymerFluxes_<Scalar>(
581 flux, *waterVolumeFlux, waterShearFactor, polymerShearFactor, up);
582 }
583 }
584
585 // deal with convective mixing
586 if constexpr (enableConvectiveMixing) {
587 ConvectiveMixingModule::addConvectiveMixingFlux(
588 flux,
589 intQuantsIn,
590 intQuantsEx,
591 globalIndexIn,
592 globalIndexEx,
593 nbInfo.dZg,
594 nbInfo.trans,
595 nbInfo.faceArea,
596 moduleParams.convectiveMixingModuleParam);
597 }
598
599 // deal with energy (if present)
600 if constexpr (enableFullyImplicitThermal) {
601 const Scalar inAlpha = nbInfo.inAlpha;
602 const Scalar outAlpha = nbInfo.outAlpha;
603 Evaluation heatFlux;
604
605 short interiorDofIdx = 0; // NB
606 short exteriorDofIdx = 1; // NB
607
608 EnergyModule::ExtensiveQuantities::updateEnergy(heatFlux,
609 interiorDofIdx, // focusDofIndex,
610 interiorDofIdx,
611 exteriorDofIdx,
612 intQuantsIn,
613 intQuantsEx,
614 intQuantsIn.fluidState(),
615 intQuantsEx.fluidState(),
616 inAlpha,
617 outAlpha,
618 faceArea);
619 EnergyModule::addHeatFlux(flux, heatFlux);
620 }
621 // NB need to be tha last energy call since it does scaling
622 // EnergyModule::computeFlux(flux, elemCtx, scvfIdx, timeIdx);
623
624 // deal with foam transported by solvent (if present)
625 static_assert(
626 !(enableFoam && enableSolvent),
627 "Foam flux with SOLVENT transport phase must be implemented before enabling.");
628
629 // deal with diffusion (if present). opm-models expects per area flux (added in the
630 // tmpdiffusivity).
631 // Only work if diffusion is enabled run-time by DIFFUSE in the deck. Without
632 // this check the diffusive flux is evaluated on every face of the grid even
633 // though it does not contribute to the residual.
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);
644 }
645 }
646
647 // deal with dispersion (if present). opm-models expects per area flux (added in the
648 // tmpdispersivity).
649 // Only work if dispersion is enabled run-time by DISPERC in the deck.
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);
659 }
660 }
661
662 // apply the scaling for the urea equation in MICP
663 if constexpr (enableMICP) {
664 BioeffectsModule::applyScaling(flux);
665 }
666 }
667
668 template <class BoundaryConditionData>
669 static void computeBoundaryFluxRate(RateVector& bdyFlux, const BoundaryConditionData& bdyInfo)
670 {
671 bdyFlux.setMassRate(bdyInfo.massRate, bdyInfo.pvtRegionIdx);
672 }
673
674 template <class BoundaryConditionData>
675 static void computeBoundaryFluxFree(const Problem& problem,
676 RateVector& bdyFlux,
677 const BoundaryConditionData& bdyInfo,
678 const IntensiveQuantities& insideIntQuants,
679 unsigned globalSpaceIdx)
680 {
681 OPM_TIMEBLOCK_LOCAL(computeBoundaryFluxFree, Subsystem::Assembly);
682 std::array<short, numPhases> upIdx;
683 std::array<short, numPhases> dnIdx;
684 std::array<Evaluation, numPhases> volumeFlux;
685 std::array<Evaluation, numPhases> pressureDifference;
686
687 ExtensiveQuantities::calculateBoundaryGradients_(problem,
688 globalSpaceIdx,
689 insideIntQuants,
690 bdyInfo.boundaryFaceIndex,
691 bdyInfo.faceArea,
692 bdyInfo.faceZCoord,
693 bdyInfo.exFluidState,
694 upIdx,
695 dnIdx,
696 volumeFlux,
697 pressureDifference);
698
700 // advective fluxes of all components in all phases
702 bdyFlux = 0.0;
703 for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
704 if (!FluidSystem::phaseIsActive(phaseIdx)) {
705 continue;
706 }
707 const auto& pBoundary = bdyInfo.exFluidState.pressure(phaseIdx);
708 const Evaluation& pInside = insideIntQuants.fluidState().pressure(phaseIdx);
709 const unsigned pvtRegionIdx = insideIntQuants.pvtRegionIndex();
710
711 RateVector tmp(0.0);
712 const auto& darcyFlux = volumeFlux[phaseIdx];
713 // mass conservation
714 if (pBoundary < pInside) {
715 // outflux
716 const auto& invB = getInvB_<FluidSystem, FluidState, Evaluation>(
717 insideIntQuants.fluidState(), phaseIdx, pvtRegionIdx);
718 Evaluation surfaceVolumeFlux = invB * darcyFlux;
719 evalPhaseFluxes_<Evaluation>(tmp,
720 phaseIdx,
721 insideIntQuants.pvtRegionIndex(),
722 surfaceVolumeFlux,
723 insideIntQuants.fluidState());
724 if constexpr (enableFullyImplicitThermal) {
725 EnergyModule::template addPhaseEnthalpyFluxes_<Evaluation>(
726 tmp, phaseIdx, darcyFlux, insideIntQuants.fluidState());
727 }
728 } else if (pBoundary > pInside) {
729 // influx
730 using ScalarFluidState = decltype(bdyInfo.exFluidState);
731 const auto& invB = getInvB_<FluidSystem, ScalarFluidState, Scalar>(
732 bdyInfo.exFluidState, phaseIdx, pvtRegionIdx);
733 Evaluation surfaceVolumeFlux = invB * darcyFlux;
734 evalPhaseFluxes_<Scalar>(tmp,
735 phaseIdx,
736 insideIntQuants.pvtRegionIndex(),
737 surfaceVolumeFlux,
738 bdyInfo.exFluidState);
739 if constexpr (enableFullyImplicitThermal) {
740 EnergyModule::template addPhaseEnthalpyFluxes_<Scalar>(
741 tmp, phaseIdx, darcyFlux, bdyInfo.exFluidState);
742 }
743 }
744
745 for (unsigned i = 0; i < tmp.size(); ++i) {
746 bdyFlux[i] += tmp[i];
747 }
748 }
749
750 // conductive heat flux from boundary
751 if constexpr (enableFullyImplicitThermal) {
752 Evaluation heatFlux;
753 // avoid overload of functions with same number of elements in eclproblem
754 Scalar alpha = problem.eclTransmissibilities().thermalHalfTransBoundary(
755 globalSpaceIdx, bdyInfo.boundaryFaceIndex);
756 unsigned inIdx = 0; // dummy
757 // always calculated with derivatives of this cell
758 EnergyModule::ExtensiveQuantities::updateEnergyBoundary(heatFlux,
759 insideIntQuants,
760 /*focusDofIndex*/ inIdx,
761 inIdx,
762 alpha,
763 bdyInfo.exFluidState);
764 EnergyModule::addHeatFlux(bdyFlux, heatFlux);
765 }
766
767 if constexpr (enableSolvent) {
768 // NOTE: the treatment of solvent boundary flux follows element context version with
769 // its limitations: (i) solvent flux = gas flux and (ii) no flux of dissolved solvent
770 // in water
771 const Evaluation solventVolumeFlux
772 = (upIdx[gasPhaseIdx] == 0) ? volumeFlux[gasPhaseIdx] : Evaluation(0.0);
773 SolventModule::template addSolventFluxes_<Evaluation>(
774 bdyFlux, solventVolumeFlux, /*waterVolumeFlux=*/Evaluation(0.0), insideIntQuants);
775 }
776
777 if constexpr (enablePolymer) {
778 bdyFlux[Indices::contiPolymerEqIdx]
779 = volumeFlux[waterPhaseIdx] * insideIntQuants.polymerConcentration();
780 }
781
782 const FluidSystem& fsys = insideIntQuants.getFluidSystem();
783
784 // make sure that the right mass conservation quantities are used
785 adaptMassConservationQuantities_(bdyFlux, insideIntQuants.pvtRegionIndex(), fsys);
786
787#ifndef NDEBUG
788 for (unsigned i = 0; i < numEq; ++i) {
789 Valgrind::CheckDefined(bdyFlux[i]);
790 }
791 Valgrind::CheckDefined(bdyFlux);
792#endif
793 }
794
795 template <class ProblemLocal, class BoundaryConditionData, class RateVectorLocal>
796 OPM_HOST_DEVICE static void computeBoundaryThermal(const ProblemLocal& problem,
797 RateVectorLocal& bdyFlux,
798 const BoundaryConditionData& bdyInfo,
799 const IntensiveQuantities& insideIntQuants,
800 [[maybe_unused]] unsigned globalSpaceIdx)
801 {
802 OPM_TIMEBLOCK_LOCAL(computeBoundaryThermal, Subsystem::Assembly);
803 // only heat is allowed to flow through this boundary
804 bdyFlux = 0.0;
805
806 // conductive heat flux from boundary
807 if constexpr (enableFullyImplicitThermal) {
808 Evaluation heatFlux;
809 // avoid overload of functions with same numeber of elements in eclproblem
810 Scalar alpha;
811 if constexpr (!std::is_empty_v<GetPropType<TypeTag, Properties::FluidSystem>>) {
812 alpha = problem.getAlpha(globalSpaceIdx, bdyInfo.boundaryFaceIndex);
813 } else {
814 alpha = problem.eclTransmissibilities().thermalHalfTransBoundary(globalSpaceIdx, bdyInfo.boundaryFaceIndex);
815 }
816 unsigned inIdx = 0; // dummy
817 // always calculated with derivatives of this cell
818 EnergyModule::ExtensiveQuantities::updateEnergyBoundary(heatFlux,
819 insideIntQuants,
820 /*focusDofIndex*/ inIdx,
821 inIdx,
822 alpha,
823 bdyInfo.exFluidState);
824 EnergyModule::addHeatFlux(bdyFlux, heatFlux);
825 }
826
827#ifndef NDEBUG
828 for (unsigned i = 0; i < numEq; ++i) {
829 Valgrind::CheckDefined(bdyFlux[i]);
830 }
831 Valgrind::CheckDefined(bdyFlux);
832#endif
833 }
834
835 template <class BoundaryConditionData, class RateVectorLocal, class LocalProblem>
836 OPM_HOST_DEVICE static void computeBoundaryFlux(RateVectorLocal& bdyFlux,
837 const LocalProblem& problem,
838 const BoundaryConditionData& bdyInfo,
839 const IntensiveQuantities& insideIntQuants,
840 unsigned globalSpaceIdx)
841 {
842 if constexpr (std::is_empty_v<GetPropType<TypeTag, Properties::FluidSystem>>) {
843 switch (bdyInfo.type) {
844 case BCType::NONE:
845 bdyFlux = 0.0;
846 break;
847 case BCType::RATE:
848 computeBoundaryFluxRate(bdyFlux, bdyInfo);
849 break;
850 case BCType::FREE:
851 case BCType::DIRICHLET:
852 computeBoundaryFluxFree(problem, bdyFlux, bdyInfo, insideIntQuants, globalSpaceIdx);
853 break;
854 case BCType::THERMAL:
855 computeBoundaryThermal(problem, bdyFlux, bdyInfo, insideIntQuants, globalSpaceIdx);
856 break;
857 default:
858 OPM_THROW(std::logic_error, "Unknown boundary condition type "
859 + std::to_string(static_cast<int>(bdyInfo.type))
860 + " in computeBoundaryFlux().");
861 }
862 } else { // Non-static fluid system used in GPU assembly
863 switch (bdyInfo.type) {
864 case BCType::NONE:
865 bdyFlux = 0.0;
866 break;
867 case BCType::THERMAL:
868 computeBoundaryThermal(problem, bdyFlux, bdyInfo, insideIntQuants, globalSpaceIdx);
869 break;
870 default:
871 OPM_THROW(std::logic_error,
872 "Boundary condition type " + std::to_string(static_cast<int>(bdyInfo.type))
873 + " is not supported for GPU fluid systems in computeBoundaryFlux().");
874 }
875 }
876 }
877
878 static void computeSource(RateVector& source,
879 const Problem& problem,
880 const IntensiveQuantities& insideIntQuants,
881 unsigned globalSpaceIdex,
882 unsigned timeIdx)
883 {
884 OPM_TIMEBLOCK_LOCAL(computeSource, Subsystem::Assembly);
885 // retrieve the source term intrinsic to the problem
886 problem.source(source, globalSpaceIdex, timeIdx);
887
888 // deal with bioeffects (if present)
889 if constexpr (enableBioeffects) {
890 BioeffectsModule::addSource(source, problem, insideIntQuants, globalSpaceIdex);
891 }
892
893 // scale the source term of the energy equation
894 if constexpr (enableFullyImplicitThermal) {
895 source[Indices::contiEnergyEqIdx]
896 *= getPropValue<TypeTag, Properties::BlackOilEnergyScalingFactor>();
897 }
898 }
899
900 static void computeSourceDense(RateVector& source,
901 const Problem& problem,
902 const IntensiveQuantities& insideIntQuants,
903 unsigned globalSpaceIdex,
904 unsigned timeIdx)
905 {
906 source = 0.0;
907 problem.addToSourceDense(source, globalSpaceIdex, timeIdx);
908
909 // deal with bioeffects (if present)
910 if constexpr (enableBioeffects) {
911 BioeffectsModule::addSource(source, problem, insideIntQuants, globalSpaceIdex);
912 }
913
914 // scale the source term of the energy equation
915 if constexpr (enableFullyImplicitThermal) {
916 source[Indices::contiEnergyEqIdx]
917 *= getPropValue<TypeTag, Properties::BlackOilEnergyScalingFactor>();
918 }
919 }
920
924 void computeSource(RateVector& source,
925 const ElementContext& elemCtx,
926 unsigned dofIdx,
927 unsigned timeIdx) const
928 {
929 OPM_TIMEBLOCK_LOCAL(computeSource, Subsystem::Assembly);
930 // retrieve the source term intrinsic to the problem
931 elemCtx.problem().source(source, elemCtx, dofIdx, timeIdx);
932
933 // deal with bioeffects (if present)
934 if constexpr (enableBioeffects) {
935 BioeffectsModule::addSource(source, elemCtx, dofIdx, timeIdx);
936 }
937
938 // scale the source term of the energy equation
939 if constexpr (enableFullyImplicitThermal) {
940 source[Indices::contiEnergyEqIdx]
941 *= getPropValue<TypeTag, Properties::BlackOilEnergyScalingFactor>();
942 }
943 }
944
945 template <class UpEval, class FluidState>
946 static void evalPhaseFluxes_(RateVector& flux,
947 unsigned phaseIdx,
948 unsigned pvtRegionIdx,
949 const ExtensiveQuantities& extQuants,
950 const FluidState& upFs)
951 {
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);
955 }
956
961 template <class UpEval, class Eval, class FluidState, class RateVectorT = RateVector>
962 OPM_HOST_DEVICE static void evalPhaseFluxes_(RateVectorT& flux,
963 unsigned phaseIdx,
964 unsigned pvtRegionIdx,
965 const Eval& surfaceVolumeFlux,
966 const FluidState& upFs)
967 {
968 const FluidSystem& fsys = upFs.fluidSystem();
969
970 unsigned activeCompIdx
971 = fsys.canonicalToActiveCompIdx(fsys.solventComponentIndex(phaseIdx));
972
973 if constexpr (blackoilConserveSurfaceVolume) {
974 flux[conti0EqIdx + activeCompIdx] += surfaceVolumeFlux;
975 } else {
976 flux[conti0EqIdx + activeCompIdx]
977 += surfaceVolumeFlux * fsys.referenceDensity(phaseIdx, pvtRegionIdx);
978 }
979
980 if (phaseIdx == oilPhaseIdx) {
981 // dissolved gas (in the oil phase).
982 if (fsys.enableDissolvedGas()) {
983 const auto& Rs
984 = BlackOil::getRs_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
985
986 const unsigned activeGasCompIdx = fsys.canonicalToActiveCompIdx(gasCompIdx);
987 if constexpr (blackoilConserveSurfaceVolume) {
988 flux[conti0EqIdx + activeGasCompIdx] += Rs * surfaceVolumeFlux;
989 } else {
990 flux[conti0EqIdx + activeGasCompIdx] += Rs * surfaceVolumeFlux
991 * fsys.referenceDensity(gasPhaseIdx, pvtRegionIdx);
992 }
993 }
994 } else if (phaseIdx == waterPhaseIdx) {
995 // dissolved gas (in the water phase).
996 if (fsys.enableDissolvedGasInWater()) {
997 const auto& Rsw
998 = BlackOil::getRsw_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
999
1000 const unsigned activeGasCompIdx = fsys.canonicalToActiveCompIdx(gasCompIdx);
1001 if constexpr (blackoilConserveSurfaceVolume) {
1002 flux[conti0EqIdx + activeGasCompIdx] += Rsw * surfaceVolumeFlux;
1003 } else {
1004 flux[conti0EqIdx + activeGasCompIdx] += Rsw * surfaceVolumeFlux
1005 * fsys.referenceDensity(gasPhaseIdx, pvtRegionIdx);
1006 }
1007 }
1008 } else if (phaseIdx == gasPhaseIdx) {
1009 // vaporized oil (in the gas phase).
1010 if (fsys.enableVaporizedOil()) {
1011 const auto& Rv
1012 = BlackOil::getRv_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
1013
1014 const unsigned activeOilCompIdx = fsys.canonicalToActiveCompIdx(oilCompIdx);
1015 if constexpr (blackoilConserveSurfaceVolume) {
1016 flux[conti0EqIdx + activeOilCompIdx] += Rv * surfaceVolumeFlux;
1017 } else {
1018 flux[conti0EqIdx + activeOilCompIdx] += Rv * surfaceVolumeFlux
1019 * fsys.referenceDensity(oilPhaseIdx, pvtRegionIdx);
1020 }
1021 }
1022 // vaporized water (in the gas phase).
1023 if (fsys.enableVaporizedWater()) {
1024 const auto& Rvw
1025 = BlackOil::getRvw_<FluidSystem, FluidState, UpEval>(upFs, pvtRegionIdx);
1026
1027 const unsigned activeWaterCompIdx = fsys.canonicalToActiveCompIdx(waterCompIdx);
1028 if constexpr (blackoilConserveSurfaceVolume) {
1029 flux[conti0EqIdx + activeWaterCompIdx] += Rvw * surfaceVolumeFlux;
1030 } else {
1031 flux[conti0EqIdx + activeWaterCompIdx] += Rvw * surfaceVolumeFlux
1032 * fsys.referenceDensity(waterPhaseIdx, pvtRegionIdx);
1033 }
1034 }
1035 }
1036 }
1037
1041 template <class ScalarVector>
1042 OPM_HOST_DEVICE static void adaptMassConservationQuantities_(ScalarVector& container,
1043 unsigned pvtRegionIdx)
1044 {
1045 // Delegate to the generic overload using a default-constructed static FluidSystem
1046 // instance. Valid because the static FluidSystem is stateless (std::is_empty_v).
1047 adaptMassConservationQuantities_(container, pvtRegionIdx, FluidSystem{});
1048 }
1049
1064 template <class ScalarVector, class FsysType>
1065 OPM_HOST_DEVICE static void adaptMassConservationQuantities_(ScalarVector& container,
1066 unsigned pvtRegionIdx,
1067 const FsysType& fsys)
1068 {
1069 if constexpr (!blackoilConserveSurfaceVolume) {
1070 // convert "surface volume" to mass. this is complicated a bit by the fact that
1071 // not all phases are necessarily enabled. (we here assume that if a fluid phase
1072 // is disabled, its respective "main" component is not considered as well.)
1073
1074 if constexpr (waterEnabled) {
1075 const unsigned activeWaterCompIdx = fsys.canonicalToActiveCompIdx(waterCompIdx);
1076 container[conti0EqIdx + activeWaterCompIdx]
1077 *= fsys.referenceDensity(waterPhaseIdx, pvtRegionIdx);
1078 }
1079
1080 if constexpr (gasEnabled) {
1081 const unsigned activeGasCompIdx = fsys.canonicalToActiveCompIdx(gasCompIdx);
1082 container[conti0EqIdx + activeGasCompIdx]
1083 *= fsys.referenceDensity(gasPhaseIdx, pvtRegionIdx);
1084 }
1085
1086 if constexpr (oilEnabled) {
1087 const unsigned activeOilCompIdx = fsys.canonicalToActiveCompIdx(oilCompIdx);
1088 container[conti0EqIdx + activeOilCompIdx]
1089 *= fsys.referenceDensity(oilPhaseIdx, pvtRegionIdx);
1090 }
1091 }
1092 }
1093
1094 // NNC does not have a direction
1095 static FaceDir::DirEnum faceDirFromDirId(const int dirId)
1096 {
1097 return dirId < 0 ? FaceDir::DirEnum::Unknown : FaceDir::FromIntersectionIndex(dirId);
1098 }
1099};
1100
1101} // namespace Opm
1102
1103#endif
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