My Project
Loading...
Searching...
No Matches
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 <sstream>
63#include <string>
64
65namespace Opm {
66
67template <class TypeTag>
68class BlackOilModel;
69
70}
71
72namespace Opm::Properties {
73
74namespace TTag {
75
78{ using InheritsFrom = std::tuple<VtkBlackOilPolymer, MultiPhaseBaseModel>; };
79} // namespace TTag
80
82template<class TypeTag>
84
86template<class TypeTag>
88
90template<class TypeTag>
91struct Model<TypeTag, TTag::BlackOilModel> { using type = BlackOilModel<TypeTag>; };
92
94template<class TypeTag>
95struct BaseProblem<TypeTag, TTag::BlackOilModel> { using type = BlackOilProblem<TypeTag>; };
96
98template<class TypeTag>
99struct RateVector<TypeTag, TTag::BlackOilModel> { using type = BlackOilRateVector<TypeTag>; };
100
102template<class TypeTag>
104
106template<class TypeTag>
108
110template<class TypeTag>
112
114template<class TypeTag>
116
119template<class TypeTag>
121
123template<class TypeTag>
133
135template<class TypeTag>
136struct FluidSystem<TypeTag, TTag::BlackOilModel>
137{
138public:
141 using type = BlackOilFluidSystem<Scalar>;
142};
143
144// by default, all ECL extension modules are disabled
145template<class TypeTag>
146struct EnableSolvent<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
147template<class TypeTag>
148struct EnableExtbo<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
149template<class TypeTag>
150struct EnablePolymer<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
151template<class TypeTag>
152struct EnablePolymerMW<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
153template<class TypeTag>
154struct EnableFoam<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
155template<class TypeTag>
156struct EnableBrine<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
157template<class TypeTag>
158struct EnableVapwat<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
159template<class TypeTag>
160struct EnableDisgasInWater<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
161template<class TypeTag>
162struct EnableSaltPrecipitation<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
163template<class TypeTag>
164struct EnableMICP<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
165
167template<class TypeTag>
168struct EnableTemperature<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
169template<class TypeTag>
170struct EnableEnergy<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
171
173template<class TypeTag>
174struct EnableDiffusion<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
175
177template<class TypeTag>
178struct EnableDispersion<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
179template<class TypeTag>
180struct EnableConvectiveMixing<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
181
188template<class TypeTag>
190{
191private:
193 static constexpr Scalar alpha = getPropValue<TypeTag, Properties::BlackoilConserveSurfaceVolume>() ? 1000.0 : 1.0;
194
195public:
196 using type = Scalar;
197 static constexpr Scalar value = 1.0/(30.0*4184.0*alpha);
198};
199
201template<class TypeTag>
203{
204private:
206 static constexpr Scalar alpha = getPropValue<TypeTag, Properties::BlackoilConserveSurfaceVolume>() ? 1000.0 : 1.0;
207
208public:
209 using type = Scalar;
210 static constexpr Scalar value = 1.0/(10.0*alpha);
211};
212
213// by default, ebos formulates the conservation equations in terms of mass not surface
214// volumes
215template<class TypeTag>
216struct BlackoilConserveSurfaceVolume<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
217
218} // namespace Opm::Properties
219
220namespace Opm {
221
285template<class TypeTag >
287 : public MultiPhaseBaseModel<TypeTag>
288{
289public:
293private:
294 using Implementation = GetPropType<TypeTag, Properties::Model>;
296
301
303 enum { numComponents = FluidSystem::numComponents };
305 enum { enableDiffusion = getPropValue<TypeTag, Properties::EnableDiffusion>() };
306 enum { enableDispersion = getPropValue<TypeTag, Properties::EnableDispersion>() };
307
308 static constexpr bool compositionSwitchEnabled = Indices::compositionSwitchIdx >= 0;
309 static constexpr bool waterEnabled = Indices::waterEnabled;
310
318
319public:
320
322
323 explicit BlackOilModel(Simulator& simulator)
324 : ParentType(simulator)
325 {
326 eqWeights_.resize(numEq, 1.0);
327 }
328
348
352 static std::string name()
353 { return "blackoil"; }
354
358 std::string primaryVarName(int pvIdx) const
359 {
360 std::ostringstream oss;
361
362 if (pvIdx == Indices::waterSwitchIdx)
363 oss << "water_switching";
364 else if (pvIdx == Indices::pressureSwitchIdx)
365 oss << "pressure_switching";
366 else if (static_cast<int>(pvIdx) == Indices::compositionSwitchIdx)
367 oss << "composition_switching";
368 else if (SolventModule::primaryVarApplies(pvIdx))
369 return SolventModule::primaryVarName(pvIdx);
370 else if (ExtboModule::primaryVarApplies(pvIdx))
371 return ExtboModule::primaryVarName(pvIdx);
372 else if (PolymerModule::primaryVarApplies(pvIdx))
373 return PolymerModule::primaryVarName(pvIdx);
374 else if (EnergyModule::primaryVarApplies(pvIdx))
375 return EnergyModule::primaryVarName(pvIdx);
376 else
377 assert(false);
378
379 return oss.str();
380 }
381
385 std::string eqName(int eqIdx) const
386 {
387 std::ostringstream oss;
388
389 if (Indices::conti0EqIdx <= eqIdx && eqIdx < Indices::conti0EqIdx + numComponents)
390 oss << "conti_" << FluidSystem::phaseName(eqIdx - Indices::conti0EqIdx);
391 else if (SolventModule::eqApplies(eqIdx))
392 return SolventModule::eqName(eqIdx);
393 else if (ExtboModule::eqApplies(eqIdx))
394 return ExtboModule::eqName(eqIdx);
395 else if (PolymerModule::eqApplies(eqIdx))
396 return PolymerModule::eqName(eqIdx);
397 else if (EnergyModule::eqApplies(eqIdx))
398 return EnergyModule::eqName(eqIdx);
399 else
400 assert(false);
401
402 return oss.str();
403 }
404
408 Scalar primaryVarWeight(unsigned globalDofIdx, unsigned pvIdx) const
409 {
410 // do not care about the auxiliary equations as they are supposed to scale
411 // themselves
412 if (globalDofIdx >= this->numGridDof())
413 return 1.0;
414
415 // saturations are always in the range [0, 1]!
416 if (int(Indices::waterSwitchIdx) == int(pvIdx))
417 return 1.0;
418
419 // oil pressures usually are in the range of 100 to 500 bars for typical oil
420 // reservoirs (which is the only relevant application for the black-oil model).
421 else if (int(Indices::pressureSwitchIdx) == int(pvIdx))
422 return 1.0/300e5;
423
424 // deal with primary variables stemming from the solvent module
425 else if (SolventModule::primaryVarApplies(pvIdx))
426 return SolventModule::primaryVarWeight(pvIdx);
427
428 // deal with primary variables stemming from the extBO module
429 else if (ExtboModule::primaryVarApplies(pvIdx))
430 return ExtboModule::primaryVarWeight(pvIdx);
431
432 // deal with primary variables stemming from the polymer module
433 else if (PolymerModule::primaryVarApplies(pvIdx))
434 return PolymerModule::primaryVarWeight(pvIdx);
435
436 // deal with primary variables stemming from the energy module
437 else if (EnergyModule::primaryVarApplies(pvIdx))
438 return EnergyModule::primaryVarWeight(pvIdx);
439
440 // if the primary variable is either the gas saturation, Rs or Rv
441 assert(int(Indices::compositionSwitchIdx) == int(pvIdx));
442
443 auto pvMeaning = this->solution(0)[globalDofIdx].primaryVarsMeaningGas();
444 if (pvMeaning == PrimaryVariables::GasMeaning::Sg)
445 return 1.0; // gas saturation
446 else if (pvMeaning == PrimaryVariables::GasMeaning::Rs)
447 return 1.0/250.; // gas dissolution factor
448 else {
449 assert(pvMeaning == PrimaryVariables::GasMeaning::Rv);
450 return 1.0/0.025; // oil vaporization factor
451 }
452
453 }
454
458 Scalar eqWeight(unsigned globalDofIdx, unsigned eqIdx) const
459 {
460 // do not care about the auxiliary equations as they are supposed to scale
461 // themselves
462 if (globalDofIdx >= this->numGridDof())
463 return 1.0;
464
465 return eqWeights_[eqIdx];
466 }
467
468 void setEqWeight(unsigned eqIdx, Scalar value) {
469 eqWeights_[eqIdx] = value;
470 }
471
480 template <class DofEntity>
481 void serializeEntity(std::ostream& outstream, const DofEntity& dof)
482 {
483 unsigned dofIdx = static_cast<unsigned>(asImp_().dofMapper().index(dof));
484
485 // write phase state
486 if (!outstream.good())
487 throw std::runtime_error("Could not serialize degree of freedom "+std::to_string(dofIdx));
488
489 // write the primary variables
490 const auto& priVars = this->solution(/*timeIdx=*/0)[dofIdx];
491 for (unsigned eqIdx = 0; eqIdx < numEq; ++eqIdx)
492 outstream << priVars[eqIdx] << " ";
493
494 // write the pseudo primary variables
495 outstream << static_cast<int>(priVars.primaryVarsMeaningGas()) << " ";
496 outstream << static_cast<int>(priVars.primaryVarsMeaningWater()) << " ";
497 outstream << static_cast<int>(priVars.primaryVarsMeaningPressure()) << " ";
498
499 outstream << priVars.pvtRegionIndex() << " ";
500
501 SolventModule::serializeEntity(asImp_(), outstream, dof);
502 ExtboModule::serializeEntity(asImp_(), outstream, dof);
503 PolymerModule::serializeEntity(asImp_(), outstream, dof);
504 EnergyModule::serializeEntity(asImp_(), outstream, dof);
505 }
506
515 template <class DofEntity>
516 void deserializeEntity(std::istream& instream,
517 const DofEntity& dof)
518 {
519 unsigned dofIdx = static_cast<unsigned>(asImp_().dofMapper().index(dof));
520
521 // read in the "real" primary variables of the DOF
522 auto& priVars = this->solution(/*timeIdx=*/0)[dofIdx];
523 for (unsigned eqIdx = 0; eqIdx < numEq; ++eqIdx) {
524 if (!instream.good())
525 throw std::runtime_error("Could not deserialize degree of freedom "+std::to_string(dofIdx));
526 instream >> priVars[eqIdx];
527 }
528
529 // read the pseudo primary variables
530 unsigned primaryVarsMeaningGas;
531 instream >> primaryVarsMeaningGas;
532
533 unsigned primaryVarsMeaningWater;
534 instream >> primaryVarsMeaningWater;
535
536 unsigned primaryVarsMeaningPressure;
537 instream >> primaryVarsMeaningPressure;
538
539 unsigned pvtRegionIdx;
540 instream >> pvtRegionIdx;
541
542 if (!instream.good())
543 throw std::runtime_error("Could not deserialize degree of freedom "+std::to_string(dofIdx));
544
545 SolventModule::deserializeEntity(asImp_(), instream, dof);
546 ExtboModule::deserializeEntity(asImp_(), instream, dof);
547 PolymerModule::deserializeEntity(asImp_(), instream, dof);
548 EnergyModule::deserializeEntity(asImp_(), instream, dof);
549
550 using PVM_G = typename PrimaryVariables::GasMeaning;
551 using PVM_W = typename PrimaryVariables::WaterMeaning;
552 using PVM_P = typename PrimaryVariables::PressureMeaning;
553 priVars.setPrimaryVarsMeaningGas(static_cast<PVM_G>(primaryVarsMeaningGas));
554 priVars.setPrimaryVarsMeaningWater(static_cast<PVM_W>(primaryVarsMeaningWater));
555 priVars.setPrimaryVarsMeaningPressure(static_cast<PVM_P>(primaryVarsMeaningPressure));
556
557 priVars.setPvtRegionIndex(pvtRegionIdx);
558 }
559
567 template <class Restarter>
569 {
570 ParentType::deserialize(res);
571
572 // set the PVT indices of the primary variables. This is also done by writing
573 // them into the restart file and re-reading them, but it is better to calculate
574 // them from scratch because the input could have been changed in this regard...
575 ElementContext elemCtx(this->simulator_);
576 for (const auto& elem : elements(this->gridView())) {
577 elemCtx.updateStencil(elem);
578 for (unsigned dofIdx = 0; dofIdx < elemCtx.numPrimaryDof(/*timIdx=*/0); ++dofIdx) {
579 unsigned globalDofIdx = elemCtx.globalSpaceIndex(dofIdx, /*timIdx=*/0);
580 updatePvtRegionIndex_(this->solution(/*timeIdx=*/0)[globalDofIdx],
581 elemCtx,
582 dofIdx,
583 /*timeIdx=*/0);
584 }
585 }
586
587 this->solution(/*timeIdx=*/1) = this->solution(/*timeIdx=*/0);
588 }
589
590/*
591 // hack: this interferes with the static polymorphism trick
592protected:
593 friend ParentType;
594 friend Discretization;
595*/
596
597 template <class Context>
598 void supplementInitialSolution_(PrimaryVariables& priVars,
599 const Context& context,
600 unsigned dofIdx,
601 unsigned timeIdx)
602 { updatePvtRegionIndex_(priVars, context, dofIdx, timeIdx); }
603
604 void registerOutputModules_()
605 {
606 ParentType::registerOutputModules_();
607
608 // add the VTK output modules which make sense for the blackoil model
609 SolventModule::registerOutputModules(asImp_(), this->simulator_);
610 PolymerModule::registerOutputModules(asImp_(), this->simulator_);
611 EnergyModule::registerOutputModules(asImp_(), this->simulator_);
612 MICPModule::registerOutputModules(asImp_(), this->simulator_);
613
614 this->addOutputModule(new VtkBlackOilModule<TypeTag>(this->simulator_));
615 this->addOutputModule(new VtkCompositionModule<TypeTag>(this->simulator_));
616
617 if constexpr (enableDiffusion)
618 this->addOutputModule(new VtkDiffusionModule<TypeTag>(this->simulator_));
619 }
620
621private:
622 std::vector<Scalar> eqWeights_;
623 Implementation& asImp_()
624 { return *static_cast<Implementation*>(this); }
625 const Implementation& asImp_() const
626 { return *static_cast<const Implementation*>(this); }
627
628 template <class Context>
629 void updatePvtRegionIndex_(PrimaryVariables& priVars,
630 const Context& context,
631 unsigned dofIdx,
632 unsigned timeIdx)
633 {
634 unsigned regionIdx = context.problem().pvtRegionIndex(context, dofIdx, timeIdx);
635 priVars.setPvtRegionIndex(regionIdx);
636 }
637};
638
639} // namespace Opm
640
641#endif // OPM_BLACK_OIL_MODEL_HPP
Implements a boundary vector for the fully implicit black-oil model.
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.
This template class contains the data which is required to calculate the fluxes of the fluid phases o...
Contains the classes required to extend the black-oil model to include the effects of foam.
The primary variable and equation indices for the black-oil model.
Contains the quantities which are are constant within a finite volume in the black-oil model.
Calculates the local residual of the black oil model.
Contains the classes required to extend the black-oil model by MICP.
A newton solver which is specific to the black oil model.
Contains the classes required to extend the black-oil model by polymer.
Represents the primary variables used by the black-oil model.
Base class for all problems which use the black-oil model.
Declares the properties required by the black oil model.
Implements a vector representing mass, molar or volumetric rates for the black oil model.
Contains the classes required to extend the black-oil model by solvents.
The primary variable and equation indices for the black-oil model.
Implements a boundary vector for the fully implicit black-oil model.
Definition blackoilboundaryratevector.hh:46
Provides the auxiliary methods required for consideration of the diffusion equation.
Definition blackoildiffusionmodule.hh:49
Provides the auxiliary methods required for consideration of the dispersion equation.
Definition blackoildispersionmodule.hh:50
Contains the high level supplements required to extend the black oil model by energy.
Definition blackoilenergymodules.hh:52
static void registerParameters()
Register all run-time parameters for the black-oil energy module.
Definition blackoilenergymodules.hh:77
static void registerOutputModules(Model &model, Simulator &simulator)
Register all energy specific VTK and ECL output modules.
Definition blackoilenergymodules.hh:86
Contains the high level supplements required to extend the black oil model.
Definition blackoilextbomodules.hh:59
static void registerParameters()
Register all run-time parameters for the black-oil solvent module.
Definition blackoilextbomodules.hh:98
This template class contains the data which is required to calculate the fluxes of the fluid phases o...
Definition blackoilextensivequantities.hh:60
Contains the quantities which are are constant within a finite volume in the black-oil model.
Definition blackoilintensivequantities.hh:82
Calculates the local residual of the black oil model.
Definition blackoillocalresidual.hh:51
Contains the high level supplements required to extend the black oil model by MICP.
Definition blackoilmicpmodules.hh:49
static void registerParameters()
Register all run-time parameters for the black-oil MICP module.
Definition blackoilmicpmodules.hh:96
static void registerOutputModules(Model &model, Simulator &simulator)
Register all MICP specific VTK and ECL output modules.
Definition blackoilmicpmodules.hh:105
A fully-implicit black-oil flow model.
Definition blackoilmodel.hh:288
std::string primaryVarName(int pvIdx) const
Given an primary variable index, return a human readable name.
Definition blackoilmodel.hh:358
Scalar primaryVarWeight(unsigned globalDofIdx, unsigned pvIdx) const
Returns the relative weight of a primary variable for calculating relative errors.
Definition blackoilmodel.hh:408
Scalar eqWeight(unsigned globalDofIdx, unsigned eqIdx) const
Returns the relative weight of an equation.
Definition blackoilmodel.hh:458
void serializeEntity(std::ostream &outstream, const DofEntity &dof)
Write the current solution for a degree of freedom to a restart file.
Definition blackoilmodel.hh:481
std::string eqName(int eqIdx) const
Given an equation index, return a human readable name.
Definition blackoilmodel.hh:385
static std::string name()
Definition blackoilmodel.hh:352
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:516
static void registerParameters()
Register all run-time parameters for the immiscible model.
Definition blackoilmodel.hh:332
void deserialize(Restarter &res)
Deserializes the state of the model.
Definition blackoilmodel.hh:568
A newton solver which is specific to the black oil model.
Definition blackoilnewtonmethod.hpp:57
Contains the high level supplements required to extend the black oil model by polymer.
Definition blackoilpolymermodules.hh:54
static void registerParameters()
Register all run-time parameters for the black-oil polymer module.
Definition blackoilpolymermodules.hh:138
static void registerOutputModules(Model &model, Simulator &simulator)
Register all polymer specific VTK and ECL output modules.
Definition blackoilpolymermodules.hh:147
Represents the primary variables used by the black-oil model.
Definition blackoilprimaryvariables.hh:64
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:53
Contains the high level supplements required to extend the black oil model by solvents.
Definition blackoilsolventmodules.hh:58
static void registerOutputModules(Model &model, Simulator &simulator)
Register all solvent specific VTK and ECL output modules.
Definition blackoilsolventmodules.hh:117
static void registerParameters()
Register all run-time parameters for the black-oil solvent module.
Definition blackoilsolventmodules.hh:108
A base class for fully-implicit multi-phase porous-media flow models which assume multiple fluid phas...
Definition multiphasebasemodel.hh:153
static void registerParameters()
Register all run-time parameters for the immiscible model.
Definition multiphasebasemodel.hh:179
static void registerParameters()
Register all run-time parameters for the multi-phase VTK output module.
Definition vtkblackoilmodule.hpp:88
static void registerParameters()
Register all run-time parameters for the Vtk output module.
Definition vtkcompositionmodule.hpp:86
static void registerParameters()
Register all run-time parameters for the Vtk output module.
Definition vtkdiffusionmodule.hpp:87
A base class for fully-implicit multi-phase porous-media flow models which assume multiple fluid phas...
This file contains a set of helper functions used by VFPProd / VFPInj.
Definition blackoilboundaryratevector.hh:37
constexpr auto getPropValue()
get the value data member of a property
Definition propertysystem.hh:242
typename Properties::Detail::GetPropImpl< TypeTag, Property >::type::type GetPropType
get the type alias defined in the property (equivalent to old macro GET_PROP_TYPE(....
Definition propertysystem.hh:235
Provides a Darcy flux module for the blackoil model.
Definition blackoildarcyfluxmodule.hh:49
The primary variable and equation indices for the black-oil model.
Definition blackoilindices.hh:47
The type of the base class for all problems which use this model.
Definition fvbaseproperties.hh:84
The relative weight of the residual of the energy equation compared to the mass residuals.
Definition blackoilproperties.hh:91
Similarly to the energy equation, a scaling is applied to the urea equation in MICP.
Definition blackoilproperties.hh:95
Enable surface volume scaling.
Definition blackoilproperties.hh:54
Type of object for specifying boundary conditions.
Definition fvbaseproperties.hh:119
Enable the ECL-blackoil extension for salt.
Definition blackoilproperties.hh:60
Enable convective mixing?
Definition multiphasebaseproperties.hh:85
Enable diffusive fluxes?
Definition multiphasebaseproperties.hh:79
Enable the ECL-blackoil extension for disolution of gas into water.
Definition blackoilproperties.hh:69
Enable dispersive fluxes?
Definition multiphasebaseproperties.hh:82
Specify whether energy should be considered as a conservation quantity or not.
Definition multiphasebaseproperties.hh:76
Enable the ECL-blackoil extension for extended BO. ("Second gas" - alternative approach)
Definition blackoilproperties.hh:45
Enable the ECL-blackoil extension for foam.
Definition blackoilproperties.hh:57
Enable the ECL-blackoil extension for MICP.
Definition blackoilproperties.hh:72
Enable the tracking polymer molecular weight tracking and related functionalities.
Definition blackoilproperties.hh:51
Enable the ECL-blackoil extension for polymer.
Definition blackoilproperties.hh:48
Enable the ECL-blackoil extension for salt precipitation.
Definition blackoilproperties.hh:63
Enable the ECL-blackoil extension for solvents. ("Second gas")
Definition blackoilproperties.hh:42
Allow the spatial and temporal domains to exhibit non-constant temperature in the black-oil model.
Definition blackoilproperties.hh:78
Enable the ECL-blackoil extension for water evaporation.
Definition blackoilproperties.hh:66
Data required to calculate a flux over a face.
Definition fvbaseproperties.hh:149
The fluid systems including the information about the phases.
Definition multiphasebaseproperties.hh:69
Specifies the relation used for velocity.
Definition multiphasebaseproperties.hh:72
Enumerations used by the model.
Definition multiphasebaseproperties.hh:48
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:78
VTK output module for the black oil model's parameters.
VTK output module for the fluid composition.
VTK output module for quantities which make sense for models which incorperate molecular diffusion.