3.1-git
DUNE for Multi-{Phase, Component, Scale, Physics, ...} flow and transport in porous media
Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
Dumux::FV2dPressure2P2CAdaptive< TypeTag > Class Template Reference

The finite volume model for the solution of the compositional pressure equation. More...

#include <dumux/porousmediumflow/2p2c/sequential/fv2dpressureadaptive.hh>

Inheritance diagram for Dumux::FV2dPressure2P2CAdaptive< TypeTag >:
Inheritance graph

Description

template<class TypeTag>
class Dumux::FV2dPressure2P2CAdaptive< TypeTag >

The finite volume model for the solution of the compositional pressure equation.

Provides a Finite Volume implementation for the pressure equation of a compressible system with two components. An IMPES-like method is used for the sequential solution of the problem. Diffusion is neglected, capillarity can be regarded. Isothermal conditions and local thermodynamic equilibrium are assumed. Gravity is included.

\[ c_{total}\frac{\partial p}{\partial t} + \sum_{\kappa} \frac{\partial v_{total}}{\partial C^{\kappa}} \nabla \cdot \left( \sum_{\alpha} X^{\kappa}_{\alpha} \varrho_{\alpha} \bf{v}_{\alpha}\right) = \sum_{\kappa} \frac{\partial v_{total}}{\partial C^{\kappa}} q^{\kappa}, \]

where \(\bf{v}_{\alpha} = - \lambda_{\alpha} \bf{K} \left(\nabla p_{\alpha} + \rho_{\alpha} \bf{g} \right) \). \( c_{total} \) represents the total compressibility, for constant porosity this yields \( - \frac{\partial V_{total}}{\partial p_{\alpha}} \), \(p_{\alpha} \) denotes the phase pressure, \( \bf{K} \) the absolute permeability, \( \lambda_{\alpha} \) the phase mobility, \( \rho_{\alpha} \) the phase density and \( \bf{g} \) the gravity constant and \( C^{\kappa} \) the total Component concentration. See paper SPE 99619 or "Analysis of a Compositional Model for Fluid Flow in Porous Media" by Chen, Qin and Ewing for derivation. The partial derivatives of the actual fluid volume \( v_{total} \) are gained by using a secant method.

This adaptive implementation uses its own initialization and assembling methods for matrix and right-hand-side vector, but solution is done by the base class FVPressure. Fluxes near hanging nodes can be calculated using an mpfa method.

Template Parameters
TypeTagThe Type Tag

Public Member Functions

void initializeMatrix ()
 initializes the matrix to store the system of equations More...
 
void assemble (bool first)
 function which assembles the system of equations to be solved More...
 
void getMpfaFlux (const IntersectionIterator &, const CellData &)
 Compute flux over an irregular interface using a mpfa method. More...
 
int computeTransmissibilities (const IntersectionIterator &, IntersectionIterator &, TransmissivityMatrix &, TransmissivityMatrix &, GlobalPosition &, int &)
 Computes the transmissibility coefficients for the MPFA-l method. More...
 
void adaptPressure ()
 Adapt primary variables vector after adapting the grid. More...
 
 FV2dPressure2P2CAdaptive (Problem &problem)
 Constructs a FV2dPressure2P2CAdaptive object. More...
 
void getSource (EntryType &sourceEntry, const Element &elementI, const CellData &cellDataI, const bool first)
 Assembles the source term. More...
 
void getStorage (EntryType &storageEntry, const Element &elementI, const CellData &cellDataI, const bool first)
 Assembles the storage term. More...
 
void getFlux (EntryType &entries, const Intersection &intersection, const CellData &cellDataI, const bool first)
 Get flux at an interface between two cells. More...
 
void getFluxOnBoundary (EntryType &entries, const Intersection &intersection, const CellData &cellDataI, const bool first)
 Get flux on Boundary. More...
 
void updateMaterialLawsInElement (const Element &elementI, bool postTimeStep)
 Updates secondary variables of one cell. More...
 
void initialMaterialLaws (bool compositional)
 initializes the fluid distribution and hereby the variables container More...
 
void initialize (bool solveTwice=false)
 Initializes the simulation run. More...
 
