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
200// by default, ebos formulates the conservation equations in terms of mass not surface
201// volumes
202template<class TypeTag>
203struct BlackoilConserveSurfaceVolume<TypeTag, TTag::BlackOilModel> { static constexpr bool value = false; };
204
205} // namespace Opm::Properties
206
207namespace Opm {
208
272template<class TypeTag >
274 : public MultiPhaseBaseModel<TypeTag>
275{
276public:
280private:
281 using Implementation = GetPropType<TypeTag, Properties::Model>;
283
288
290 enum { numComponents = FluidSystem::numComponents };
292 enum { enableDiffusion = getPropValue<TypeTag, Properties::EnableDiffusion>() };
293 enum { enableDispersion = getPropValue<TypeTag, Properties::EnableDispersion>() };
294
295 static constexpr bool compositionSwitchEnabled = Indices::compositionSwitchIdx >= 0;
296 static constexpr bool waterEnabled = Indices::waterEnabled;
297
305
306public:
307
309
310 explicit BlackOilModel(Simulator& simulator)
311 : ParentType(simulator)
312 {
313 eqWeights_.resize(numEq, 1.0);
314 }
315
335
339 static std::string name()
340 { return "blackoil"; }
341
345 std::string primaryVarName(int pvIdx) const
346 {
347 std::ostringstream oss;
348
349 if (pvIdx == Indices::waterSwitchIdx)
350 oss << "water_switching";
351 else if (pvIdx == Indices::pressureSwitchIdx)
352 oss << "pressure_switching";
353 else if (static_cast<int>(pvIdx) == Indices::compositionSwitchIdx)
354 oss << "composition_switching";
355 else if (SolventModule::primaryVarApplies(pvIdx))
356 return SolventModule::primaryVarName(pvIdx);
357 else if (ExtboModule::primaryVarApplies(pvIdx))
358 return ExtboModule::primaryVarName(pvIdx);
359 else if (PolymerModule::primaryVarApplies(pvIdx))
360 return PolymerModule::primaryVarName(pvIdx);
361 else if (EnergyModule::primaryVarApplies(pvIdx))
362 return EnergyModule::primaryVarName(pvIdx);
363 else
364 assert(false);
365
366 return oss.str();
367 }
368
372 std::string eqName(int eqIdx) const
373 {
374 std::ostringstream oss;
375
376 if (Indices::conti0EqIdx <= eqIdx && eqIdx < Indices::conti0EqIdx + numComponents)
377 oss << "conti_" << FluidSystem::phaseName(eqIdx - Indices::conti0EqIdx);
378 else if (SolventModule::eqApplies(eqIdx))
379 return SolventModule::eqName(eqIdx);
380 else if (ExtboModule::eqApplies(eqIdx))
381 return ExtboModule::eqName(eqIdx);
382 else if (PolymerModule::eqApplies(eqIdx))
383 return PolymerModule::eqName(eqIdx);
384 else if (EnergyModule::eqApplies(eqIdx))
385 return EnergyModule::eqName(eqIdx);
386 else
387 assert(false);
388
389 return oss.str();
390 }
391
395 Scalar primaryVarWeight(unsigned globalDofIdx, unsigned pvIdx) const
396 {
397 // do not care about the auxiliary equations as they are supposed to scale
398 // themselves
399 if (globalDofIdx >= this->numGridDof())
400 return 1.0;
401
402 // saturations are always in the range [0, 1]!
403 if (int(Indices::waterSwitchIdx) == int(pvIdx))
404 return 1.0;
405
406 // oil pressures usually are in the range of 100 to 500 bars for typical oil
407 // reservoirs (which is the only relevant application for the black-oil model).
408 else if (int(Indices::pressureSwitchIdx) == int(pvIdx))
409 return 1.0/300e5;
410
411 // deal with primary variables stemming from the solvent module
412 else if (SolventModule::primaryVarApplies(pvIdx))
413 return SolventModule::primaryVarWeight(pvIdx);
414
415 // deal with primary variables stemming from the extBO module
416 else if (ExtboModule::primaryVarApplies(pvIdx))
417 return ExtboModule::primaryVarWeight(pvIdx);
418
419 // deal with primary variables stemming from the polymer module
420 else if (PolymerModule::primaryVarApplies(pvIdx))
421 return PolymerModule::primaryVarWeight(pvIdx);
422
423 // deal with primary variables stemming from the energy module
424 else if (EnergyModule::primaryVarApplies(pvIdx))
425 return EnergyModule::primaryVarWeight(pvIdx);
426
427 // if the primary variable is either the gas saturation, Rs or Rv
428 assert(int(Indices::compositionSwitchIdx) == int(pvIdx));
429
430 auto pvMeaning = this->solution(0)[globalDofIdx].primaryVarsMeaningGas();
431 if (pvMeaning == PrimaryVariables::GasMeaning::Sg)
432 return 1.0; // gas saturation
433 else if (pvMeaning == PrimaryVariables::GasMeaning::Rs)
434 return 1.0/250.; // gas dissolution factor
435 else {
436 assert(pvMeaning == PrimaryVariables::GasMeaning::Rv);
437 return 1.0/0.025; // oil vaporization factor
438 }
439
440 }
441
445 Scalar eqWeight(unsigned globalDofIdx, unsigned eqIdx) const
446 {
447 // do not care about the auxiliary equations as they are supposed to scale
448 // themselves
449 if (globalDofIdx >= this->numGridDof())
450 return 1.0;
451
452 return eqWeights_[eqIdx];
453 }
454
455 void setEqWeight(unsigned eqIdx, Scalar value) {
456 eqWeights_[eqIdx] = value;
457 }
458
467 template <class DofEntity>
468 void serializeEntity(std::ostream& outstream, const DofEntity& dof)
469 {
470 unsigned dofIdx = static_cast<unsigned>(asImp_().dofMapper().index(dof));
471
472 // write phase state
473 if (!outstream.good())
474 throw std::runtime_error("Could not serialize degree of freedom "+std::to_string(dofIdx));
475
476 // write the primary variables
477 const auto& priVars = this->solution(/*timeIdx=*/0)[dofIdx];
478 for (unsigned eqIdx = 0; eqIdx < numEq; ++eqIdx)
479 outstream << priVars[eqIdx] << " ";
480
481 // write the pseudo primary variables
482 outstream << static_cast<int>(priVars.primaryVarsMeaningGas()) << " ";
483 outstream << static_cast<int>(priVars.primaryVarsMeaningWater()) << " ";
484 outstream << static_cast<int>(priVars.primaryVarsMeaningPressure()) << " ";
485
486 outstream << priVars.pvtRegionIndex() << " ";
487
488 SolventModule::serializeEntity(asImp_(), outstream, dof);
489 ExtboModule::serializeEntity(asImp_(), outstream, dof);
490 PolymerModule::serializeEntity(asImp_(), outstream, dof);
491 EnergyModule::serializeEntity(asImp_(), outstream, dof);
492 }
493
502 template <class DofEntity>
503 void deserializeEntity(std::istream& instream,
504 const DofEntity& dof)
505 {
506 unsigned dofIdx = static_cast<unsigned>(asImp_().dofMapper().index(dof));
507
508 // read in the "real" primary variables of the DOF
509 auto& priVars = this->solution(/*timeIdx=*/0)[dofIdx];
510 for (unsigned eqIdx = 0; eqIdx < numEq; ++eqIdx) {
511 if (!instream.good())
512 throw std::runtime_error("Could not deserialize degree of freedom "+std::to_string(dofIdx));
513 instream >> priVars[eqIdx];
514 }
515
516 // read the pseudo primary variables
517 unsigned primaryVarsMeaningGas;
518 instream >> primaryVarsMeaningGas;
519
520 unsigned primaryVarsMeaningWater;
521 instream >> primaryVarsMeaningWater;
522
523 unsigned primaryVarsMeaningPressure;
524 instream >> primaryVarsMeaningPressure;
525
526 unsigned pvtRegionIdx;
527 instream >> pvtRegionIdx;
528
529 if (!instream.good())
530 throw std::runtime_error("Could not deserialize degree of freedom "+std::to_string(dofIdx));
531
532 SolventModule::deserializeEntity(asImp_(), instream, dof);
533 ExtboModule::deserializeEntity(asImp_(), instream, dof);
534 PolymerModule::deserializeEntity(asImp_(), instream, dof);
535 EnergyModule::deserializeEntity(asImp_(), instream, dof);
536
537 using PVM_G = typename PrimaryVariables::GasMeaning;
538 using PVM_W = typename PrimaryVariables::WaterMeaning;
539 using PVM_P = typename PrimaryVariables::PressureMeaning;
540 priVars.setPrimaryVarsMeaningGas(static_cast<PVM_G>(primaryVarsMeaningGas));
541 priVars.setPrimaryVarsMeaningWater(static_cast<PVM_W>(primaryVarsMeaningWater));
542 priVars.setPrimaryVarsMeaningPressure(static_cast<PVM_P>(primaryVarsMeaningPressure));
543
544 priVars.setPvtRegionIndex(pvtRegionIdx);
545 }
546
554 template <class Restarter>
556 {
557 ParentType::deserialize(res);
558
559 // set the PVT indices of the primary variables. This is also done by writing
560 // them into the restart file and re-reading them, but it is better to calculate
561 // them from scratch because the input could have been changed in this regard...
562 ElementContext elemCtx(this->simulator_);
563 for (const auto& elem : elements(this->gridView())) {
564 elemCtx.updateStencil(elem);
565 for (unsigned dofIdx = 0; dofIdx < elemCtx.numPrimaryDof(/*timIdx=*/0); ++dofIdx) {
566 unsigned globalDofIdx = elemCtx.globalSpaceIndex(dofIdx, /*timIdx=*/0);
567 updatePvtRegionIndex_(this->solution(/*timeIdx=*/0)[globalDofIdx],
568 elemCtx,
569 dofIdx,
570 /*timeIdx=*/0);
571 }
572 }
573
574 this->solution(/*timeIdx=*/1) = this->solution(/*timeIdx=*/0);
575 }
576
577/*
578 // hack: this interferes with the static polymorphism trick
579protected:
580 friend ParentType;
581 friend Discretization;
582*/
583
584 template <class Context>
585 void supplementInitialSolution_(PrimaryVariables& priVars,
586 const Context& context,
587 unsigned dofIdx,
588 unsigned timeIdx)
589 { updatePvtRegionIndex_(priVars, context, dofIdx, timeIdx); }
590
591 void registerOutputModules_()
592 {
593 ParentType::registerOutputModules_();
594
595 // add the VTK output modules which make sense for the blackoil model
596 SolventModule::registerOutputModules(asImp_(), this->simulator_);
597 PolymerModule::registerOutputModules(asImp_(), this->simulator_);
598 EnergyModule::registerOutputModules(asImp_(), this->simulator_);
599 MICPModule::registerOutputModules(asImp_(), this->simulator_);
600
601 this->addOutputModule(new VtkBlackOilModule<TypeTag>(this->simulator_));
602 this->addOutputModule(new VtkCompositionModule<TypeTag>(this->simulator_));
603
604 if constexpr (enableDiffusion)
605 this->addOutputModule(new VtkDiffusionModule<TypeTag>(this->simulator_));
606 }
607
608private:
609 std::vector<Scalar> eqWeights_;
610 Implementation& asImp_()
611 { return *static_cast<Implementation*>(this); }
612 const Implementation& asImp_() const
613 { return *static_cast<const Implementation*>(this); }
614
615 template <class Context>
616 void updatePvtRegionIndex_(PrimaryVariables& priVars,
617 const Context& context,
618 unsigned dofIdx,
619 unsigned timeIdx)
620 {
621 unsigned regionIdx = context.problem().pvtRegionIndex(context, dofIdx, timeIdx);
622 priVars.setPvtRegionIndex(regionIdx);
623 }
624};
625
626} // namespace Opm
627
628#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:48
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:80
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:105
static void registerOutputModules(Model &model, Simulator &simulator)
Register all MICP specific VTK and ECL output modules.
Definition blackoilmicpmodules.hh:117
A fully-implicit black-oil flow model.
Definition blackoilmodel.hh:275
std::string primaryVarName(int pvIdx) const
Given an primary variable index, return a human readable name.
Definition blackoilmodel.hh:345
Scalar primaryVarWeight(unsigned globalDofIdx, unsigned pvIdx) const
Returns the relative weight of a primary variable for calculating relative errors.
Definition blackoilmodel.hh:395
Scalar eqWeight(unsigned globalDofIdx, unsigned eqIdx) const
Returns the relative weight of an equation.
Definition blackoilmodel.hh:445
void serializeEntity(std::ostream &outstream, const DofEntity &dof)
Write the current solution for a degree of freedom to a restart file.
Definition blackoilmodel.hh:468
std::string eqName(int eqIdx) const
Given an equation index, return a human readable name.
Definition blackoilmodel.hh:372
static std::string name()
Definition blackoilmodel.hh:339
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:503
static void registerParameters()
Register all run-time parameters for the immiscible model.
Definition blackoilmodel.hh:319
void deserialize(Restarter &res)
Deserializes the state of the model.
Definition blackoilmodel.hh:555
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
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.