blackoilmodel.hh
Go to the documentation of this file.
1// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2// vi: set et ts=4 sw=4 sts=4:
3/*
4 This file is part of the Open Porous Media project (OPM).
5
6 OPM is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 2 of the License, or
9 (at your option) any later version.
10
11 OPM is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with OPM. If not, see <http://www.gnu.org/licenses/>.
18
19 Consult the COPYING file in the top-level source directory of this
20 module for the precise wording of the license and the list of
21 copyright holders.
22*/
28#ifndef OPM_BLACK_OIL_MODEL_HPP
29#define OPM_BLACK_OIL_MODEL_HPP
30
31#include <opm/material/densead/Math.hpp>
32
33#include <opm/material/fluidsystems/BlackOilFluidSystem.hpp>
34
55
57
61
62#include <cassert>
63#include <istream>
64#include <memory>
65#include <ostream>
66#include <sstream>
67#include <stdexcept>
68#include <string>
69#include <tuple>
70#include <vector>
71
72namespace Opm {
73
74template <class TypeTag>
75class BlackOilModel;
76
77}
78
79namespace Opm::Properties {
80
81namespace TTag {
82
85{ using InheritsFrom = std::tuple<VtkBlackOilPolymer, MultiPhaseBaseModel>; };
86} // namespace TTag
87
89template<class TypeTag>
90struct LocalResidual<TypeTag, TTag::BlackOilModel>
92
94template<class TypeTag>
95struct NewtonMethod<TypeTag, TTag::BlackOilModel>
97
99template<class TypeTag>
100struct Model<TypeTag, TTag::BlackOilModel>
102
104template<class TypeTag>
105struct BaseProblem<TypeTag, TTag::BlackOilModel>
107
109template<class TypeTag>
110struct RateVector<TypeTag, TTag::BlackOilModel>
112
114template<class TypeTag>
115struct BoundaryRateVector<TypeTag, TTag::BlackOilModel>
117
119template<class TypeTag>
120struct PrimaryVariables<TypeTag, TTag::BlackOilModel>
122
124template<class TypeTag>
125struct IntensiveQuantities<TypeTag, TTag::BlackOilModel>
127
129template<class TypeTag>
130struct ExtensiveQuantities<TypeTag, TTag::BlackOilModel>
132
135template<class TypeTag>
136struct FluxModule<TypeTag, TTag::BlackOilModel>
138
140template<class TypeTag>
141struct Indices<TypeTag, TTag::BlackOilModel>
142{
144 getPropValue<TypeTag, Properties::EnableExtbo>(),
145 getPropValue<TypeTag, Properties::EnablePolymer>(),
146 getPropValue<TypeTag, Properties::EnableEnergy>(),
147 getPropValue<TypeTag, Properties::EnableFoam>(),
148 getPropValue<TypeTag, Properties::EnableBrine>(),
149 /*PVOffset=*/0,
150 getPropValue<TypeTag, Properties::EnableBioeffects>()>;
151};
152
154template<class TypeTag>
155struct FluidSystem<TypeTag, TTag::BlackOilModel>
156{
157public:
160 using type = BlackOilFluidSystem<Scalar>;
161};
162
163// by default, all ECL extension modules are disabled
164template<class TypeTag>
165struct EnableSolvent<TypeTag, TTag::BlackOilModel>
166{ static constexpr bool value = false; };
167
168template<class TypeTag>
169struct EnableExtbo<TypeTag, TTag::BlackOilModel>
170{ static constexpr bool value = false; };
171
172template<class TypeTag>
173struct EnablePolymer<TypeTag, TTag::BlackOilModel>
174{ static constexpr bool value = false; };
175
176template<class TypeTag>
177struct EnablePolymerMW<TypeTag, TTag::BlackOilModel>
178{ static constexpr bool value = false; };
179
180template<class TypeTag>
181struct EnableFoam<TypeTag, TTag::BlackOilModel>
182{ static constexpr bool value = false; };
183
184template<class TypeTag>
185struct EnableBrine<TypeTag, TTag::BlackOilModel>
186{ static constexpr bool value = false; };
187
188template<class TypeTag>
189struct EnableVapwat<TypeTag, TTag::BlackOilModel>
190{ static constexpr bool value = false; };
191
192template<class TypeTag>
193struct EnableDisgasInWater<TypeTag, TTag::BlackOilModel>
194{ static constexpr bool value = false; };
195
196template<class TypeTag>
198{ static constexpr bool value = false; };
199
200template<class TypeTag>
201struct EnableBioeffects<TypeTag, TTag::BlackOilModel>
202{ static constexpr bool value = false; };
203
205template<class TypeTag>
206struct EnableTemperature<TypeTag, TTag::BlackOilModel>
207{ static constexpr bool value = false; };
208
209template<class TypeTag>
210struct EnableEnergy<TypeTag, TTag::BlackOilModel>
211{ static constexpr bool value = false; };
212
214template<class TypeTag>
215struct EnableDiffusion<TypeTag, TTag::BlackOilModel>
216{ static constexpr bool value = false; };
217
219template<class TypeTag>
220struct EnableDispersion<TypeTag, TTag::BlackOilModel>
221{ static constexpr bool value = false; };
222
223template<class TypeTag>
225{ static constexpr bool value = false; };
226
233template<class TypeTag>
235{
236private:
238 static constexpr Scalar alpha =
239 getPropValue<TypeTag, Properties::BlackoilConserveSurfaceVolume>() ? 1000.0 : 1.0;
240
241public:
242 using type = Scalar;
243 static constexpr Scalar value = 1.0/(30.0*4184.0*alpha);
244};
245
247template<class TypeTag>
249{
250private:
252 static constexpr Scalar alpha =
253 getPropValue<TypeTag, Properties::BlackoilConserveSurfaceVolume>() ? 1000.0 : 1.0;
254
255public:
256 using type = Scalar;
257 static constexpr Scalar value = 1.0/(10.0*alpha);
258};
259
260// by default, ebos formulates the conservation equations in terms of mass not surface
261// volumes
262template<class TypeTag>
264{ static constexpr bool value = false; };
265
266} // namespace Opm::Properties
267
268namespace Opm {
269
333template<class TypeTag >
335 : public MultiPhaseBaseModel<TypeTag>
336{
337public:
341
342private:
343 using Implementation = GetPropType<TypeTag, Properties::Model>;
345
350
351 enum { numComponents = FluidSystem::numComponents };
352 enum { numEq = getPropValue<TypeTag, Properties::NumEq>() };
353 enum { enableDiffusion = getPropValue<TypeTag, Properties::EnableDiffusion>() };
354 enum { enableDispersion = getPropValue<TypeTag, Properties::EnableDispersion>() };
355
356 static constexpr bool compositionSwitchEnabled = Indices::compositionSwitchIdx >= 0;
357 static constexpr bool waterEnabled = Indices::waterEnabled;
358
359 using SolventModule = BlackOilSolventModule<TypeTag>;
360 using ExtboModule = BlackOilExtboModule<TypeTag>;
361 using PolymerModule = BlackOilPolymerModule<TypeTag>;
362 using EnergyModule = BlackOilEnergyModule<TypeTag>;
363 using DiffusionModule = BlackOilDiffusionModule<TypeTag, enableDiffusion>;
364 using DispersionModule = BlackOilDispersionModule<TypeTag, enableDispersion>;
365 using BioeffectsModule = BlackOilBioeffectsModule<TypeTag>;
366
367public:
369
370 explicit BlackOilModel(Simulator& simulator)
371 : ParentType(simulator)
372 {
373 eqWeights_.resize(numEq, 1.0);
374 }
375
379 static void registerParameters()
380 {
382
387 DiffusionModule::registerParameters();
389
390 // register runtime parameters of the VTK output modules
394 }
395
399 static std::string name()
400 { return "blackoil"; }
401
405 std::string primaryVarName(int pvIdx) const
406 {
407 if (pvIdx == Indices::waterSwitchIdx) {
408 return "water_switching";
409 }
410 else if (pvIdx == Indices::pressureSwitchIdx) {
411 return "pressure_switching";
412 }
413 else if (static_cast<int>(pvIdx) == Indices::compositionSwitchIdx) {
414 return "composition_switching";
415 }
416 else if (SolventModule::primaryVarApplies(pvIdx)) {
417 return SolventModule::primaryVarName(pvIdx);
418 }
419 else if (ExtboModule::primaryVarApplies(pvIdx)) {
420 return ExtboModule::primaryVarName(pvIdx);
421 }
422 else if (PolymerModule::primaryVarApplies(pvIdx)) {
423 return PolymerModule::primaryVarName(pvIdx);
424 }
425 else if (EnergyModule::primaryVarApplies(pvIdx)) {
426 return EnergyModule::primaryVarName(pvIdx);
427 }
428 else {
429 throw std::logic_error("Invalid primary variable index");
430 }
431 }
432
436 std::string eqName(int eqIdx) const
437 {
438 if (Indices::conti0EqIdx <= eqIdx && eqIdx < Indices::conti0EqIdx + numComponents) {
439 std::ostringstream oss;
440 oss << "conti_" << FluidSystem::phaseName(eqIdx - Indices::conti0EqIdx);
441 return oss.str();
442 }
443 else if (SolventModule::eqApplies(eqIdx)) {
444 return SolventModule::eqName(eqIdx);
445 }
446 else if (ExtboModule::eqApplies(eqIdx)) {
447 return ExtboModule::eqName(eqIdx);
448 }
449 else if (PolymerModule::eqApplies(eqIdx)) {
450 return PolymerModule::eqName(eqIdx);
451 }
452 else if (EnergyModule::eqApplies(eqIdx)) {
453 return EnergyModule::eqName(eqIdx);
454 }
455 else {
456 throw std::logic_error("Invalid equation index");
457 }
458 }
459
463 Scalar primaryVarWeight(unsigned globalDofIdx, unsigned pvIdx) const
464 {
465 // do not care about the auxiliary equations as they are supposed to scale
466 // themselves
467 if (globalDofIdx >= this->numGridDof()) {
468 return 1.0;
469 }
470
471 // saturations are always in the range [0, 1]!
472 if (int(Indices::waterSwitchIdx) == int(pvIdx)) {
473 return 1.0;
474 }
475
476 // oil pressures usually are in the range of 100 to 500 bars for typical oil
477 // reservoirs (which is the only relevant application for the black-oil model).
478 else if (int(Indices::pressureSwitchIdx) == int(pvIdx)) {
479 return 1.0 / 300e5;
480 }
481
482 // deal with primary variables stemming from the solvent module
483 else if (SolventModule::primaryVarApplies(pvIdx)) {
485 }
486
487 // deal with primary variables stemming from the extBO module
488 else if (ExtboModule::primaryVarApplies(pvIdx)) {
489 return ExtboModule::primaryVarWeight(pvIdx);
490 }
491
492 // deal with primary variables stemming from the polymer module
493 else if (PolymerModule::primaryVarApplies(pvIdx)) {
495 }
496
497 // deal with primary variables stemming from the energy module
498 else if (EnergyModule::primaryVarApplies(pvIdx)) {
499 return EnergyModule::primaryVarWeight(pvIdx);
500 }
501
502 // if the primary variable is either the gas saturation, Rs or Rv
503 assert(int(Indices::compositionSwitchIdx) == int(pvIdx));
504
505 switch (this->solution(0)[globalDofIdx].primaryVarsMeaningGas()) {
506 case PrimaryVariables::GasMeaning::Sg: return 1.0; // gas saturation
507 case PrimaryVariables::GasMeaning::Rs: return 1.0 / 250.; // gas dissolution factor
508 case PrimaryVariables::GasMeaning::Rv: return 1.0 / 0.025; // oil vaporization factor
509 default: throw std::logic_error("Invalid primary variable meaning flag for gas");
510 }
511 }
512
519 Scalar eqWeight(unsigned globalDofIdx, unsigned eqIdx) const
520 {
521 // do not care about the auxiliary equations as they are supposed to scale
522 // themselves
523 if (globalDofIdx >= this->numGridDof()) {
524 return 1.0;
525 }
526
527 return eqWeights_[eqIdx];
528 }
529
530 void setEqWeight(unsigned eqIdx, Scalar value)
531 { eqWeights_[eqIdx] = value; }
532
541 template <class DofEntity>
542 void serializeEntity(std::ostream& outstream, const DofEntity& dof)
543 {
544 const unsigned dofIdx = static_cast<unsigned>(asImp_().dofMapper().index(dof));
545
546 // write phase state
547 if (!outstream.good()) {
548 throw std::runtime_error("Could not serialize degree of freedom " + std::to_string(dofIdx));
549 }
550
551 // write the primary variables
552 const auto& priVars = this->solution(/*timeIdx=*/0)[dofIdx];
553 for (unsigned eqIdx = 0; eqIdx < numEq; ++eqIdx) {
554 outstream << priVars[eqIdx] << " ";
555 }
556
557 // write the pseudo primary variables
558 outstream << static_cast<int>(priVars.primaryVarsMeaningGas()) << " ";
559 outstream << static_cast<int>(priVars.primaryVarsMeaningWater()) << " ";
560 outstream << static_cast<int>(priVars.primaryVarsMeaningPressure()) << " ";
561
562 outstream << priVars.pvtRegionIndex() << " ";
563
564 SolventModule::serializeEntity(asImp_(), outstream, dof);
565 ExtboModule::serializeEntity(asImp_(), outstream, dof);
566 PolymerModule::serializeEntity(asImp_(), outstream, dof);
567 EnergyModule::serializeEntity(asImp_(), outstream, dof);
568 }
569
578 template <class DofEntity>
579 void deserializeEntity(std::istream& instream,
580 const DofEntity& dof)
581 {
582 const unsigned dofIdx = static_cast<unsigned>(asImp_().dofMapper().index(dof));
583
584 // read in the "real" primary variables of the DOF
585 auto& priVars = this->solution(/*timeIdx=*/0)[dofIdx];
586 for (unsigned eqIdx = 0; eqIdx < numEq; ++eqIdx) {
587 if (!instream.good()) {
588 throw std::runtime_error("Could not deserialize degree of freedom " + std::to_string(dofIdx));
589 }
590 instream >> priVars[eqIdx];
591 }
592
593 // read the pseudo primary variables
594 unsigned primaryVarsMeaningGas;
595 instream >> primaryVarsMeaningGas;
596
597 unsigned primaryVarsMeaningWater;
598 instream >> primaryVarsMeaningWater;
599
600 unsigned primaryVarsMeaningPressure;
601 instream >> primaryVarsMeaningPressure;
602
603 unsigned pvtRegionIdx;
604 instream >> pvtRegionIdx;
605
606 if (!instream.good()) {
607 throw std::runtime_error("Could not deserialize degree of freedom " + std::to_string(dofIdx));
608 }
609
610 SolventModule::deserializeEntity(asImp_(), instream, dof);
611 ExtboModule::deserializeEntity(asImp_(), instream, dof);
612 PolymerModule::deserializeEntity(asImp_(), instream, dof);
613 EnergyModule::deserializeEntity(asImp_(), instream, dof);
614
615 using PVM_G = typename PrimaryVariables::GasMeaning;
616 using PVM_W = typename PrimaryVariables::WaterMeaning;
617 using PVM_P = typename PrimaryVariables::PressureMeaning;
618 priVars.setPrimaryVarsMeaningGas(static_cast<PVM_G>(primaryVarsMeaningGas));
619 priVars.setPrimaryVarsMeaningWater(static_cast<PVM_W>(primaryVarsMeaningWater));
620 priVars.setPrimaryVarsMeaningPressure(static_cast<PVM_P>(primaryVarsMeaningPressure));
621
622 priVars.setPvtRegionIndex(pvtRegionIdx);
623 }
624
632 template <class Restarter>
633 void deserialize(Restarter& res)
634 {
635 ParentType::deserialize(res);
636
637 // set the PVT indices of the primary variables. This is also done by writing
638 // them into the restart file and re-reading them, but it is better to calculate
639 // them from scratch because the input could have been changed in this regard...
640 ElementContext elemCtx(this->simulator_);
641 for (const auto& elem : elements(this->gridView())) {
642 elemCtx.updateStencil(elem);
643 for (unsigned dofIdx = 0; dofIdx < elemCtx.numPrimaryDof(/*timIdx=*/0); ++dofIdx) {
644 const unsigned globalDofIdx = elemCtx.globalSpaceIndex(dofIdx, /*timIdx=*/0);
645 updatePvtRegionIndex_(this->solution(/*timeIdx=*/0)[globalDofIdx],
646 elemCtx,
647 dofIdx,
648 /*timeIdx=*/0);
649 }
650 }
651
652 this->solution(/*timeIdx=*/1) = this->solution(/*timeIdx=*/0);
653 }
654
655/*
656 // hack: this interferes with the static polymorphism trick
657protected:
658 friend ParentType;
659 friend Discretization;
660*/
661
662 template <class Context>
664 const Context& context,
665 unsigned dofIdx,
666 unsigned timeIdx)
667 { updatePvtRegionIndex_(priVars, context, dofIdx, timeIdx); }
668
670 {
672
673 // add the VTK output modules which make sense for the blackoil model
674 SolventModule::registerOutputModules(asImp_(), this->simulator_);
675 PolymerModule::registerOutputModules(asImp_(), this->simulator_);
676 EnergyModule::registerOutputModules(asImp_(), this->simulator_);
677 BioeffectsModule::registerOutputModules(asImp_(), this->simulator_);
678
679 this->addOutputModule(std::make_unique<VtkBlackOilModule<TypeTag>>(this->simulator_));
680 this->addOutputModule(std::make_unique<VtkCompositionModule<TypeTag>>(this->simulator_));
681
682 if constexpr (enableDiffusion) {
683 this->addOutputModule(std::make_unique<VtkDiffusionModule<TypeTag>>(this->simulator_));
684 }
685 }
686
687private:
688 std::vector<Scalar> eqWeights_;
689
690 Implementation& asImp_()
691 { return *static_cast<Implementation*>(this); }
692
693 const Implementation& asImp_() const
694 { return *static_cast<const Implementation*>(this); }
695
696 template <class Context>
697 void updatePvtRegionIndex_(PrimaryVariables& priVars,
698 const Context& context,
699 unsigned dofIdx,
700 unsigned timeIdx)
701 {
702 const unsigned regionIdx = context.problem().pvtRegionIndex(context, dofIdx, timeIdx);
703 priVars.setPvtRegionIndex(regionIdx);
704 }
705};
706
707} // namespace Opm
708
709#endif // OPM_BLACK_OIL_MODEL_HPP
Contains the classes required to extend the black-oil model by bioeffects.
Contains the classes required to extend the black-oil model by brine.
This file contains the default flux module of the blackoil model.
Classes required for molecular diffusion.
Classes required for mechanical dispersion.
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.
static void registerParameters()
Register all run-time parameters for the black-oil bioeffects module.
Definition: blackoilbioeffectsmodules.hh:139
static void registerOutputModules(Model &model, Simulator &simulator)
Register all bioeffects specific VTK and ECL output modules.
Definition: blackoilbioeffectsmodules.hh:148
Implements a boundary vector for the fully implicit black-oil model.
Definition: blackoilboundaryratevector.hh:48
static void registerParameters()
Register all run-time parameters for the black-oil energy module.
Definition: blackoilenergymodules.hh:84
static void deserializeEntity(Model &model, std::istream &instream, const DofEntity &dof)
Definition: blackoilenergymodules.hh:316
static bool primaryVarApplies(unsigned pvIdx)
Definition: blackoilenergymodules.hh:102
static std::string primaryVarName(unsigned pvIdx)
Definition: blackoilenergymodules.hh:112
static std::string eqName(unsigned eqIdx)
Definition: blackoilenergymodules.hh:137
static void serializeEntity(const Model &model, std::ostream &outstream, const DofEntity &dof)
Definition: blackoilenergymodules.hh:306
static Scalar primaryVarWeight(unsigned pvIdx)
Definition: blackoilenergymodules.hh:119
static void registerOutputModules(Model &model, Simulator &simulator)
Register all energy specific VTK and ECL output modules.
Definition: blackoilenergymodules.hh:94
static bool eqApplies(unsigned eqIdx)
Definition: blackoilenergymodules.hh:127
static bool primaryVarApplies(unsigned pvIdx)
Definition: blackoilextbomodules.hh:105
static std::string eqName(unsigned eqIdx)
Definition: blackoilextbomodules.hh:140
static bool eqApplies(unsigned eqIdx)
Definition: blackoilextbomodules.hh:130
static Scalar primaryVarWeight(unsigned pvIdx)
Definition: blackoilextbomodules.hh:122
static void serializeEntity(const Model &model, std::ostream &outstream, const DofEntity &dof)
Definition: blackoilextbomodules.hh:289
static void registerParameters()
Register all run-time parameters for the black-oil solvent module.
Definition: blackoilextbomodules.hh:95
static void deserializeEntity(Model &model, std::istream &instream, const DofEntity &dof)
Definition: blackoilextbomodules.hh:300
static std::string primaryVarName(unsigned pvIdx)
Definition: blackoilextbomodules.hh:115
This template class contains the data which is required to calculate the fluxes of the fluid phases o...
Definition: blackoilextensivequantities.hh:59
Contains the quantities which are are constant within a finite volume in the black-oil model.
Definition: blackoilintensivequantities.hh:85
Calculates the local residual of the black oil model.
Definition: blackoillocalresidual.hh:56
A fully-implicit black-oil flow model.
Definition: blackoilmodel.hh:336
GetPropType< TypeTag, Properties::PrimaryVariables > PrimaryVariables
Definition: blackoilmodel.hh:340
BlackOilModel(Simulator &simulator)
Definition: blackoilmodel.hh:370
std::string primaryVarName(int pvIdx) const
Given an primary variable index, return a human readable name.
Definition: blackoilmodel.hh:405
Scalar primaryVarWeight(unsigned globalDofIdx, unsigned pvIdx) const
Returns the relative weight of a primary variable for calculating relative errors.
Definition: blackoilmodel.hh:463
Scalar eqWeight(unsigned globalDofIdx, unsigned eqIdx) const
Returns the relative weight of an equation.
Definition: blackoilmodel.hh:519
void supplementInitialSolution_(PrimaryVariables &priVars, const Context &context, unsigned dofIdx, unsigned timeIdx)
Definition: blackoilmodel.hh:663
void serializeEntity(std::ostream &outstream, const DofEntity &dof)
Write the current solution for a degree of freedom to a restart file.
Definition: blackoilmodel.hh:542
void registerOutputModules_()
Definition: blackoilmodel.hh:669
std::string eqName(int eqIdx) const
Given an equation index, return a human readable name.
Definition: blackoilmodel.hh:436
GetPropType< TypeTag, Properties::FluidSystem > FluidSystem
Definition: blackoilmodel.hh:339
static std::string name()
Definition: blackoilmodel.hh:399
GetPropType< TypeTag, Properties::Indices > Indices
Definition: blackoilmodel.hh:338
void deserializeEntity(std::istream &instream, const DofEntity &dof)
Reads the current solution variables for a degree of freedom from a restart file.
Definition: blackoilmodel.hh:579
GetPropType< TypeTag, Properties::LocalResidual > LocalResidual
Definition: blackoilmodel.hh:368
static void registerParameters()
Register all run-time parameters for the immiscible model.
Definition: blackoilmodel.hh:379
void setEqWeight(unsigned eqIdx, Scalar value)
Definition: blackoilmodel.hh:530
void deserialize(Restarter &res)
Deserializes the state of the model.
Definition: blackoilmodel.hh:633
A newton solver which is specific to the black oil model.
Definition: blackoilnewtonmethod.hpp:61
static std::string primaryVarName(unsigned pvIdx)
Definition: blackoilpolymermodules.hh:179
static void serializeEntity(const Model &model, std::ostream &outstream, const DofEntity &dof)
Definition: blackoilpolymermodules.hh:339
static void registerParameters()
Register all run-time parameters for the black-oil polymer module.
Definition: blackoilpolymermodules.hh:146
static bool eqApplies(unsigned eqIdx)
Definition: blackoilpolymermodules.hh:199
static Scalar primaryVarWeight(unsigned pvIdx)
Definition: blackoilpolymermodules.hh:191
static void registerOutputModules(Model &model, Simulator &simulator)
Register all polymer specific VTK and ECL output modules.
Definition: blackoilpolymermodules.hh:156
static bool primaryVarApplies(unsigned pvIdx)
Definition: blackoilpolymermodules.hh:164
static std::string eqName(unsigned eqIdx)
Definition: blackoilpolymermodules.hh:214
static void deserializeEntity(Model &model, std::istream &instream, const DofEntity &dof)
Definition: blackoilpolymermodules.hh:350
Represents the primary variables used by the black-oil model.
Definition: blackoilprimaryvariables.hh:68
Base class for all problems which use the black-oil model.
Definition: blackoilproblem.hh:43
Implements a vector representing mass, molar or volumetric rates for the black oil model.
Definition: blackoilratevector.hh:62
static Scalar primaryVarWeight(unsigned pvIdx)
Definition: blackoilsolventmodules.hh:149
static std::string eqName(unsigned eqIdx)
Definition: blackoilsolventmodules.hh:167
static void serializeEntity(const Model &model, std::ostream &outstream, const DofEntity &dof)
Definition: blackoilsolventmodules.hh:337
static void registerOutputModules(Model &model, Simulator &simulator)
Register all solvent specific VTK and ECL output modules.
Definition: blackoilsolventmodules.hh:124
static void registerParameters()
Register all run-time parameters for the black-oil solvent module.
Definition: blackoilsolventmodules.hh:114
static std::string primaryVarName(unsigned pvIdx)
Definition: blackoilsolventmodules.hh:142
static bool eqApplies(unsigned eqIdx)
Definition: blackoilsolventmodules.hh:157
static void deserializeEntity(Model &model, std::istream &instream, const DofEntity &dof)
Definition: blackoilsolventmodules.hh:348
static bool primaryVarApplies(unsigned pvIdx)
Definition: blackoilsolventmodules.hh:132
A base class for fully-implicit multi-phase porous-media flow models which assume multiple fluid phas...
Definition: multiphasebasemodel.hh:168
static void registerParameters()
Register all run-time parameters for the immiscible model.
Definition: multiphasebasemodel.hh:194
void registerOutputModules_()
Definition: multiphasebasemodel.hh:270
VTK output module for the black oil model's parameters.
Definition: vtkblackoilmodule.hpp:57
static void registerParameters()
Register all run-time parameters for the multi-phase VTK output module.
Definition: vtkblackoilmodule.hpp:93
VTK output module for the fluid composition.
Definition: vtkcompositionmodule.hpp:57
static void registerParameters()
Register all run-time parameters for the Vtk output module.
Definition: vtkcompositionmodule.hpp:87
VTK output module for quantities which make sense for models which incorperate molecular diffusion.
Definition: vtkdiffusionmodule.hpp:58
static void registerParameters()
Register all run-time parameters for the Vtk output module.
Definition: vtkdiffusionmodule.hpp:88
Definition: blackoilmodel.hh:79
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)
Provides a Darcy flux module for the blackoil model.
Definition: blackoildarcyfluxmodule.hh:49
The primary variable and equation indices for the three-phase black-oil model.
Definition: blackoilvariableandequationindices.hh:47
The type of the base class for all problems which use this model.
Definition: fvbaseproperties.hh:84
Definition: blackoilproperties.hh:101
Similarly to the energy equation, a scaling is applied to the urea equation in MICP.
Definition: blackoilproperties.hh:105
Enable surface volume scaling.
Definition: blackoilproperties.hh:59
Type of object for specifying boundary conditions.
Definition: fvbaseproperties.hh:119
Enable the ECL-blackoil extension for bioeffects (biofilm/MICP)
Definition: blackoilproperties.hh:83
Enable the ECL-blackoil extension for salt.
Definition: blackoilproperties.hh:67
Enable convective mixing?
Definition: multiphasebaseproperties.hh:99
Enable diffusive fluxes?
Definition: multiphasebaseproperties.hh:91
Enable the ECL-blackoil extension for disolution of gas into water.
Definition: blackoilproperties.hh:79
Enable dispersive fluxes?
Definition: multiphasebaseproperties.hh:95
Specify whether energy should be considered as a conservation quantity or not.
Definition: multiphasebaseproperties.hh:87
Enable the ECL-blackoil extension for extended BO. ("Second gas" - alternative approach)
Definition: blackoilproperties.hh:47
Enable the ECL-blackoil extension for foam.
Definition: blackoilproperties.hh:63
Enable the tracking polymer molecular weight tracking and related functionalities.
Definition: blackoilproperties.hh:55
Enable the ECL-blackoil extension for polymer.
Definition: blackoilproperties.hh:51
Enable the ECL-blackoil extension for salt precipitation.
Definition: blackoilproperties.hh:71
Enable the ECL-blackoil extension for solvents. ("Second gas")
Definition: blackoilproperties.hh:43
Definition: blackoilproperties.hh:88
Enable the ECL-blackoil extension for water evaporation.
Definition: blackoilproperties.hh:75
Data required to calculate a flux over a face.
Definition: fvbaseproperties.hh:149
GetPropType< TypeTag, Properties::Evaluation > Evaluation
Definition: blackoilmodel.hh:159
GetPropType< TypeTag, Properties::Scalar > Scalar
Definition: blackoilmodel.hh:158
BlackOilFluidSystem< Scalar > type
Definition: blackoilmodel.hh:160
The fluid systems including the information about the phases.
Definition: multiphasebaseproperties.hh:79
Specifies the relation used for velocity.
Definition: multiphasebaseproperties.hh:83
Enumerations used by the model.
Definition: multiphasebaseproperties.hh:51
The secondary variables within a sub-control volume.
Definition: fvbaseproperties.hh:133
The type of the local residual function.
Definition: fvbaseproperties.hh:94
The type of the model.
Definition: basicproperties.hh:88
Specifies the type of the actual Newton method.
Definition: newtonmethodproperties.hh:32
A vector of primary variables within a sub-control volume.
Definition: fvbaseproperties.hh:130
Vector containing volumetric or areal rates of quantities.
Definition: fvbaseproperties.hh:116
The type tag for the black-oil problems.
Definition: blackoilmodel.hh:85
std::tuple< VtkBlackOilPolymer, MultiPhaseBaseModel > InheritsFrom
Definition: blackoilmodel.hh:85