void initialize ()
 Initialize pressure model. More...
 
void update ()
 Compositional pressure solution routine: update estimate for secants, assemble, solve. More...
 
void updateMaterialLaws (bool postTimeStep=false)
 Updates secondary variables. More...
 
void volumeDerivatives (const GlobalPosition &, const Element &ep)
 Partial derivatives of the volumes w.r.t. changes in total concentration and pressure. More...
 
const Scalar pressure (const int eIdxGlobal) const
 Public access function for the primary pressure variable. More...
 
const Matrix & globalMatrix ()
 Returns the global matrix of the last pressure solution step. More...
 
const RHSVector & rightHandSide ()
 Returns the right hand side vector of the last pressure solution step. More...
 
void calculateVelocity ()
 
void updateVelocity ()
 
void serializeEntity (std::ostream &outstream, const Element &element)
 Function for serialization of the pressure field. More...
 
void deserializeEntity (std::istream &instream, const Element &element)
 Function for deserialization of the pressure field. More...
 
void setFixPressureAtIndex (Scalar pressure, int eIdxGlobal)
 Set a pressure to be fixed at a certain cell. More...
 
void unsetFixPressureAtIndex (int eIdxGlobal)
 Reset the fixed pressure state. More...
 
void resetFixPressureAtIndex ()
 

Protected Types

using EntryType = Dune::FieldVector< Scalar, 2 >
 
enum  { rhs = 1 , matrix = 0 }
 Indices of matrix and rhs entries. More...
 
enum  { pressEqIdx = Indices::pressureEqIdx }
 

Protected Member Functions

Problem & problem ()
 
const Problem & problem () const
 
int transmissibilityAdapter_ (const IntersectionIterator &, const IntersectionIterator &, IntersectionIterator &, GlobalPosition &, TransmissivityMatrix &)
 An adapter to use the traditional 2p implementation for the second interaction region. More...
 
void initializeMatrixRowSize ()
 Initialize the global matrix of the system of equations to solve. More...
 
void initializeMatrixIndices ()
 Initialize the global matrix of the system of equations to solve. More...
 
void solve ()
 Solves the global system of equations to get the spatial distribution of the pressure. More...
 
PressureSolution & pressure ()
 Returns the vector containing the pressure solution. More...
 
const PressureSolution & pressure () const
 Returns the vector containing the pressure solution. More...
 
void initializePressure ()
 Initialization of the pressure solution vector: Initialization with meaningful values may. More...
 

Protected Attributes

DimMatrix R_
 Matrix for vector rotation used in mpfa. More...
 
bool enableVolumeIntegral
 Enables the volume integral of the pressure equation. More...
 
bool enableMPFA
 Enables mpfa method to calculate the fluxes near hanging nodes. More...
 
bool enableSecondHalfEdge
 
TransmissibilityCalculator transmissibilityCalculator_
 The 2p Mpfa pressure module, that is only used for the calulation of transmissibility of the second interaction volumes. More...
 
bool regulateBoundaryPermeability
 Enables regulation of permeability in the direction of a Dirichlet Boundary Condition. More...
 
Scalar minimalBoundaryPermeability
 Minimal limit for the boundary permeability. More...
 
Scalar ErrorTermFactor_
 Handling of error term: relaxation factor. More...
 
Scalar ErrorTermLowerBound_
 Handling of error term: lower bound for error dampening. More...
 
Scalar ErrorTermUpperBound_
 
Matrix A_
 Global stiffnes matrix (sparse matrix which is build by the initializeMatrix() function) More...
 
RHSVector f_
 Right hand side vector. More...
 

Static Protected Attributes

static constexpr int pressureType = GET_PROP_VALUE(TypeTag, PressureFormulation)
 gives kind of pressure used ( \( 0 = p_w \), \( 1 = p_n \), \( 2 = p_{global} \)) More...
 

general methods for output

TransportSolutionType updateEstimate_
 Update estimate for changes in volume for the pressure equation. More...
 
VtkMultiWriter< GridView > initializationOutputWriter_
 output for the initialization procedure More...
 
Scalar maxError_
 Maximum volume error of all cells. More...
 
Scalar incp_
 Increment for the volume derivative w.r.t pressure. More...
 
