diff --git a/dumux/decoupled/2p/2pindices.hh b/dumux/decoupled/2p/2pindices.hh
index 663f17bd1d4ac609f3aca6a03d02303e8def4972..2df31080429f82cde55cdab2cd0cbe6ae4a9d255 100644
--- a/dumux/decoupled/2p/2pindices.hh
+++ b/dumux/decoupled/2p/2pindices.hh
@@ -54,48 +54,51 @@ struct DecoupledTwoPCommonIndices
static const int totalPhaseIdx = 2; //!< Index of the total phase (wetting + nonwetting)
//saturation flags
- static const int saturationW = 0;
- static const int saturationNW = 1;
+ static const int saturationW = 0; //!< Indicates wetting phase saturation
+ static const int saturationNW = 1; //!< Indicates non-wetting phase saturation
//pressure flags
- static const int pressureW = 0;
- static const int pressureNW = 1;
- static const int pressureGlobal = 2;
+ static const int pressureW = 0; //!< Indicates wetting phase pressure
+ static const int pressureNW = 1; //!< Indicates non-wetting phase pressure
+ static const int pressureGlobal = 2; //!< Indicates global-pressure
//velocity flags
- static const int velocityW = 0;
- static const int velocityNW = 1;
- static const int velocityTotal = 2;
+ static const int velocityW = 0; //!< Indicates wetting phase velocity
+ static const int velocityNW = 1; //!< Indicates non-wetting phase velocity
+ static const int velocityTotal = 2; //!< Indicates total velocity
};
/*!
* \brief The indices for the \f$p_w-S_n\f$ formulation of the
* isothermal two-phase model.
*
- * \tparam formulation The formulation, either pwSn or pnSw
+ * \tparam formulation Index of the formulation
* \tparam PVOffset The first index in a primary variable vector.
*/
template <int formulation = DecoupledTwoPCommonIndices::pwSn, int PVOffset = 0>
struct DecoupledTwoPIndices : public DecoupledTwoPCommonIndices
{
// Primary variable indices
- static const int pressureIdx = PVOffset + 0; //!< Index for wetting/non-wetting phase pressure (depending on formulation) in a solution vector
- static const int saturationIdx = PVOffset + 1; //!< Index of the saturation of the non-wetting/wetting phase
+ static const int pressureIdx = PVOffset + 0; //!< Index for the primary pressure vairable in a solution vector
+ static const int saturationIdx = PVOffset + 1; //!< Index for the primary saturation variable in a solution vector
// indices of the primary variables
static const int pwIdx = PVOffset + 0; //!< Pressure index of the wetting phase
static const int SnIdx = PVOffset + 1; //!< Saturation index of the non-wetting phase
+ //! \cond \private
+ //Set the types of the single models depending on the formulation
static const int pressureType = pressureW;
static const int saturationType = saturationNW;
static const int velocityDefault = velocityNW;
+ //! \endcond
// indices of the equations
static const int contiWEqIdx = PVOffset + 0; //!< Index of the continuity equation of the wetting phase
static const int pressEqIdx = contiWEqIdx; //!< Index of the pressure equation (total mass balance)
static const int contiNEqIdx = PVOffset + 1; //!< Index of the continuity equation of the non-wetting phase
static const int satEqIdx = contiNEqIdx; //!< Index of the continuity equation of the non-wetting phase (saturation equation)
- static const int transportEqIdx = satEqIdx;
+ static const int transportEqIdx = satEqIdx; //!< Index of the saturation transport equation
};
/*!
@@ -109,32 +112,35 @@ struct DecoupledTwoPIndices<DecoupledTwoPCommonIndices::pnSw, PVOffset>
: public DecoupledTwoPCommonIndices
{
// Primary variable indices
- static const int pressureIdx = PVOffset + 0; //!< Index for wetting/non-wetting phase pressure (depending on formulation) in a solution vector
- static const int saturationIdx = PVOffset + 1; //!< Index of the saturation of the non-wetting/wetting phase
+ static const int pressureIdx = PVOffset + 0; //!< Index for the primary pressure vairable in a solution vector
+ static const int saturationIdx = PVOffset + 1; //!< Index for the primary saturation variable in a solution vector
// indices of the primary variables
static const int pnIdx = PVOffset + 0; //!< Pressure index of the non-wetting phase
static const int SwIdx = PVOffset + 1; //!< Saturation index of the wetting phase
+ //! \cond \private
+ //Set the types of the single models depending on the formulation
static const int pressureType = pressureNW;
static const int saturationType = saturationW;
static const int velocityDefault = velocityW;
+ //! \endcond
// indices of the equations
static const int contiNEqIdx = PVOffset + 0; //!< Index of the continuity equation of the non-wetting phase
static const int pressEqIdx = contiNEqIdx; //!< Index of the pressure equation (total mass balance)
static const int contiWEqIdx = PVOffset + 1; //!< Index of the continuity equation of the wetting phase
static const int satEqIdx = contiWEqIdx; //!< Index of the continuity equation of the non-wetting phase (saturation equation)
- static const int transportEqIdx = satEqIdx;
+ static const int transportEqIdx = satEqIdx; //!< Index of the saturation transport equation
};
/*!
- * \brief The indices for the \f$p_w-S_n\f$ formulation of the
+ * \brief The indices for the \f$p_w-S_w\f$ formulation of the
* isothermal two-phase model.
*
- * \tparam formulation The formulation, either pwSn or pnSw
+ * \tparam formulation Index of the formulation
* \tparam PVOffset The first index in a primary variable vector.
*/
template <int PVOffset>
@@ -142,28 +148,31 @@ struct DecoupledTwoPIndices<DecoupledTwoPCommonIndices::pwSw, PVOffset>
: public DecoupledTwoPCommonIndices
{
// Primary variable indices
- static const int pressureIdx = PVOffset + 0; //!< Index for wetting/non-wetting phase pressure (depending on formulation) in a solution vector
- static const int saturationIdx = PVOffset + 1; //!< Index of the saturation of the non-wetting/wetting phase
+ static const int pressureIdx = PVOffset + 0; //!< Index for the primary pressure vairable in a solution vector
+ static const int saturationIdx = PVOffset + 1; //!< Index for the primary saturation variable in a solution vector
// indices of the primary variables
static const int pwIdx = PVOffset + 0; //!< Pressure index of the wetting phase
static const int SwIdx = PVOffset + 1; //!< Saturation index of the wetting phase
+ //! \cond \private
+ //Set the types of the single models depending on the formulation
static const int pressureType = pressureW;
static const int saturationType = saturationW;
static const int velocityDefault = velocityW;
+ //! \endcond
// indices of the equations
static const int contiWEqIdx = PVOffset + 0; //!< Index of the continuity equation of the wetting phase
static const int pressEqIdx = contiWEqIdx; //!< Index of the pressure equation (total mass balance)
static const int contiNEqIdx = PVOffset + 1; //!< Index of the continuity equation of the non-wetting phase
static const int satEqIdx = contiNEqIdx; //!< Index of the continuity equation of the non-wetting phase (saturation equation)
- static const int transportEqIdx = satEqIdx;
+ static const int transportEqIdx = satEqIdx; //!< Index of the saturation transport equation
};
/*!
- * \brief The indices for the \f$p_n-S_w\f$ formulation of the
+ * \brief The indices for the \f$p_n-S_n\f$ formulation of the
* isothermal two-phase model.
*
* \tparam PVOffset The first index in a primary variable vector.
@@ -173,58 +182,64 @@ struct DecoupledTwoPIndices<DecoupledTwoPCommonIndices::pnSn, PVOffset>
: public DecoupledTwoPCommonIndices
{
// Primary variable indices
- static const int pressureIdx = PVOffset + 0; //!< Index for wetting/non-wetting phase pressure (depending on formulation) in a solution vector
- static const int saturationIdx = PVOffset + 1; //!< Index of the saturation of the non-wetting/wetting phase
+ static const int pressureIdx = PVOffset + 0; //!< Index for the primary pressure vairable in a solution vector
+ static const int saturationIdx = PVOffset + 1; //!< Index for the primary saturation variable in a solution vector
// indices of the primary variables
static const int pnIdx = PVOffset + 0; //!< Pressure index of the non-wetting phase
static const int SnIdx = PVOffset + 1; //!< Saturation index of the non-wetting phase
+ //! \cond \private
+ //Set the types of the single models depending on the formulation
static const int pressureType = pressureNW;
static const int saturationType = saturationNW;
static const int velocityDefault = velocityNW;
+ //! \endcond
// indices of the equations
static const int contiNEqIdx = PVOffset + 0; //!< Index of the continuity equation of the non-wetting phase
static const int pressEqIdx = contiNEqIdx; //!< Index of the pressure equation (total mass balance)
static const int contiWEqIdx = PVOffset + 1; //!< Index of the continuity equation of the wetting phase
static const int satEqIdx = contiWEqIdx; //!< Index of the continuity equation of the non-wetting phase (saturation equation)
- static const int transportEqIdx = satEqIdx;
+ static const int transportEqIdx = satEqIdx; //!< Index of the saturation transport equation
};
/*!
- * \brief The indices for the \f$p_w-S_n\f$ formulation of the
+ * \brief The indices for the \f$p_{global}-S_w\f$ formulation of the
* isothermal two-phase model.
*
- * \tparam formulation The formulation, either pwSn or pnSw
+ * \tparam formulation Index of the formulation
* \tparam PVOffset The first index in a primary variable vector.
*/
template <int PVOffset>
struct DecoupledTwoPIndices<DecoupledTwoPCommonIndices::pGlobalSw, PVOffset> : public DecoupledTwoPCommonIndices
{
// Primary variable indices
- static const int pressureIdx = PVOffset + 0; //!< Index for wetting/non-wetting phase pressure (depending on formulation) in a solution vector
- static const int saturationIdx = PVOffset + 1; //!< Index of the saturation of the non-wetting/wetting phase
+ static const int pressureIdx = PVOffset + 0; //!< Index for the primary pressure vairable in a solution vector
+ static const int saturationIdx = PVOffset + 1; //!< Index for the primary saturation variable in a solution vector
// indices of the primary variables
- static const int pGlobalIdx = PVOffset + 0; //!< Pressure index of the wetting phase
+ static const int pGlobalIdx = PVOffset + 0; //!< Global pressure index
static const int SwIdx = PVOffset + 1; //!< Saturation index of the wetting phase
+ //! \cond \private
+ //Set the types of the single models depending on the formulation
static const int pressureType = pressureGlobal;
static const int saturationType = saturationW;
static const int velocityDefault = velocityTotal;
+ //! \endcond
// indices of the equations
static const int pressEqIdx = PVOffset + 0; //!< Index of the pressure equation (total mass balance)
static const int satEqIdx = PVOffset + 1; //!< Index of the continuity equation of the non-wetting phase (saturation equation)
- static const int transportEqIdx = satEqIdx;
+ static const int transportEqIdx = satEqIdx; //!< Index of the saturation transport equation
};
/*!
- * \brief The indices for the \f$p_n-S_w\f$ formulation of the
+ * \brief The indices for the \f$p_{global}-S_n\f$ formulation of the
* isothermal two-phase model.
*
* \tparam PVOffset The first index in a primary variable vector.
@@ -234,22 +249,25 @@ struct DecoupledTwoPIndices<DecoupledTwoPCommonIndices::pGlobalSn, PVOffset>
: public DecoupledTwoPCommonIndices
{
// Primary variable indices
- static const int pressureIdx = PVOffset + 0; //!< Index for wetting/non-wetting phase pressure (depending on formulation) in a solution vector
- static const int saturationIdx = PVOffset + 1; //!< Index of the saturation of the non-wetting/wetting phase
+ static const int pressureIdx = PVOffset + 0; //!< Index for the primary pressure vairable in a solution vector
+ static const int saturationIdx = PVOffset + 1; //!< Index for the primary saturation variable in a solution vector
// indices of the primary variables
- static const int pGlobalIdx = PVOffset + 0; //!< Pressure index of the wetting phase
+ static const int pGlobalIdx = PVOffset + 0; //!< Global pressure index
static const int SnIdx = PVOffset + 1; //!< Saturation index of the non-wetting phase
+ //! \cond \private
+ //Set the types of the single models depending on the formulation
static const int pressureType = pressureGlobal;
static const int saturationType = saturationNW;
static const int velocityDefault = velocityTotal;
+ //! \endcond
// indices of the equations
static const int pressEqIdx = PVOffset + 0; //!< Index of the pressure equation (total mass balance)
static const int satEqIdx = PVOffset + 1; //!< Index of the continuity equation of the non-wetting phase (saturation equation)
- static const int transportEqIdx = satEqIdx;
+ static const int transportEqIdx = satEqIdx; //!< Index of the saturation transport equation
};
// \}
diff --git a/dumux/decoupled/2p/2pproperties.hh b/dumux/decoupled/2p/2pproperties.hh
index fede543cee6036d81bb0196b373c8041b6e8f220..fe6e177947274fce9fc6344533d9e1f84d69dc75 100644
--- a/dumux/decoupled/2p/2pproperties.hh
+++ b/dumux/decoupled/2p/2pproperties.hh
@@ -29,7 +29,7 @@
/*!
* \file
*
- * \brief Defines the properties required for (immiscible) twophase sequential models.
+ * \brief Defines the properties required for (immiscible) two-phase sequential models.
*/
#ifndef DUMUX_2PPROPERTIES_DECOUPLED_HH
@@ -56,7 +56,7 @@ namespace Properties
// Type tags
//////////////////////////////////////////////////////////////////
-//! The type tag for the two-phase problems
+//! The TypeTag for decoupled two-phase problems
NEW_TYPE_TAG(DecoupledTwoP, INHERITS_FROM(DecoupledModel))
;
@@ -67,31 +67,35 @@ NEW_TYPE_TAG(DecoupledTwoP, INHERITS_FROM(DecoupledModel))
NEW_PROP_TAG( SpatialParameters )
; //!< The type of the spatial parameters object
NEW_PROP_TAG(MaterialLaw); //!< The material law which ought to be used (extracted from the spatial parameters)
-NEW_PROP_TAG(MaterialLawParams); //!< The context material law (extracted from the spatial parameters)
+NEW_PROP_TAG(MaterialLawParams); //!< The material law parameters (extracted from the spatial parameters)
NEW_PROP_TAG( EnableGravity)
; //!< Returns whether gravity is considered in the problem
-NEW_PROP_TAG( Formulation);
+NEW_PROP_TAG( Formulation); //!< The formulation of the model
NEW_PROP_TAG( PressureFormulation)
-; //!< The formulation of the model
+; //!< The formulation of the pressure model
NEW_PROP_TAG( SaturationFormulation)
-; //!< The formulation of the model
+; //!< The formulation of the saturation model
NEW_PROP_TAG( VelocityFormulation)
-; //!< The formulation of the model
+; //!< The type of velocity reconstructed for the transport model
NEW_PROP_TAG( EnableCompressibility)
;// !< Returns whether compressibility is allowed
NEW_PROP_TAG( WettingPhase)
-; //!< The wetting phase for two-phase models
+; //!< The wetting phase of a two-phase model
NEW_PROP_TAG( NonwettingPhase)
-; //!< The non-wetting phase for two-phase models
+; //!< The non-wetting phase of a two-phase model
NEW_PROP_TAG( FluidSystem )//!< Defines the fluid system
;
NEW_PROP_TAG( FluidState )//!< Defines the fluid state
;
-NEW_PROP_TAG( TwoPIndices ); //!< keep for compatibility with box models
-NEW_PROP_TAG( ErrorTermFactor );
-NEW_PROP_TAG( ErrorTermLowerBound );
-NEW_PROP_TAG( ErrorTermUpperBound );
+//! \cond \private
+// keep only for compatibility with box models
+NEW_PROP_TAG( TwoPIndices );
+//! \endcond
+
+NEW_PROP_TAG( ErrorTermFactor ); //! Scaling factor for the error term (term to damp unphysical saturation overshoots via pressure correction)
+NEW_PROP_TAG( ErrorTermLowerBound );//! Lower threshold used for the error term evaluation (term to damp unphysical saturation overshoots via pressure correction)
+NEW_PROP_TAG( ErrorTermUpperBound );//!Upper threshold used for the error term evaluation (term to damp unphysical saturation overshoots via pressure correction)
}
}
@@ -107,44 +111,59 @@ namespace Properties
//////////////////////////////////////////////////////////////////
// Properties
//////////////////////////////////////////////////////////////////
+//! Set number of equations to 2 for isothermal two-phase models
SET_INT_PROP(DecoupledTwoP, NumEq, 2);
+//! Set number of phases to 2 for two-phase models
SET_INT_PROP(DecoupledTwoP, NumPhases, 2);//!< The number of phases in the 2p model is 2
+//! Set number of components to 1 for immiscible two-phase models
SET_INT_PROP(DecoupledTwoP, NumComponents, 1); //!< Each phase consists of 1 pure component
-
+//! Set \f$p_w\f$-\f$S_n\f$ formulation as default two-phase formulation
SET_INT_PROP(DecoupledTwoP,
Formulation,
DecoupledTwoPCommonIndices::pwSw);
+//! Chose the set of indices depending on the chosen formulation
SET_PROP(DecoupledTwoP, Indices)
{
typedef DecoupledTwoPIndices<GET_PROP_VALUE(TypeTag, Formulation), 0> type;
};
+
+//! \cond \private
+// keep only for compatibility with box models
SET_TYPE_PROP(DecoupledTwoP, TwoPIndices, typename GET_PROP_TYPE(TypeTag, Indices));
+//! \endcond
-//! Set the default formulation
+//! Set the default pressure formulation according to the chosen two-phase formulation
SET_INT_PROP(DecoupledTwoP,
PressureFormulation,
GET_PROP_TYPE(TypeTag, Indices)::pressureType);
+//! Set the default saturation formulation according to the chosen two-phase formulation
SET_INT_PROP(DecoupledTwoP,
SaturationFormulation,
GET_PROP_TYPE(TypeTag, Indices)::saturationType);
+//! Set the default velocity formulation according to the chosen two-phase formulation
SET_INT_PROP(DecoupledTwoP,
VelocityFormulation,
GET_PROP_TYPE(TypeTag, Indices)::velocityDefault);
+//! Disable compressibility by default
SET_BOOL_PROP(DecoupledTwoP, EnableCompressibility, false);
+//! Set general decoupled VariableClass as default
SET_TYPE_PROP(DecoupledTwoP, Variables, VariableClass<TypeTag>);
+//! Set standart CellData of immiscible two-phase models as default
SET_TYPE_PROP(DecoupledTwoP, CellData, CellData2P<TypeTag, GET_PROP_VALUE(TypeTag, EnableCompressibility)>);
+//! Set default fluid system
SET_TYPE_PROP(DecoupledTwoP, FluidSystem, TwoPImmiscibleFluidSystem<TypeTag>);
+//! Set default fluid state
SET_PROP(DecoupledTwoP, FluidState)
{
private:
@@ -167,8 +186,11 @@ public:
typedef typename MaterialLaw::Params type;
};
+//! Default error term factor
SET_SCALAR_PROP(DecoupledTwoP, ErrorTermFactor, 0.5);
+//! Default lower threshold for evaluation of an error term
SET_SCALAR_PROP(DecoupledTwoP, ErrorTermLowerBound, 0.1);
+//! Default upper threshold for evaluation of an error term
SET_SCALAR_PROP(DecoupledTwoP, ErrorTermUpperBound, 0.9);
// \}
diff --git a/dumux/decoupled/2p/cellData2p.hh b/dumux/decoupled/2p/cellData2p.hh
index 476852138b65225a8863341a3332df99d9de2784..723a6486a1bb83dc19e4141ecfe2e5d8a0c7b242 100644
--- a/dumux/decoupled/2p/cellData2p.hh
+++ b/dumux/decoupled/2p/cellData2p.hh
@@ -27,7 +27,7 @@
/**
* @file
- * @brief Class including the variables and data of discretized data of the constitutive relations for one element
+ * @brief Class including data of one grid cell
* @author Markus Wolff
*/
@@ -39,16 +39,28 @@ class FluxData2P;
/*!
* \ingroup IMPES
*/
-//! Class including the variables and data of discretized data of the constitutive relations for one element.
-/*! The variables of two-phase flow, which are one pressure and one saturation are stored in this class.
- * Additionally, a velocity needed in the transport part of the decoupled two-phase flow is stored, as well as discretized data of constitutive relationships like
- * mobilities, fractional flow functions and capillary pressure. Thus, they have to be callculated just once in every time step or every iteration step.
+//! Class including data of one grid cell.
+/*! The variables of two-phase flow, which are phase pressures and saturations are stored in this class. Further, resulting cell values for constitutive relationships like
+ * mobilities, fractional flow functions and capillary pressure are stored.
+ * Additionally, data assigned to cell-cell interfaces, so-called flux-data are stored.
*
- * @tparam TypeTag The Type Tag
- 1*/
+ * \tparam TypeTag The problem TypeTag
+ * \tparam bool Used for specialization for case of compressible flow (<tt>true</tt>) or incompressible flow (<tt>false</tt>)
+ */
template<class TypeTag, bool enableCompressibility>
class CellData2P;
+/*!
+ * \ingroup IMPES
+ */
+//! Class including the variables and data of discretized data of the constitutive relations for one grid cell.
+/*! The variables of two-phase flow, which are phase pressures and saturations are stored in this class. Further, resulting cell values for constitutive relationships like
+ * mobilities, fractional flow functions and capillary pressure are stored.
+ * Additionally, data assigned to cell-cell interfaces, so-called flux-data are stored.
+ *
+ * \tparam TypeTag The problem TypeTag
+ * \tparam bool Used for specialization: in case of incompressible flow bool = <tt>false</tt>
+ */
template<class TypeTag>
class CellData2P<TypeTag, false>
{
@@ -85,11 +97,7 @@ private:
FluxData fluxData_;
public:
- //! Constructs a VariableClass object
- /**
- * @param gridView a DUNE gridview object corresponding to diffusion and transport equation
- */
-
+ //! Constructs a CellData2P object
CellData2P()
{
for (int i = 0; i < numPhases;i++)
@@ -103,72 +111,108 @@ public:
update_ = 0.0;
}
+ //! Returns the flux data of the cell
FluxData& fluxData()
{
return fluxData_;
}
+ //! Returns the flux data of the cell
const FluxData& fluxData() const
{
return fluxData_;
}
+ //! \cond \private
+ //fluidstates are not stored for the incompressible model, however the function is needed to avoid compiler errors
FluidState& fluidState()
{
DUNE_THROW(Dune::NotImplemented,"fluid states not stored in cell data of incompressible models!");
}
+ //fluidstates are not stored for the incompressible model, however the function is needed to avoid compiler errors
const FluidState& fluidState() const
{
DUNE_THROW(Dune::NotImplemented,"fluid states not stored in cell data of incompressible models!");
}
+ //! \endcond
////////////////////////////////////////////////////////////
// functions returning primary variables
////////////////////////////////////////////////////////////
-
+ /*!\brief Returns the cell phase pressure
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar pressure(int phaseIdx)
{
return pressure_[phaseIdx];
}
+ /*!\brief Returns the cell phase pressure
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar pressure(int phaseIdx) const
{
return pressure_[phaseIdx];
}
+ /*!\brief Sets the cell phase pressure
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param press Phase pressure which is stored
+ */
void setPressure(int phaseIdx, Scalar press)
{
pressure_[phaseIdx] = press;
}
+ //! Returns the global pressure of the cell
Scalar globalPressure()
{
return pressure_[wPhaseIdx];
}
+ //! Returns the global pressure of the cell
Scalar globalPressure() const
{
return pressure_[wPhaseIdx];
}
+ /*!\brief Sets the cell global pressure
+ *
+ * \param press Global pressure which is stored
+ */
void setGlobalPressure(Scalar press)
{
pressure_[wPhaseIdx] = press;
}
- //! Return saturation vector
+ /*!\brief Returns the cell phase saturation
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar saturation(int phaseIdx)
{
return saturation_[phaseIdx];
}
+ /*!\brief Returns the cell phase saturation
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar saturation(int phaseIdx) const
{
return saturation_[phaseIdx];
}
+ /*!\brief Sets the cell phase saturation
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param sat Phase saturation which is stored
+ */
void setSaturation(int phaseIdx, Scalar sat)
{
saturation_[phaseIdx] = sat;
@@ -178,71 +222,105 @@ public:
// functions returning the vectors of secondary variables
//////////////////////////////////////////////////////////////
- //! Return phase mobilities
+ /*!\brief Returns the cell phase mobility
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar mobility(int phaseIdx)
{
return mobility_[phaseIdx];
}
+ /*!\brief Returns the cell phase mobility
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar mobility(int phaseIdx) const
{
return mobility_[phaseIdx];
}
+ /*!\brief Sets the cell phase mobility
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param mobility Phase mobility with which is stored
+ */
void setMobility(int phaseIdx, Scalar mobility)
{
mobility_[phaseIdx] = mobility;
}
- //! Return phase fractional flow functions
+ /*!\brief Returns the cell phase fractional flow function
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar fracFlowFunc(int phaseIdx)
{
return fracFlowFunc_[phaseIdx];
}
+ /*!\brief Returns the cell phase fractional flow function
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar fracFlowFunc(int phaseIdx) const
{
return fracFlowFunc_[phaseIdx];
}
+ /*!\brief Sets the cell phase fractional flow function
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param fracFlowFunc Phase fractional flow function which is stored
+ */
void setFracFlowFunc(int phaseIdx, Scalar fracFlowFunc)
{
fracFlowFunc_[phaseIdx] = fracFlowFunc;
}
- //! Return capillary pressure vector
+ //! Returns the cell capillary pressure
Scalar capillaryPressure()
{
return capillaryPressure_;
}
+ //! Returns the cell capillary pressure
Scalar capillaryPressure() const
{
return capillaryPressure_;
}
+ /*!\brief Sets the cell capillary pressure
+ *
+ * \param pc Capillary pressure which is stored
+ */
void setCapillaryPressure(Scalar pc)
{
capillaryPressure_ = pc;
}
+ /*!\brief Store transport update
+ *
+ * \param update Transport update of the cell
+ */
void setUpdate(Scalar update)
{
update_ = update;
}
- //! Return density vector
+ //! Returns the cell volume correction needed in the pressure equation
Scalar volumeCorrection()
{
return update_;
}
-
+ //! Returns the cell volume correction needed in the pressure equation
Scalar volumeCorrection() const
{
return update_;
}
- //! Return density vector
+ //! \cond \private
+ //densities are not stored for the incompressible model, however the function is needed to avoid compiler errors
Scalar density(int phaseIdx)
{
DUNE_THROW(Dune::NotImplemented,"density function not implemented in cell data of incompressible models!");
@@ -252,7 +330,7 @@ public:
DUNE_THROW(Dune::NotImplemented,"density function not implemented in cell data of incompressible models!");
}
- //! Return density vector
+ //viscosities are not stored for the incompressible model, however the function is needed to avoid compiler errors
Scalar viscosity(int phaseIdx)
{
DUNE_THROW(Dune::NotImplemented,"viscosity function not implemented in cell data of incompressible models!");
@@ -262,8 +340,20 @@ public:
{
DUNE_THROW(Dune::NotImplemented,"viscosity function not implemented in cell data of incompressible models!");
}
+ //! \endcond
};
+/*!
+ * \ingroup IMPES
+ */
+//! Class including the variables and data of discretized data of the constitutive relations for one grid cell.
+/*! The variables of two-phase flow, which are phase pressures and saturations are stored in this class. Further, resulting cell values for constitutive relationships like
+ * mobilities, fractional flow functions and capillary pressure are stored.
+ * Additionally, data assigned to cell-cell interfaces, so-called flux-data are stored.
+ *
+ * \tparam TypeTag The problem TypeTag
+ * \tparam bool Used for specialization: In case of compressible flow bool = <tt>true</tt>
+ */
template<class TypeTag>
class CellData2P<TypeTag, true>
{
@@ -297,11 +387,7 @@ private:
FluidState fluidState_;
public:
- //! Constructs a VariableClass object
- /**
- * @param gridView a DUNE gridview object corresponding to diffusion and transport equation
- */
-
+ //! Constructs a CellData2P object
CellData2P()
{
for (int i = 0; i < numPhases;i++)
@@ -312,21 +398,24 @@ public:
update_ = 0.0;
}
+ //! Returns the flux data of the cell
FluxData& fluxData()
{
return fluxData_;
}
+ //! Returns the flux data of the cell
const FluxData& fluxData() const
{
return fluxData_;
}
+ //! Returns the FluidState object for this cell
FluidState& fluidState()
{
return fluidState_;
}
-
+ //! Returns the FluidState object for this cell
const FluidState& fluidState() const
{
return fluidState_;
@@ -336,49 +425,77 @@ public:
// functions returning primary variables
////////////////////////////////////////////////////////////
-
+ /*!\brief Returns the cell phase pressure
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar pressure(int phaseIdx)
{
return fluidState_.pressure(phaseIdx);
}
+ /*!\brief Returns the cell phase pressure
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar pressure(int phaseIdx) const
{
return fluidState_.pressure(phaseIdx);
}
+ /*!\brief Sets the cell phase pressure
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param press Phase pressure which is stored
+ */
void setPressure(int phaseIdx, Scalar press)
{
fluidState_.setPressure(phaseIdx, press);
}
+ //! \cond \private
+ // global pressure is not supported in the compressible case, however the function hast to be defined to avoid compiler errors!
Scalar globalPressure()
{
DUNE_THROW(Dune::NotImplemented,"no global pressure defined for compressible models!");
}
+ // global pressure is not supported in the compressible case, however the function hast to be defined to avoid compiler errors!
Scalar globalPressure() const
{
DUNE_THROW(Dune::NotImplemented,"no global pressure defined for compressible models!");
}
+ // global pressure is not supported in the compressible case, however the function hast to be defined to avoid compiler errors!
void setGlobalPressure(Scalar press)
{
DUNE_THROW(Dune::NotImplemented,"no global pressure defined for compressible models!");
}
+ //! \endcond
-
- //! Return saturation vector
+ /*!\brief Returns the cell phase saturation
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar saturation(int phaseIdx)
{
return fluidState_.saturation(phaseIdx);
}
+ /*!\brief Returns the cell phase saturation
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar saturation(int phaseIdx) const
{
return fluidState_.saturation(phaseIdx);
}
+ /*!\brief Sets the cell phase saturation
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param sat Phase saturation which is stored
+ */
void setSaturation(int phaseIdx, Scalar sat)
{
fluidState_.setSaturation(phaseIdx, sat);
@@ -388,96 +505,154 @@ public:
// functions returning the vectors of secondary variables
//////////////////////////////////////////////////////////////
- //! Return phase mobilities
+ /*!\brief Returns the cell phase mobility
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar mobility(int phaseIdx)
{
return mobility_[phaseIdx];
}
+ /*!\brief Returns the cell phase mobility
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar mobility(int phaseIdx) const
{
return mobility_[phaseIdx];
}
+ /*!\brief Sets the cell phase mobility
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param mobility Phase mobility with which is stored
+ */
void setMobility(int phaseIdx, Scalar mobility)
{
mobility_[phaseIdx] = mobility;
}
- //! Return phase fractional flow functions
+ /*!\brief Returns the cell phase fractional flow function
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar fracFlowFunc(int phaseIdx)
{
return fracFlowFunc_[phaseIdx];
}
+ /*!\brief Returns the cell phase fractional flow function
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar fracFlowFunc(int phaseIdx) const
{
return fracFlowFunc_[phaseIdx];
}
+ /*!\brief Sets the cell phase fractional flow function
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param fracFlowFunc Phase fractional flow function which is stored
+ */
void setFracFlowFunc(int phaseIdx, Scalar fracFlowFunc)
{
fracFlowFunc_[phaseIdx] = fracFlowFunc;
}
- //! Return capillary pressure vector
+ //! Returns the cell capillary pressure
Scalar capillaryPressure()
{
return fluidState_.pressure(nPhaseIdx) - fluidState_.pressure(wPhaseIdx);
}
+ //! Returns the cell capillary pressure
Scalar capillaryPressure() const
{
return fluidState_.pressure(nPhaseIdx) - fluidState_.pressure(wPhaseIdx);
}
+ //! \cond \private
+ //in the compressible model capillary pressure is not stored eplicitely, however the function is needed to avoid compiler errors
void setCapillaryPressure(Scalar pc)
{
DUNE_THROW(Dune::NotImplemented,"no capillary pressure stored for compressible models!");
}
+ //! \endcond
- //! Return density vector
+ /*!\brief Returns the cell phase density
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar density(int phaseIdx)
{
return fluidState_.density(phaseIdx);
}
+
+ /*!\brief Returns the cell phase density
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar density(int phaseIdx) const
{
return fluidState_.density(phaseIdx);
}
+ /*!\brief Sets the cell phase density
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param density Phase density which is stored
+ */
void setDensity(int phaseIdx, Scalar density)
{
fluidState_.setDensity(phaseIdx, density);
}
- //! Return density vector
+ /*!\brief Returns the cell phase viscosity
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar viscosity(int phaseIdx)
{
return fluidState_.viscosity(phaseIdx);
}
+ /*!\brief Returns the cell phase viscosity
+ *
+ * \param phaseIdx Index of a fluid phase
+ */
Scalar viscosity(int phaseIdx) const
{
return fluidState_.viscosity(phaseIdx);
}
+ /*!\brief Sets the cell phase viscosity
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param viscosity Phase viscosity which is stored
+ */
void setViscosity(int phaseIdx, Scalar viscosity)
{
fluidState_.setViscosity(phaseIdx, viscosity);
}
+ /*!\brief Store transport update
+ *
+ * \param update Transport update of the cell
+ */
void setUpdate(Scalar update)
{
update_ = update;
}
- //! Return density vector
+ //! Returns the cell volume correction needed in the pressure equation
Scalar volumeCorrection()
{
return update_;
}
+ //! Returns the cell volume correction needed in the pressure equation
Scalar volumeCorrection() const
{
return update_;
diff --git a/dumux/decoupled/2p/cellData2p_adaptive.hh b/dumux/decoupled/2p/cellData2p_adaptive.hh
index 4da6e333511b8a2a8a400fd3ca476a2b25587729..a612e3149a0aa99a191f316a547cbf9549243343 100644
--- a/dumux/decoupled/2p/cellData2p_adaptive.hh
+++ b/dumux/decoupled/2p/cellData2p_adaptive.hh
@@ -26,22 +26,23 @@
/**
* @file
- * @brief Class including the variables and data of discretized data of the constitutive relations for one element
+ * @brief Class including the data of a grid cell needed if an adaptive grid is used.
* @author Markus Wolff
*/
namespace Dumux
{
+
/*!
* \ingroup IMPES
*/
-//! Class including the variables and data of discretized data of the constitutive relations for one element.
-/*! The variables of two-phase flow, which are one pressure and one saturation are stored in this class.
- * Additionally, a velocity needed in the transport part of the decoupled two-phase flow is stored, as well as discretized data of constitutive relationships like
- * mobilities, fractional flow functions and capillary pressure. Thus, they have to be callculated just once in every time step or every iteration step.
+//! Class including the data of a grid cell needed if an adaptive grid is used.
+/*! The class provides model-specific functions needed to adapt the stored cell data to a new (adapted) grid.
+ * Additionally, it provides the storage-infrastructure for explicit front tracking.
*
- * @tparam TypeTag The Type Tag
- 1*/
+ * \tparam TypeTag The problem TypeTag
+ * \tparam bool Used for specialization for case of compressible flow (<tt>true</tt>) or incompressible flow (<tt>false</tt>)
+ */
template<class TypeTag, bool enableCompressibility = GET_PROP_VALUE(TypeTag, EnableCompressibility)>
class CellData2PAdaptive: public CellData2P<TypeTag, enableCompressibility>
{
@@ -79,7 +80,7 @@ private:
public:
//! Collection of variables that have to be mapped if the grid is adapted
/**
- * For an non-compositional two-phase model, the following data has to be
+ * For an immiscible two-phase model, the following data has to be
* transferred to a new grid.
*/
struct AdaptedValues
@@ -104,22 +105,29 @@ public:
};
//! Constructs an adaptive CellData object
- /**
- */
CellData2PAdaptive():
isFront_(false)
{}
+ /*! \brief Track the front
+ *
+ * Returns true if the cell is located at a fluid-fluid displacement-front
+ */
bool isFront() const
{
return isFront_;
}
+ /*! \brief Track the front
+ *
+ * Returns true if the cell is located at a fluid-fluid displacement-front
+ */
bool isFront()
{
return isFront_;
}
+ //! Marks the cell as fluid-fluid displacement-front cell
void setFront()
{
isFront_ = true;
diff --git a/dumux/decoupled/2p/fluxData2p.hh b/dumux/decoupled/2p/fluxData2p.hh
index 8386639707afb53d6a7efbaf255a67f28fa96770..27ff6c5bfd43d46c45ec67c995647acec45a194b 100644
--- a/dumux/decoupled/2p/fluxData2p.hh
+++ b/dumux/decoupled/2p/fluxData2p.hh
@@ -26,7 +26,7 @@
/**
* @file
- * @brief Class including the variables and data of discretized data of the constitutive relations
+ * @brief Class storing data assigned to a cell-cell interfaces, so-called flux-data
* @author Markus Wolff
*/
@@ -35,13 +35,11 @@ namespace Dumux
/*!
* \ingroup IMPES
*/
-//! Class including the variables and data of discretized data of the constitutive relations.
-/*! The variables of two-phase flow, which are one pressure and one saturation are stored in this class.
- * Additionally, a velocity needed in the transport part of the decoupled two-phase flow is stored, as well as discretized data of constitutive relationships like
- * mobilities, fractional flow functions and capillary pressure. Thus, they have to be callculated just once in every time step or every iteration step.
+//! Class storing data assigned to a cell-cell interfaces, so-called flux-data.
+/*! Stores velocities and potentials at cell-cell interfaces. Further it provides methods which interpret stored phase potentials for upwind decisions.
*
- * @tparam TypeTag The Type Tag
- 1*/
+ * @tparam TypeTag The problem TypeTag
+ */
template<class TypeTag>
class FluxData2P
{
@@ -77,11 +75,7 @@ private:
public:
- //! Constructs a VariableClass object
- /**
- * @param gridView a DUNE gridview object corresponding to diffusion and transport equation
- */
-
+ //! Constructs a FluxData2P object
FluxData2P()
{
for (int face = 0; face < 2*dim; face++)
@@ -100,27 +94,49 @@ public:
// functions returning the vectors of the primary variables
////////////////////////////////////////////////////////////
- //! Return the velocity
+ /*! \brief Returns the phase velocity vector at a cell-cell interface
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param indexInInside Index of the cell-cell interface in this cell
+ */
const FieldVector& velocity(int phaseIdx, int indexInInside)
{
return velocity_[phaseIdx][indexInInside];
}
+ /*! \brief Returns the phase velocity vector at a cell-cell interface
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param indexInInside Index of the cell-cell interface in this cell
+ */
const FieldVector& velocity(int phaseIdx, int indexInInside) const
{
return velocity_[phaseIdx][indexInInside];
}
+ /*! \brief Sets the phase velocity vector at a cell-cell interface
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param indexInInside Index of the cell-cell interface in this cell
+ * \param velocity Phase velocity vector which is stored
+ */
void setVelocity(int phaseIdx, int indexInInside, const FieldVector& velocity)
{
velocity_[phaseIdx][indexInInside] = velocity;
}
+ /*! \brief Adds a phase velocity vector to the one previously stored.
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param indexInInside Index of the cell-cell interface in this cell
+ * \param velocity Phase velocity vector which is added
+ */
void addVelocity(int phaseIdx, int indexInInside, const FieldVector& velocity)
{
velocity_[phaseIdx][indexInInside] += velocity;
}
+ //!Resets velocities and potentials
void resetVelocity()
{
for (int i = 0; i < 2 * dim; i++)
@@ -134,59 +150,112 @@ public:
}
}
- //! Return the velocity
+ /*! \brief Returns the total velocity vector at a cell-cell interface
+ *
+ * \param indexInInside Index of the cell-cell interface in this cell
+ */
FieldVector velocityTotal(int indexInInside)
{
return velocity_[wPhaseIdx][indexInInside]
+ velocity_[nPhaseIdx][indexInInside];
}
+ /*! \brief Returns the total velocity vector at a cell-cell interface
+ *
+ * \param indexInInside Index of the cell-cell interface in this cell
+ */
FieldVector velocityTotal(int indexInInside) const
{
return velocity_[wPhaseIdx][indexInInside]
+ velocity_[nPhaseIdx][indexInInside];
}
+ /*! \brief Sets the velocity marker at a cell-cell interface
+ * This marker can be used to check if a velocity has already been stored for this interface
+ *
+ * \param indexInInside Index of the cell-cell interface in this cell
+ */
void setVelocityMarker(int indexInInside)
{
velocityMarker_[indexInInside] = true;
}
+ /*! \brief Check the velocity marker
+ * Returns <tt>true</tt> if a velocity marker was set, otherwise <tt>false</tt>
+ *
+ * \param indexInInside Index of the cell-cell interface in this cell
+ */
bool haveVelocity(int indexInInside)
{
return velocityMarker_[indexInInside];
}
+ //!Resets the velocity marker
void resetVelocityMarker()
{
for (int i = 0; i < 2*dim; i++)
velocityMarker_[i] = false;
}
+ /*! \brief Checks for upwind direction
+ *Returns <tt>true</tt> if the cell is the upwind cell, otherwise <tt>false</tt>
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param indexInInside Index of the cell-cell interface in this cell
+ */
bool isUpwindCell(int phaseIdx, int indexInInside)
{
return (potential_[indexInInside][phaseIdx] >= 0.);
}
+ /*! \brief Checks for upwind direction
+ *Returns <tt>true</tt> if the cell is the upwind cell, otherwise <tt>false</tt>
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param indexInInside Index of the cell-cell interface in this cell
+ */
bool isUpwindCell(int phaseIdx, int indexInInside) const
{
return (potential_[indexInInside][phaseIdx] >= 0.);
}
+ /*! \brief Returns the phase potential at a cell-cell interface
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param indexInInside Index of the cell-cell interface in this cell
+ */
Scalar potential(int phaseIdx, int indexInInside)
{
return potential_[indexInInside][phaseIdx];
}
+ /*! \brief Returns the phase potential at a cell-cell interface
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param indexInInside Index of the cell-cell interface in this cell
+ */
Scalar potential(int phaseIdx, int indexInInside) const
{
return potential_[indexInInside][phaseIdx];
}
+ /*! \brief Sets the phase potential at a cell-cell interface
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param indexInInside Index of the cell-cell interface in this cell
+ * \param pot Phase potential which is stored
+ */
void setPotential(int phaseIdx, int indexInInside, Scalar pot)
{
potential_[indexInInside][phaseIdx] = pot;
}
+
+ /*! \brief Adds a phase potential to the one previously stored
+ *
+ * \param phaseIdx Index of a fluid phase
+ * \param indexInInside Index of the cell-cell interface in this cell
+ * \param pot Phase potential which is added
+ */
void addPotential(int phaseIdx, int indexInInside, Scalar pot)
{
potential_[indexInInside][phaseIdx] += pot;