template<class MultiWriter >
void addOutputVtkFields (MultiWriter &writer)
 Write data files. More...
 
void initializationOutput (double pseudoTS=0.)
 Write additional debug info in a special writer. More...
 

Member Typedef Documentation

◆ EntryType

template<class TypeTag >
using Dumux::FVPressure2P2C< TypeTag >::EntryType = Dune::FieldVector<Scalar, 2>
protectedinherited

Type of the vector of entries

Contains the return values of the get*()-functions (matrix or right-hand side entry).

Member Enumeration Documentation

◆ anonymous enum

template<class TypeTag >
anonymous enum
protectedinherited

Indices of matrix and rhs entries.

During the assembling of the global system of equations get-functions are called (getSource(), getFlux(), etc.), which return global matrix or right hand side entries in a vector. These can be accessed using following indices:

Enumerator
rhs 

index for the right hand side entry

matrix 

index for the global matrix entry

◆ anonymous enum

template<class TypeTag >
anonymous enum
protectedinherited
Enumerator
pressEqIdx 

Constructor & Destructor Documentation

◆ FV2dPressure2P2CAdaptive()

template<class TypeTag >
Dumux::FV2dPressure2P2CAdaptive< TypeTag >::FV2dPressure2P2CAdaptive ( Problem &  problem)
inline

Constructs a FV2dPressure2P2CAdaptive object.

Parameters
problema problem class object

Member Function Documentation

◆ adaptPressure()

template<class TypeTag >
void Dumux::FV2dPressure2P2CAdaptive< TypeTag >::adaptPressure ( )
inline

Adapt primary variables vector after adapting the grid.

◆ addOutputVtkFields()

template<class TypeTag >
template<class MultiWriter >
void Dumux::FVPressureCompositional< TypeTag >::addOutputVtkFields ( MultiWriter &  writer)
inlineinherited

Write data files.

Adds pressure-related quantities, including numerical things such as the volume Error entering the pressure equation. Verobosity of the output can be triggered by the property / parameter VtkOutputLevel, with 0 putting out only primary variables and 4 being very verbose.

Template Parameters
MultiWriterClass defining the output writer
Parameters
writerThe output writer (usually a VTKMultiWriter object)

◆ assemble()

template<class TypeTag >
void Dumux::FV2dPressure2P2CAdaptive< TypeTag >::assemble ( bool  first)

function which assembles the system of equations to be solved

This function assembles the Matrix and the RHS vectors to solve for a pressure field with an Finite-Volume Discretization in an implicit fashion. Compared to the method in FVPressure, this implementation calculates fluxes near hanging nodes with the mpfa method using the method getMpfaFlux(). Matrix and Right-hand-side entries are done therein.

Parameters
firstFlag if pressure field is unknown

◆ calculateVelocity()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::calculateVelocity ( )
inlineinherited

◆ computeTransmissibilities()

template<class TypeTag >
int Dumux::FV2dPressure2P2CAdaptive< TypeTag >::computeTransmissibilities ( const IntersectionIterator &  isIt,
IntersectionIterator &  additionalIntersectionIt,
TransmissivityMatrix &  T,
TransmissivityMatrix &  additionalT,
GlobalPosition &  globalPos3,
int &  globalIdx3 
)

Computes the transmissibility coefficients for the MPFA-l method.

Indices used in a interaction volume of the MPFA-l method

               ___________________________________________________
               | nux: cell geometry     | nx: face normal        |
               |                        | =integrationOuterNormal|
               |                        |                        |
               |  nextIt________________|                        |
               |                        |    nu4    3            |
               |                        |      \;.´ |            |
               |                        |     .´ <--|nu3         |
               |   elementnumber        |  .´ ^n1   |            |
               |            1...........x_____|_____|____________|
               |             `.    |nu5 !`.   _nu7  |            |
               |                `.`'´   !   `./` <--|            |
       lastIt  |                  `._   !     `. nu2|            |
            \  |                 nu6/`. !nu1^   ` . |            |
             \ |                       `!---|------`2            |
              `|                        |                        |
               |\ isIt__________________|->n12                   |
               | \                      |                        |
               |_face14_________________|________________________|


     _
     /` is a normal directing upwards to the right,
     while a normal directing downwards to the right looks like \;
Parameters
isItIterator to the current intersection
additionalIntersectionItIterator to the additional interface included in the second interaction region
TTransmissitivity matrix of the first unique interaction region
additionalTTransmissitivity matrix of the second non-unique interaction region
globalPos3Unique interaction region: Position of the 3rd cell, the other neighbor on the hanging node
globalIdx3Unique interaction region: Index of the 3rd cell, the other neighbor on the hanging node

1) get geometrical information of interaction triangle

2) search for face13, face23

3) Calculate omega, chi for matrices

4) Calculate A, B, C, D and solve for T

◆ deserializeEntity()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::deserializeEntity ( std::istream &  instream,
const Element &  element 
)
inlineinherited

Function for deserialization of the pressure field.

Function needed for restart option. Reads the pressure of a grid element from a restart file.

Parameters
instreamStream from the restart file.
elementGrid element

◆ getFlux()

template<class TypeTag >
void Dumux::FVPressure2P2C< TypeTag >::getFlux ( EntryType entries,
const Intersection &  intersection,
const CellData &  cellDataI,
const bool  first 
)
inherited

Get flux at an interface between two cells.

for first == true, the flux is calculated in traditional fractional-flow forn as in FVPressure2P. for first == false, the flux thorugh \( \gamma \) is calculated via a volume balance formulation

\[ - A_{\gamma} \mathbf{n}^T_{\gamma} \mathbf{K} \sum_{\alpha} \varrho_{\alpha} \lambda_{\alpha} \mathbf{d}_{ij} \left( \frac{p_{\alpha,j}^t - p^{t}_{\alpha,i}}{\Delta x} + \varrho_{\alpha} \mathbf{g}^T \mathbf{d}_{ij} \right) \sum_{\kappa} X^{\kappa}_{\alpha} \frac{\partial v_{t}}{\partial C^{\kappa}} + V_i \frac{A_{\gamma}}{U_i} \mathbf{d}^T \mathbf{K} \sum_{\alpha} \varrho_{\alpha} \lambda_{\alpha} \mathbf{d}_{ij} \left( \frac{p_{\alpha,j}^t - p^{t}_{\alpha,i}}{\Delta x} + \varrho_{\alpha} \mathbf{g}^T \mathbf{d}_{ij} \right) \sum_{\kappa} X^{\kappa}_{\alpha} \frac{\frac{\partial v_{t,j}}{\partial C^{\kappa}_j}-\frac{\partial v_{t,i}}{\partial C^{\kappa}_i}}{\Delta x} \]

This includes a boundary integral and a volume integral, because \( \frac{\partial v_{t,i}}{\partial C^{\kappa}_i} \) is not constant. Here, \( \mathbf{d}_{ij} \) is the normalized vector connecting the cell centers, and \( \mathbf{n}_{\gamma} \) represents the normal of the face \( \gamma \).

Parameters
entriesThe Matrix and RHS entries
intersectionIntersection between cell I and J
cellDataIData of cell I
firstFlag if pressure field is unknown

◆ getFluxOnBoundary()

template<class TypeTag >
void Dumux::FVPressure2P2C< TypeTag >::getFluxOnBoundary ( EntryType entries,
const Intersection &  intersection,
const CellData &  cellDataI,
const bool  first 
)
inherited

Get flux on Boundary.

for first == true, the flux is calculated in traditional fractional-flow forn as in FVPressure2P. for first == false, the flux thorugh \( \gamma \) is calculated via a volume balance formulation

\[ - A_{\gamma} \mathbf{n}^T_{\gamma} \mathbf{K} \sum_{\alpha} \varrho_{\alpha} \lambda_{\alpha} \mathbf{d}_{ij} \left( \frac{p_{\alpha,j}^t - p^{t}_{\alpha,i}}{\Delta x} + \varrho_{\alpha} \mathbf{g}^T \mathbf{d}_{ij} \right) \sum_{\kappa} \frac{\partial v_{t}}{\partial C^{\kappa}} X^{\kappa}_{\alpha} \;, \]

where we skip the volume integral assuming \( \frac{\partial v_{t,i}}{\partial C^{\kappa}_i} \) to be constant at the boundary. Here, \( \mathbf{d}_{ij} \) is the normalized vector connecting the cell centers, and \( \mathbf{n}_{\gamma} \) represents the normal of the face \( \gamma \).

If a Neumann BC is set, the given (mass-)flux is directly multiplied by the volume derivative and inserted.

Parameters
entriesThe Matrix and RHS entries
intersectionIntersection between cell I and J
cellDataIData of cell I
firstFlag if pressure field is unknown

◆ getMpfaFlux()

template<class TypeTag >
void Dumux::FV2dPressure2P2CAdaptive< TypeTag >::getMpfaFlux ( const IntersectionIterator &  intersectionIterator,
const CellData &  cellDataI 
)

Compute flux over an irregular interface using a mpfa method.

A mpfa l-method is applied to calculate fluxes near hanging nodes, using:

\[ - \sum_{\alpha} \varrho_{\alpha} \lambda_{\alpha} \left( \sum_k \tau_{2k} p^t_{\alpha,k} + \varrho_{\alpha} \sum_k \tau_{2k} \mathbf{g}^T \mathbf{x}_{k} \right) \sum_{\kappa} X^{\kappa}_{\alpha} \frac{\partial v_{t}}{\partial C^{\kappa}} + \frac{ V_i}{U_i} \sum_{\alpha} \varrho_{\alpha} \lambda_{\alpha} \left( \sum_k \tau_{2k} p^t_{\alpha,k} + \varrho_{\alpha} \sum_k \tau_{2k} \mathbf{g}^T \mathbf{x}_{k} \right) \sum_{\kappa} X^{\kappa}_{\alpha} \frac{\frac{\partial v_{t,j}}{\partial C^{\kappa}_j} -\frac{\partial v_{t,i}}{\partial C^{\kappa}_i}}{\Delta x} \]

We provide two options: Calculating the flux expressed by twice the flux through the one unique interaction region on the hanging node if one halfedge is stored (eg on boundaries). Or using the second interaction region covering neighboring cells. The contribution in other cells than I or J make it necessary that the matrix and rhs entries are filled up within this function.

Parameters
intersectionIteratorIterator of the intersection between cell I and J
cellDataIData of cell I

get geometrical Info, transmissibility matrix

compute matrix entry: advective fluxes

◆ getSource()

template<class TypeTag >
void Dumux::FVPressure2P2C< TypeTag >::getSource ( EntryType sourceEntry,
const Element &  elementI,
const CellData &  cellDataI,
const bool  first 
)
inherited

Assembles the source term.

for first == true, a source is implemented as in FVPressure2P. for first == false, the source is translated into a volumentric source term:

\[ V_i \sum_{\kappa} \frac{\partial v_{t}}{\partial C^{\kappa}} q^{\kappa}_i \]

.

Parameters
sourceEntryThe Matrix and RHS entries
elementIThe element I
cellDataIData of cell I
firstFlag if pressure field is unknown

◆ getStorage()

template<class TypeTag >
void Dumux::FVPressure2P2C< TypeTag >::getStorage ( EntryType storageEntry,
const Element &  elementI,
const CellData &  cellDataI,
const bool  first 
)
inherited

Assembles the storage term.

for first == true, there is no storage contribution. for first == false, the storage term comprises the compressibility (due to a change in pressure from last timestep):

\[ V_i c_{t,i} \frac{p^t_i - p^{t-\Delta t}_i}{\Delta t} \]

and the damped error introduced by the incorrect transport of the last timestep:

\[ V_i \alpha_r \frac{v_{t} - \phi}{\Delta t} \]

. The latter is damped according to Fritz 2011.

Parameters
storageEntryThe Matrix and RHS entries
elementIThe element I
cellDataIData of cell I
firstFlag if pressure field is unknown

◆ globalMatrix()

template<class TypeTag >
const Matrix & Dumux::FVPressure< TypeTag >::globalMatrix ( )
inlineinherited

Returns the global matrix of the last pressure solution step.

◆ initializationOutput()

template<class TypeTag >
void Dumux::FVPressureCompositional< TypeTag >::initializationOutput ( double  pseudoTS = 0.)
inlineinherited

Write additional debug info in a special writer.

To visualize the different steps through the initialization procedure, we use very small pseudo time steps only for the writer! This is only for debugging of the initialization procedure.

Parameters
pseudoTSTime steps that only appear in the writer, not real.

◆ initialize() [1/2]

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::initialize ( )
inlineinherited

Initialize pressure model.

Function initializes the sparse matrix to solve the global system of equations and sets/calculates the initial pressure

◆ initialize() [2/2]

template<class TypeTag >
void Dumux::FVPressureCompositional< TypeTag >::initialize ( bool  solveTwice = false)
inherited

Initializes the simulation run.

Initializes the simulation to gain the initial pressure field. Output throughout initialization procedure is only done in debug mode.

Parameters
solveTwiceflag to determine possible iterations of the initialization process

◆ initializeMatrix()

template<class TypeTag >
void Dumux::FV2dPressure2P2CAdaptive< TypeTag >::initializeMatrix

initializes the matrix to store the system of equations

In comparison with the Tpfa method, an mpfa uses a larger flux stencil, hence more matrix entries are required if not only the unique interaction region on the hanging nodes are considered. The method checks weather the additonally regarded cells through mpfa are already "normal" neighbors for fluxes through other interfaces, or if they need to be added.

◆ initializeMatrixIndices()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::initializeMatrixIndices
protectedinherited

Initialize the global matrix of the system of equations to solve.

◆ initializeMatrixRowSize()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::initializeMatrixRowSize
protectedinherited

Initialize the global matrix of the system of equations to solve.

◆ initializePressure()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::initializePressure ( )
inlineprotectedinherited

Initialization of the pressure solution vector: Initialization with meaningful values may.

◆ initialMaterialLaws()

template<class TypeTag >
void Dumux::FVPressureCompositional< TypeTag >::initialMaterialLaws ( bool  compositional)
inherited

initializes the fluid distribution and hereby the variables container

It differs from updateMaterialLaws() because there are two possible initial conditions: saturations and concentration.

Parameters
compositionalflag that determines if compositional effects are regarded, i.e. a reasonable pressure field is known with which compositions can be calculated.

◆ pressure() [1/3]

template<class TypeTag >
PressureSolution & Dumux::FVPressure< TypeTag >::pressure ( )
inlineprotectedinherited

Returns the vector containing the pressure solution.

◆ pressure() [2/3]

template<class TypeTag >
const PressureSolution & Dumux::FVPressure< TypeTag >::pressure ( ) const
inlineprotectedinherited

Returns the vector containing the pressure solution.

◆ pressure() [3/3]

template<class TypeTag >
const Scalar Dumux::FVPressure< TypeTag >::pressure ( const int  eIdxGlobal) const
inlineinherited

Public access function for the primary pressure variable.

Function returns the cell pressure value at index eIdxGlobal

Parameters
eIdxGlobalGlobal index of a grid cell

◆ problem() [1/2]

template<class TypeTag >
Problem & Dumux::FV2dPressure2P2CAdaptive< TypeTag >::problem ( )
inlineprotected

◆ problem() [2/2]

template<class TypeTag >
const Problem & Dumux::FV2dPressure2P2CAdaptive< TypeTag >::problem ( ) const
inlineprotected

◆ resetFixPressureAtIndex()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::resetFixPressureAtIndex ( )
inlineinherited

◆ rightHandSide()

template<class TypeTag >
const RHSVector & Dumux::FVPressure< TypeTag >::rightHandSide ( )
inlineinherited

Returns the right hand side vector of the last pressure solution step.

◆ serializeEntity()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::serializeEntity ( std::ostream &  outstream,
const Element &  element 
)
inlineinherited

Function for serialization of the pressure field.

Function needed for restart option. Writes the pressure of a grid element to a restart file.

Parameters
outstreamStream into the restart file.
elementGrid element

◆ setFixPressureAtIndex()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::setFixPressureAtIndex ( Scalar  pressure,
int  eIdxGlobal 
)
inlineinherited

Set a pressure to be fixed at a certain cell.

Allows to fix a pressure somewhere (at one certain cell) in the domain. This can be necessary e.g. if only Neumann boundary conditions are defined. The pressure is fixed until the unsetFixPressureAtIndex() function is called

Parameters
pressurePressure value at eIdxGlobal
eIdxGlobalGlobal index of a grid cell

◆ solve()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::solve
protectedinherited

Solves the global system of equations to get the spatial distribution of the pressure.

◆ transmissibilityAdapter_()

template<class TypeTag >
int Dumux::FV2dPressure2P2CAdaptive< TypeTag >::transmissibilityAdapter_ ( const IntersectionIterator &  isIt,
const IntersectionIterator &  face23_2p2cnaming,
IntersectionIterator &  additionalIntersectionIt,
GlobalPosition &  corner1234,
TransmissivityMatrix &  additionalT 
)
protected

An adapter to use the traditional 2p implementation for the second interaction region.

The second interaction region consists of 4 cells, hence the traditional non-adaptive implementation to calculate the transmissibility coefficients is used. This, however, uses its own naming conventions and local Indices used in the work of I. Aavatsmark.

Indices used in a interaction volume of the MPFA-l method

               |                        |                        |
               |            4-----------3-----------3            |
               |            | --> nu43  |  nu34 <-- |            |
               |            | |nu41    1|--> n43   ||nu32        |
               |            | v   ^     |0     ^   v|            |
               |____________4__0__|n14__|__n23_|_1__2____________|
               |            |    1    0 |     0     |            |
               |            | ^         |1   nu23 ^ |            |
               |            | |nu14    0|--> n12  | |            |
               |            | -->nu12   |   nu21<-- |            |
               |        J = 1-----------1-----------2 = I        |
               |                        |                        |

.

Parameters
isItIterator to the current intersection
face23_2p2cnamingIterator to the second interface included in the unique interaction region = face23
additionalIntersectionItIterator to the intersection included in the second interaction region
corner1234Center point of non-unique interaction region.
additionalTTransmissibility Matrix of non unique interaction region.

◆ unsetFixPressureAtIndex()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::unsetFixPressureAtIndex ( int  eIdxGlobal)
inlineinherited

Reset the fixed pressure state.

No pressure is fixed inside the domain until setFixPressureAtIndex() function is called again.

Parameters
eIdxGlobalGlobal index of a grid cell

◆ update()

template<class TypeTag >
void Dumux::FVPressureCompositional< TypeTag >::update ( )
inlineinherited

Compositional pressure solution routine: update estimate for secants, assemble, solve.

An update estime (transport step acoording to old pressure field) determines changes in mass, composition, which is used to calculate volume derivatives entering the pressure equation, as well as an approximate guess for time step size for the storage terms in the p.e. Afterwards, the system is assembled and solved for pressure.

◆ updateMaterialLaws()

template<class TypeTag >
void Dumux::FVPressureCompositional< TypeTag >::updateMaterialLaws ( bool  postTimeStep = false)
inherited

Updates secondary variables.

A loop through all elements updates the secondary variables stored in the variableclass by using the updated primary variables.

Parameters
postTimeStepFlag indicating method is called from Problem::postTimeStep()

◆ updateMaterialLawsInElement()

template<class TypeTag >
void Dumux::FVPressure2P2C< TypeTag >::updateMaterialLawsInElement ( const Element &  element,
bool  postTimeStep 
)
inherited

Updates secondary variables of one cell.

For each element, the secondary variables are updated according to the primary variables. In case the method is called after the Transport, i.e. at the end / post time step, CellData2p2c.reset() resets the volume derivatives for the next time step.

Parameters
elementThe element
postTimeStepFlag indicating if we have just completed a time step

◆ updateVelocity()

template<class TypeTag >
void Dumux::FVPressure< TypeTag >::updateVelocity ( )
inlineinherited

◆ volumeDerivatives()

template<class TypeTag >
void Dumux::FVPressureCompositional< TypeTag >::volumeDerivatives ( const GlobalPosition &  globalPos,
const Element &  element 
)
inherited

Partial derivatives of the volumes w.r.t. changes in total concentration and pressure.

This method calculates the volume derivatives via a secant method, where the secants are gained in a pre-computational step via the transport equation and the last TS size. The partial derivatives w.r.t. mass are defined as \( \frac{\partial v}{\partial C^{\kappa}} = \frac{\partial V}{\partial m^{\kappa}}\)

Parameters
globalPosThe global position of the current element
elementThe current element

Member Data Documentation

◆ A_

template<class TypeTag >
Matrix Dumux::FVPressure< TypeTag >::A_
protectedinherited

Global stiffnes matrix (sparse matrix which is build by the initializeMatrix() function)

◆ enableMPFA

template<class TypeTag >
bool Dumux::FV2dPressure2P2CAdaptive< TypeTag >::enableMPFA
protected

Enables mpfa method to calculate the fluxes near hanging nodes.

◆ enableSecondHalfEdge

template<class TypeTag >
bool Dumux::FV2dPressure2P2CAdaptive< TypeTag >::enableSecondHalfEdge
protected

If possible, 2 interaction volumes are used for the mpfa method near hanging nodes

◆ enableVolumeIntegral

template<class TypeTag >
bool Dumux::FV2dPressure2P2CAdaptive< TypeTag >::enableVolumeIntegral
protected

Enables the volume integral of the pressure equation.

◆ ErrorTermFactor_

template<class TypeTag >
Scalar Dumux::FVPressure2P2C< TypeTag >::ErrorTermFactor_
protectedinherited

Handling of error term: relaxation factor.

◆ ErrorTermLowerBound_

template<class TypeTag >
Scalar Dumux::FVPressure2P2C< TypeTag >::ErrorTermLowerBound_
protectedinherited

Handling of error term: lower bound for error dampening.

◆ ErrorTermUpperBound_

template<class TypeTag >
Scalar Dumux::FVPressure2P2C< TypeTag >::ErrorTermUpperBound_
protectedinherited

Handling of error term: upper bound for error dampening

◆ f_

template<class TypeTag >
RHSVector Dumux::FVPressure< TypeTag >::f_
protectedinherited

Right hand side vector.

◆ incp_

template<class TypeTag >
Scalar Dumux::FVPressureCompositional< TypeTag >::incp_
protectedinherited

Increment for the volume derivative w.r.t pressure.

◆ initializationOutputWriter_

template<class TypeTag >
VtkMultiWriter<GridView> Dumux::FVPressureCompositional< TypeTag >::initializationOutputWriter_
protectedinherited

output for the initialization procedure

◆ maxError_

template<class TypeTag >
Scalar Dumux::FVPressureCompositional< TypeTag >::maxError_
protectedinherited

Maximum volume error of all cells.

◆ minimalBoundaryPermeability

template<class TypeTag >
Scalar Dumux::FVPressure2P2C< TypeTag >::minimalBoundaryPermeability
protectedinherited

Minimal limit for the boundary permeability.

◆ pressureType

template<class TypeTag >
constexpr int Dumux::FVPressure2P2C< TypeTag >::pressureType = GET_PROP_VALUE(TypeTag, PressureFormulation)
staticconstexprprotectedinherited

gives kind of pressure used ( \( 0 = p_w \), \( 1 = p_n \), \( 2 = p_{global} \))

◆ R_

template<class TypeTag >
DimMatrix Dumux::FV2dPressure2P2CAdaptive< TypeTag >::R_
protected

Matrix for vector rotation used in mpfa.

◆ regulateBoundaryPermeability

template<class TypeTag >
bool Dumux::FVPressure2P2C< TypeTag >::regulateBoundaryPermeability
protectedinherited

Enables regulation of permeability in the direction of a Dirichlet Boundary Condition.

◆ transmissibilityCalculator_

template<class TypeTag >
TransmissibilityCalculator Dumux::FV2dPressure2P2CAdaptive< TypeTag >::transmissibilityCalculator_
protected

The 2p Mpfa pressure module, that is only used for the calulation of transmissibility of the second interaction volumes.

◆ updateEstimate_

template<class TypeTag >
TransportSolutionType Dumux::FVPressureCompositional< TypeTag >::updateEstimate_
protectedinherited

Update estimate for changes in volume for the pressure equation.


The documentation for this class was generated from the following files: