From 3b0cf4d2f5b89b6a28b5c34f62879efdb7e351c2 Mon Sep 17 00:00:00 2001
From: Markus Wolff <markus.wolff@twt-gmbh.de>
Date: Tue, 21 Feb 2012 09:09:47 +0000
Subject: [PATCH] improved doxygen documentation
git-svn-id: svn://svn.iws.uni-stuttgart.de/DUMUX/dumux/trunk@7834 2fb0f335-1f38-0410-981e-8018bf24f1b0
---
.../2p/transport/fv/capillarydiffusion.hh | 31 ++---
.../2p/transport/fv/convectivepart.hh | 44 +++----
.../2p/transport/fv/diffusivepart.hh | 69 +++++-----
.../decoupled/2p/transport/fv/evalcflflux.hh | 40 +++---
.../2p/transport/fv/evalcflflux_coats.hh | 47 +++++--
.../2p/transport/fv/evalcflflux_default.hh | 33 ++++-
.../2p/transport/fv/fvsaturation2p.hh | 121 ++++++++++++++----
.../transport/fv/fvtransportproperties2p.hh | 18 +--
.../decoupled/2p/transport/fv/gravitypart.hh | 35 ++---
.../2p/transport/transportproblem2p.hh | 7 +-
.../2p/transport/transportproperties2p.hh | 2 +-
11 files changed, 274 insertions(+), 173 deletions(-)
diff --git a/dumux/decoupled/2p/transport/fv/capillarydiffusion.hh b/dumux/decoupled/2p/transport/fv/capillarydiffusion.hh
index 3bedb180e8..bd7d546113 100644
--- a/dumux/decoupled/2p/transport/fv/capillarydiffusion.hh
+++ b/dumux/decoupled/2p/transport/fv/capillarydiffusion.hh
@@ -32,17 +32,19 @@
*/
namespace Dumux
{
-/*!\ingroup Saturation2p
- * @brief Class for defining the diffusive capillary pressure term of a saturation equation
+/*!\ingroup FVSaturation2p
+ * \brief Class for defining the diffusive capillary pressure term of a saturation equation
*
* Defines the diffusive capillary pressure term of the form
*
- * \f[\bar \lambda \boldsymbol{K} \text{grad} \, p_c,\f]
+ * \f[
+ * \bar \lambda \boldsymbol K \text{grad} \, p_c,
+ * \f]
*
- * where \f$\bar \lambda = \lambda_w f_n = \lambda_n f_w\f$ and \f$\lambda\f$ is a phase mobility and \f$f\f$ a phase fractional flow function,
- * \f$\boldsymbol{K}\f$ is the intrinsic permeability and \f$p_c = p_c(S_w) \f$ the capillary pressure.
+ * where \f$ \bar \lambda = \lambda_w f_n = \lambda_n f_w \f$ and \f$ \lambda \f$ is a phase mobility and \f$ f \f$ a phase fractional flow function,
+ * \f$ \boldsymbol K \f$ is the intrinsic permeability and \f$ p_c = p_c(S_w) \f$ the capillary pressure.
*
- * @tparam TypeTag The Type Tag
+ * \tparam TypeTag The Type Tag
*/
template<class TypeTag>
class CapillaryDiffusion: public DiffusivePart<TypeTag>
@@ -81,12 +83,11 @@ private:
public:
//! Returns capillary diffusion term
/*! Returns capillary diffusion term for current element face
- * @param[in] element entity of codim 0
- * @param[in] indexInInside face index in reference element
- * @param[in] satI saturation of current element
- * @param[in] satJ saturation of neighbor element
- * @param[in] pcGradient gradient of capillary pressure between element I and J
- * \return capillary pressure term of the saturation equation
+ * \param flux Flux vector (gets the flux from the function)
+ * \param intersection Intersection of two grid elements/global boundary
+ * \param satI saturation of current element
+ * \param satJ saturation of neighbor element
+ * \param pcGradient gradient of capillary pressure between element I and J
*/
void getFlux (FieldVector& flux, const Intersection& intersection, Scalar satI, Scalar satJ, const FieldVector& pcGradient) const
{
@@ -209,9 +210,9 @@ public:
flux *= mobBar;
}
- /*! @brief Constructs a CapillaryDiffusion object
- * @param problem an object of class Dumux::TransportProblem or derived
- * @param preComput if preCompute = true previous calculated mobilities are taken, if preCompute = false new mobilities will be computed (for implicit Scheme)
+ /*! \brief Constructs a CapillaryDiffusion object
+ *
+ * \param problem A problem class object
*/
CapillaryDiffusion (Problem& problem)
: DiffusivePart<TypeTag>(problem), problem_(problem), preComput_(GET_PROP_VALUE(TypeTag, PrecomputedConstRels))
diff --git a/dumux/decoupled/2p/transport/fv/convectivepart.hh b/dumux/decoupled/2p/transport/fv/convectivepart.hh
index 077a9fa0aa..59ec527c8a 100644
--- a/dumux/decoupled/2p/transport/fv/convectivepart.hh
+++ b/dumux/decoupled/2p/transport/fv/convectivepart.hh
@@ -25,20 +25,19 @@
#include <dumux/decoupled/2p/2pproperties.hh>
/**
- * @file
- * @brief Base class for defining a convective part of an advection-diffusion equation
- * @author Markus Wolff
+ * \file
+ * \brief Base class for defining a convective part of the saturation transport equation
+ * \author Markus Wolff
*/
namespace Dumux
{
-/*!\ingroup Saturation2p
- * @brief Base class for defining the convective part of an advection-diffusion equation
+/*!\ingroup FVSaturation2p
+ * \brief Base class for defining a convective part of the saturation transport equation
*
- * @tparam TypeTag The Type Tag
+ * \tparam TypeTag The problem TypeTag
*/
-
template<class TypeTag>
class ConvectivePart
{
@@ -53,38 +52,33 @@ private:
typedef Dune::FieldVector<Scalar, dimWorld> FieldVector;
public:
- //! Returns convective term
- /*! Returns convective term for current element face
- * @param[in] element entity of codim 0
- * @param[in] indexInInside face index in reference element
- * @param[in] sat saturation of current element
- * \return convective term of an advection-diffusion equation
+ /*! \brief Returns convective term for current element face
+ * \param intersection Intersection of two grid elements/global boundary
+ * \param sat Saturation of current element
+ * \return Convective flux
*/
Scalar getFlux(const Intersection& intersection, const Scalar sat) const
{
return 0.0;
}
- //! Returns convective term
- /*! Returns convective term for current element face
- * @param[in] element entity of codim 0
- * @param[in] indexInInside face index in reference element
- * @param[in] satI saturation of current element
- * @param[in] satJ saturation of neighbor element
- * \return convective term of an advection-diffusion equation
+
+ /*! \brief Returns convective term for current intersection
+ *
+ * \param flux Flux vector (gets the flux from the function)
+ * \param intersection Intersection of two grid elements/global boundary
+ * \param satI Saturation of current element
+ * \param satJ Saturation of neighbor element
*/
void getFlux(FieldVector& flux, const Intersection& intersection, const Scalar satI, const Scalar satJ) const
{}
- //! The constructor
+ //! Constructs a ConvectivePart object
/*
- * \param problem object including the problem definition
+ * \param problem A problem class object
*/
ConvectivePart(Problem& problem)
{}
- //! always define virtual destructor in abstract base class
- virtual ~ConvectivePart()
- { }
};
}
diff --git a/dumux/decoupled/2p/transport/fv/diffusivepart.hh b/dumux/decoupled/2p/transport/fv/diffusivepart.hh
index 3eaa1e61d0..da262e5609 100644
--- a/dumux/decoupled/2p/transport/fv/diffusivepart.hh
+++ b/dumux/decoupled/2p/transport/fv/diffusivepart.hh
@@ -26,16 +26,16 @@
#include <dumux/decoupled/2p/transport/transportproperties2p.hh>
/**
- * @file
- * @brief Base class for defining the diffusive part of an advection-diffusion equation
- * @author Bernd Flemisch, Markus Wolff
+ * \file
+ * \brief Base class for defining a diffusive part of the saturation transport equation
+ * \author Bernd Flemisch, Markus Wolff
*/
namespace Dumux
{
-/*!\ingroup Saturation2p
- * @brief Base class for defining the diffusive part of an advection-diffusion equation
+/*!\ingroup FVSaturation2p
+ * \brief Base class for defining the diffusive part of the saturation transport equation
*
- * @tparam TypeTag The Type Tag
+ * \tparam TypeTag The problem TypeTag
*/
template<class TypeTag>
class DiffusivePart
@@ -51,41 +51,38 @@ private:
typedef Dune::FieldVector<Scalar, dim> FieldVector;
public:
- //! Returns diffusive term
- /*! Returns diffusive term for current element face
- * @param[in] element entity of codim 0
- * @param[in] indexInInside face index in reference element
- * @param[in] satI saturation of current element
- * @param[in] satJ saturation of neighbor element
- * @param[in] pcGradient gradient of capillary pressure between element I and J
- * \return diffusive term of an advection-diffusion equation
+ /*! \brief Returns diffusive term for current element face
+ *
+ * \param flux Flux vector (gets the flux from the function)
+ * \param intersection Intersection of two grid elements/global boundary
+ * \param satI saturation of current element
+ * \param satJ saturation of neighbor element
+ * \param pcGradient gradient of capillary pressure between element I and J
*/
void getFlux(FieldVector& flux, const Intersection& intersection, Scalar satI, Scalar satJ, const FieldVector& pcGradient) const
{}
- //! Returns diffusive term
- /*! Returns diffusive term for current element face
- * @param[in] element entity of codim 0
- * @param[in] indexInInside face index in reference element
- * @param[in] satIntersection saturation at the face between element I and J
- * @param[in] satGradient gradient of saturation between element I and J
- * @param[in] time time
- * \return diffusive term of an advection-diffusion equation
+ /*! \brief Returns diffusive term for current element face
+ *
+ * \param flux Flux vector (gets the flux from the function)
+ * \param intersection Intersection of two grid elements/global boundary
+ * \param satIntersection saturation at the face between element I and J
+ * \param satGradient gradient of saturation between element I and J
+ * \param time time
*/
void getFlux(FieldVector& flux, const Intersection& intersection,
const Scalar satIntersection, const FieldVector& satGradient, const Scalar time) const
{}
- //! Returns diffusive term
- /*! Returns diffusive term for current element face
- * @param[in] element entity of codim 0
- * @param[in] indexInInside face index in reference element
- * @param[in] satIntersection saturation at the face between element I and J
- * @param[in] satGradient gradient of saturation between element I and J
- * @param[in] time time
- * @param[in] satI saturation of current element
- * @param[in] satJ saturation of neighbor element
- * \return diffusive term of an advection-diffusion equation
+ /*! \brief Returns diffusive term for current element face
+ *
+ * \param flux Flux vector (gets the flux from the function)
+ * \param intersection Intersection of two grid elements/global boundary
+ * \param satIntersection saturation at the face between element I and J
+ * \param satGradient gradient of saturation between element I and J
+ * \param time time
+ * \param satI saturation of current element
+ * \param satJ saturation of neighbor element
*/
void getFlux(FieldVector& flux, const Intersection& intersection,
const Scalar satIntersection, const FieldVector& satGradient, const Scalar time,
@@ -93,15 +90,13 @@ public:
{}
- //! The constructor
+ //! Constructs a DiffusivePart object
/*
- * \param problem object including the problem definition
+ * \param A problem class object
*/
DiffusivePart(Problem& problem)
{}
- //! always define virtual destructor in abstract base class
- ~DiffusivePart()
- { }
+
};
}
diff --git a/dumux/decoupled/2p/transport/fv/evalcflflux.hh b/dumux/decoupled/2p/transport/fv/evalcflflux.hh
index 0edfeb68ec..2ac478bc72 100644
--- a/dumux/decoupled/2p/transport/fv/evalcflflux.hh
+++ b/dumux/decoupled/2p/transport/fv/evalcflflux.hh
@@ -31,22 +31,25 @@
*/
namespace Dumux
{
-/*!\ingroup Saturation2p
+/*!\ingroup IMPES
+ * \ingroup Saturation2p
* @brief Base class for implementations of different kinds of fluxes to evaluate a CFL-Condition
*
* Base class for implementations of different kinds of fluxes to evaluate a CFL-Condition of the form
*
- * \f[\frac{F_i \Delta t}{V_{p_i}} < 1\f]
+ * \f[
+ * \frac{F_i \Delta t}{V_{p_i}} < 1
+ * \f]
*
* where \f$ V_{p_i} \f$ is the pore volume of cell i and
*
- * \f[F_i = \sum f_{ij}\f]
+ * \f[
+ * F_i = \sum f_{ij}
+ * \f]
*
- * with \f$f_{ij}\f$ being the CFL-flux over edge \f$ij\f$.
+ * with \f$ f_{ij} \f$ being the CFL-flux over edge \f$ ij \f$.
*
- * Template parameters are:
-
- - TypeTag PropertyTag of the problem implementation
+ * \tparam TypeTag The problem TypeTag
*/
template<class TypeTag>
class EvalCflFlux
@@ -65,8 +68,9 @@ private:
typedef Dune::FieldVector<Scalar, dimWorld> GlobalPosition;
public:
- //! adds a flux to the cfl-criterion evaluation
- /*!
+
+ /*! \brief adds a flux to the cfl-criterion evaluation
+ *
* \param lambdaW wetting phase mobility
* \param lambdaNW non-wetting phase mobility
* \param viscosityW wetting phase viscosity
@@ -78,8 +82,8 @@ public:
void addFlux(Scalar& lambdaW, Scalar& lambdaNW, Scalar& viscosityW, Scalar& viscosityNW, Scalar flux, const Intersection& intersection, int phaseIdx)
{}
- //! adds a flux to the cfl-criterion evaluation
- /*!
+ /*! \brief adds a flux to the cfl-criterion evaluation
+ *
* \param lambdaW wetting phase mobility
* \param lambdaNW non-wetting phase mobility
* \param viscosityW wetting phase viscosity
@@ -91,22 +95,20 @@ public:
void addFlux(Scalar& lambdaW, Scalar& lambdaNW, Scalar& viscosityW, Scalar& viscosityNW, Scalar flux, const Element& element, int phaseIdx)
{}
- //! adds a flux to the cfl-criterion evaluation
- /*!
- * \param globalPos global position
+ /*! \brief Returns the CFL flux-function
+ *
* \param element element on which the CFL-criterion is evaluated
- * \return fluxFunction for the calculation of the CFL-time step (\f$ 1/F_i\f$)
+ * \return fluxFunction for the calculation of the CFL time-step (\f$ 1/F_i \f$)
*/
Scalar getCFLFluxFunction(const Element& element)
{
return 0.0;
}
- //! adds a flux to the cfl-criterion evaluation
- /*!
- * \param globalPos global position
+ /*! \brief Returns the CFL time-step
+ *
* \param element element on which the CFL-criterion is evaluated
- * \return fluxFunction for the calculation of the CFL-time step (\f$ 1/F_i\f$)
+ * \return CFL time-step
*/
Scalar getDt(const Element& element)
{
diff --git a/dumux/decoupled/2p/transport/fv/evalcflflux_coats.hh b/dumux/decoupled/2p/transport/fv/evalcflflux_coats.hh
index f2b08d50ef..3c485d8e39 100644
--- a/dumux/decoupled/2p/transport/fv/evalcflflux_coats.hh
+++ b/dumux/decoupled/2p/transport/fv/evalcflflux_coats.hh
@@ -32,13 +32,10 @@
namespace Dumux
{
-/*!\ingroup Saturation2p
+/*!\ingroup IMPES
* @brief CFL-flux-function to evaluate a CFL-Condition after Coats 2003
*
- *
- * Template parameters are:
-
- - TypeTag PropertyTag of the problem implementation
+ * tparam TypeTag The problem TypeTag
*/
template<class TypeTag>
class EvalCflFluxCoats: public EvalCflFluxDefault<TypeTag>
@@ -92,6 +89,10 @@ private:
public:
+ /*! \brief adds a flux to the cfl-criterion evaluation
+ *
+ * \copydetails EvalCflFlux::addFlux(Scalar&,Scalar&,Scalar&,Scalar&,Scalar,const Element&,int)
+ */
void addFlux(Scalar& lambdaW, Scalar& lambdaNW, Scalar& viscosityW, Scalar& viscosityNW, Scalar flux,
const Element& element, int phaseIdx = -1)
{
@@ -103,6 +104,10 @@ public:
ParentType::addFlux(lambdaW, lambdaNW, viscosityW, viscosityNW, flux, element, phaseIdx);
}
+ /*! \brief adds a flux to the cfl-criterion evaluation
+ *
+ * \copydetails EvalCflFlux::addFlux(Scalar&,Scalar&,Scalar&,Scalar&,Scalar,const Intersection&,int)
+ */
void addFlux(Scalar& lambdaW, Scalar& lambdaNW, Scalar& viscosityW, Scalar& viscosityNW, Scalar flux,
const Intersection& intersection, int phaseIdx = -1)
{
@@ -426,9 +431,13 @@ public:
}
}
- Scalar getCflFluxFunction(const Element& element)
+ /*! \brief Returns the CFL flux-function
+ *
+ * \copydetails EvalCflFlux::getCFLFluxFunction(const Element&)
+ */
+ Scalar getCFLFluxFunction(const Element& element)
{
- Scalar cflFluxDefault = 1 / ParentType::getCflFluxFunction(element);
+ Scalar cflFluxDefault = 1 / ParentType::getCFLFluxFunction(element);
if (std::isnan(cflFluxFunction_) || std::isinf(cflFluxFunction_) || cflFluxFunction_ > 100 * cflFluxDefault)
{
@@ -452,11 +461,27 @@ public:
return 1e100;
}
+ /*! \brief Returns the CFL time-step
+ *
+ * \copydetails EvalCflFlux::getDt(const Element&)
+ */
Scalar getDt(const Element& element)
{
- return getCflFluxFunction(element) * problem_.spatialParameters().porosity(element) * element.geometry().volume();
+ return getCFLFluxFunction(element) * problem_.spatialParameters().porosity(element) * element.geometry().volume();
+ }
+
+ /*! \brief Constructs an EvalCflFluxDefault object
+ *
+ * \param problem A problem type object
+ */
+ EvalCflFluxCoats(Problem& problem) :
+ ParentType(problem), problem_(problem), eps_(5e-3)
+ {
+ reset();
}
+protected:
+ //! resets the accumulated CFL-fluxes to zero
void reset()
{
ParentType::reset();
@@ -464,12 +489,6 @@ public:
hasHangingNode_ = false;
}
- EvalCflFluxCoats(Problem& problem) :
- ParentType(problem), problem_(problem), eps_(5e-3)
- {
- reset();
- }
-
private:
diff --git a/dumux/decoupled/2p/transport/fv/evalcflflux_default.hh b/dumux/decoupled/2p/transport/fv/evalcflflux_default.hh
index e809c23d10..fbde841009 100644
--- a/dumux/decoupled/2p/transport/fv/evalcflflux_default.hh
+++ b/dumux/decoupled/2p/transport/fv/evalcflflux_default.hh
@@ -32,14 +32,12 @@
namespace Dumux
{
-/*!\ingroup Saturation2p
+/*!\ingroup IMPES
* @brief Default implementation of cfl-fluxes to evaluate a CFL-Condition
*
* Compares the maximum of inflow and outflow to the element volume weighted by relative permeability and viscosity ratios.
*
- * Template parameters are:
-
- - TypeTag PropertyTag of the problem implementation
+ * \tparam TypeTag The problem TypeTag
*/
template<class TypeTag>
class EvalCflFluxDefault: public EvalCflFlux<TypeTag>
@@ -80,23 +78,43 @@ private:
public:
+ /*! \brief adds a flux to the cfl-criterion evaluation
+ *
+ * \copydetails EvalCflFlux::addFlux(Scalar&,Scalar&,Scalar&,Scalar&,Scalar,const Element&,int)
+ */
void addFlux(Scalar& lambdaW, Scalar& lambdaNW, Scalar& viscosityW, Scalar& viscosityNW, Scalar flux, const Element& element, int phaseIdx = -1)
{
addFlux(lambdaW, lambdaNW, viscosityW, viscosityNW, flux, phaseIdx);
}
+ /*! \brief adds a flux to the cfl-criterion evaluation
+ *
+ * \copydetails EvalCflFlux::addFlux(Scalar&,Scalar&,Scalar&,Scalar&,Scalar,const Intersection&,int)
+ */
void addFlux(Scalar& lambdaW, Scalar& lambdaNW, Scalar& viscosityW, Scalar& viscosityNW, Scalar flux, const Intersection& intersection, int phaseIdx = -1)
{
addFlux(lambdaW, lambdaNW, viscosityW, viscosityNW, flux, phaseIdx);
}
- Scalar getCflFluxFunction(const Element& element);
+ /*! \brief Returns the CFL flux-function
+ *
+ * \copydetails EvalCflFlux::getCFLFluxFunction(const Element&)
+ */
+ Scalar getCFLFluxFunction(const Element& element);
+ /*! \brief Returns the CFL time-step
+ *
+ * \copydetails EvalCflFlux::getDt(const Element&)
+ */
Scalar getDt(const Element& element)
{
- return (getCflFluxFunction(element) * problem_.spatialParameters().porosity(element) * element.geometry().volume());
+ return (getCFLFluxFunction(element) * problem_.spatialParameters().porosity(element) * element.geometry().volume());
}
+ /*! \brief Constructs an EvalCflFluxDefault object
+ *
+ * \param problem A problem type object
+ */
EvalCflFluxDefault (Problem& problem)
: problem_(problem)
{
@@ -213,8 +231,9 @@ private:
static const int saturationType_ = GET_PROP_VALUE(TypeTag, SaturationFormulation);
};
+// Returns the CFL flux-function
template<class TypeTag>
-typename EvalCflFluxDefault<TypeTag>::Scalar EvalCflFluxDefault<TypeTag>::getCflFluxFunction(const Element& element)
+typename EvalCflFluxDefault<TypeTag>::Scalar EvalCflFluxDefault<TypeTag>::getCFLFluxFunction(const Element& element)
{
Scalar residualSatW = problem_.spatialParameters().materialLawParams(element).Swr();
Scalar residualSatNW = problem_.spatialParameters().materialLawParams(element).Snr();
diff --git a/dumux/decoupled/2p/transport/fv/fvsaturation2p.hh b/dumux/decoupled/2p/transport/fv/fvsaturation2p.hh
index 24d474bf1c..03a0d26691 100644
--- a/dumux/decoupled/2p/transport/fv/fvsaturation2p.hh
+++ b/dumux/decoupled/2p/transport/fv/fvsaturation2p.hh
@@ -33,22 +33,35 @@
namespace Dumux
{
-//! \ingroup Saturation2p
+//! \ingroup FVSaturation2p
//! \brief The finite volume discretization of a saturation transport equation
/*! Provides a Finite Volume implementation for the evaluation
* of equations of the form
*
- * \f[\frac{\partial S_\alpha}{\partial t} + \text{div}\, \boldsymbol{v_\alpha} = q_\alpha,\f]
+ * \f[
+ * \phi \frac{\partial (\rho_\alpha S_\alpha)}{\partial t} + \text{div}\, (\rho_\alpha \boldsymbol{v_\alpha}) = q_\alpha,
+ * \f]
*
- * where \f$S_\alpha\f$ is the saturation of phase alpha (wetting (w), non-wetting (n)) and \f$\boldsymbol{v}_\alpha\f$ is the phase velocity calculated by the multi-phase Darcy equation,
- * and of the form
+ * where \f$ S_\alpha \f$ is the saturation of phase alpha (wetting (\f$ w \f$), non-wetting (\f$ n \f$)) and \f$ \boldsymbol v_\alpha \f$ is the phase velocity defined by the multi-phase Darcy equation.
+ * If a phase velocity is reconstructed from the pressure solution it can be directly inserted in the previous equation. In the incompressible case the equation is further divided by the phase density \f$ \rho_\alpha \f$. If a total velocity is reconstructed the saturation equation is reformulated into:
*
- * \f[\frac{\partial S_w}{\partial t} + f_w \text{div}\, \boldsymbol{v}_{t} + f_w \lambda_n \boldsymbol{K}\left(\text{grad}\, p_c + (\rho_n-\rho_w) g \text{grad} z \right)= q_\alpha,\f]
+ * \f[
+ * \phi \frac{\partial S_w}{\partial t} + f_w \text{div}\, \boldsymbol{v}_{t} + f_w \lambda_n \boldsymbol{K}\left(\text{grad}\, p_c + (\rho_n-\rho_w) g \text{grad} z \right)= q_\alpha,
+ * \f]
+ * to get a wetting phase saturation or
+ * \f[
+ * \phi \frac{\partial S_n}{\partial t} + f_n \text{div}\, \boldsymbol{v}_{t} - f_n \lambda_w \boldsymbol{K}\left(\text{grad}\, p_c + (\rho_n-\rho_w) g \text{grad} z \right)= q_\alpha,
+ * \f]
+ * if the non-wetting phase saturation is the primary transport variable.
*
- * \f[\frac{\partial S_n}{\partial t} + f_n \text{div}\, \boldsymbol{v}_{t} - f_n \lambda_w \boldsymbol{K}\left(\text{grad}\, p_c + (\rho_n-\rho_w) g \text{grad} z \right)= q_\alpha,\f]
+ * The total velocity formulation is only implemented for incompressible fluids and \f$ f_\alpha \f$ is the fractional flow function, \f$ \lambda_\alpha \f$ is the mobility, \f$ \boldsymbol K \f$ the absolute permeability,
+ * \f$ p_c \f$ the capillary pressure, \f$ \rho \f$ the fluid density, \f$ g \f$ the gravity constant, and \f$ q \f$ the source term.
*
- * where \f$f_\alpha\f$ is the fractional flow function, \f$\lambda_\alpha\f$ is the mobility, \f$\boldsymbol{K}\f$ the absolute permeability,
- * \f$p_c\f$ the capillary pressure, \f$\rho\f$ the fluid density, \f$g\f$ the gravity constant, and \f$q\f$ the source term.
+ *
+ * In the IMPES models the default setting is:
+ *
+ * - formulation: \f$ p_w-S_w \f$ (Property: <tt>Formulation</tt> defined as <tt>DecoupledTwoPCommonIndices::pwSw</tt>)
+ * - compressibility: disabled (Property: <tt>EnableCompressibility</tt> set to <tt>false</tt>)
*
* \tparam TypeTag The Type Tag
*/
@@ -150,22 +163,27 @@ class FVSaturation2P: public FVTransport<TypeTag>
}
public:
+ // Function which calculates the flux update
void getFlux(Scalar& update, const Intersection& intersection, CellData& cellDataI);
+ // Function which calculates the boundary flux update
void getFluxOnBoundary(Scalar& update, const Intersection& intersection, CellData& cellDataI);
+ // Function which calculates the source update
void getSource(Scalar& update, const Element& element, CellData& cellDataI);
- //! Sets the initial solution \f$S_0\f$.
+ // Sets the initial solution
void initialize();
- //! Update the values of the material laws and constitutive relations.
- /*!
- * Constitutive relations like capillary pressure-saturation relationships, mobility-saturation relationships... are updated and stored in the variable class
- * of type Dumux::VariableClass2P. The update has to be done when new saturation are available.
- */
+ // Update the values of the material laws and constitutive relations.
void updateMaterialLaws();
+
+ /* \brief Writes the current values of the primary transport variable into the <tt>transportedQuantity</tt>-vector (comes as function argument)
+ *
+ * \copydetails FVTransport::getTransportedQuantity(TransportSolutionType&)
+ *
+ */
void getTransportedQuantity(TransportSolutionType& transportedQuantity)
{
int size = problem_.gridView().size(0);
@@ -188,6 +206,10 @@ public:
}
}
+ /*! \brief Updates the primary transport variable.
+ *
+ * \copydetails FVTransport::updateTransportedQuantity(TransportSolutionType&)
+ */
void updateTransportedQuantity(TransportSolutionType& updateVec)
{
updateSaturationSolution(updateVec);
@@ -195,6 +217,10 @@ public:
// std::cout<<"update = "<<updateVec<<"\n";
}
+ /*! \brief Globally updates the saturation solution
+ *
+ * \param updateVec Vector containing the global update.
+ */
void updateSaturationSolution(TransportSolutionType& updateVec)
{
Scalar dt = problem_.timeManager().timeStepSize();
@@ -205,6 +231,14 @@ public:
}
}
+ /*! \brief Updates the saturation solution of a cell
+ *
+ * Calculates secondary saturation variables and stores saturations.
+ *
+ * \param globalIdx Global cell index
+ * \param update Cell saturation update
+ * \param dt Current time step
+ */
void updateSaturationSolution(int globalIdx, Scalar update, Scalar dt)
{
CellData& cellData = problem_.variables().cellData(globalIdx);
@@ -230,8 +264,14 @@ public:
}
}
- //! \brief Write data files
- /* \param name file name */
+ /*! \brief Adds saturation output to the output file
+ *
+ * Adds the phase saturation to the output. If the velocity is calculated in the transport model it is also added to the output.
+ *
+ * \tparam MultiWriter Class defining the output writer
+ * \param writer The output writer (usually a <tt>VTKMultiWriter</tt> object)
+ *
+ */
template<class MultiWriter>
void addOutputVtkFields(MultiWriter &writer)
{
@@ -255,10 +295,11 @@ public:
return;
}
- /*! \name general methods for serialization, output */
- //@{
- // serialization methods
- //! Function needed for restart option.
+ /*! \brief Function for serialization of the primary transport variable.
+ *
+ *\copydetails FVTransport::serializeEntity(std::ostream&,const Element&)
+ *
+ */
void serializeEntity(std::ostream &outstream, const Element &element)
{
int globalIdx = problem_.variables().index(element);
@@ -277,6 +318,11 @@ public:
outstream << sat;
}
+ /*! \brief Function for deserialization of the primary transport variable.
+ *
+ *\copydetails FVTransport::deserializeEntity(std::istream&,const Element&)
+ *
+ */
void deserializeEntity(std::istream &instream, const Element &element)
{
int globalIdx = problem_.variables().index(element);
@@ -296,14 +342,12 @@ public:
break;
}
}
- //@}
- //! Constructs a FVSaturation2P object
- /**
- * \param problem a problem class object
+ /*! \brief Constructs a FVSaturation2P object
+ *
+ * \param problem A problem class object
*/
-
FVSaturation2P(Problem& problem) :
ParentType(problem), problem_(problem), threshold_(1e-6), switchNormals_(GET_PARAM(TypeTag, bool, SwitchNormals))
{
@@ -345,6 +389,7 @@ public:
}
}
+ //! Destructor
~FVSaturation2P()
{
delete capillaryFlux_;
@@ -370,6 +415,13 @@ private:
const bool switchNormals_;
};
+/*! \brief Function which calculates the flux update
+ *
+ * \copydetails FVTransport::getFlux(Scalar&,const Intersection&,CellData&)
+ *
+ * If a total velocity formulation is used this functions calculates not only the advective flux but also fluxes due to gravity and capillary diffusion.
+ * These have to be defined separately as implementation of a DiffusivePart or ConvectivePart (e.g. GravityPart / CapillaryDiffusion ) and added to the property system via properties <tt>CapillaryFlux</tt> and <tt>GravityFlux</tt>.
+ */
template<class TypeTag>
void FVSaturation2P<TypeTag>::getFlux(Scalar& update, const Intersection& intersection, CellData& cellDataI)
{
@@ -549,6 +601,13 @@ void FVSaturation2P<TypeTag>::getFlux(Scalar& update, const Intersection& inters
}
}
+/*! \brief Function which calculates the boundary flux update
+ *
+ * \copydetails FVTransport::getFluxOnBoundary(Scalar&,const Intersection&,CellData&)
+ *
+ * Dirichlet boundary condition is a phase saturation depending on the formulation (\f$ S_w \f$ (default) or \f$ S_n \f$),
+ * Neumann boundary condition are phase mass fluxes (\f$ q_w \f$ (default) or \f$ q_n \f$ [\f$\text{kg}/(\text{m}^2 \text{s}\f$])
+ */
template<class TypeTag>
void FVSaturation2P<TypeTag>::getFluxOnBoundary(Scalar& update, const Intersection& intersection, CellData& cellDataI)
{
@@ -838,6 +897,12 @@ void FVSaturation2P<TypeTag>::getFluxOnBoundary(Scalar& update, const Intersecti
}
}
+/*! \brief Function which calculates the source update
+ *
+ *\copydetails FVTransport::getSource(Scalar&,const Element&,CellData&)
+ *
+ * Source of the fluid phase has to be defined as mass flux (\f$\text{kg}/(\text{m}^3 \text{s}\f$).
+ */
template<class TypeTag>
void FVSaturation2P<TypeTag>::getSource(Scalar& update, const Element& element, CellData& cellDataI)
{
@@ -916,6 +981,7 @@ void FVSaturation2P<TypeTag>::getSource(Scalar& update, const Element& element,
}
}
+//! Sets the initial solution \f$ S_0 \f$.
template<class TypeTag>
void FVSaturation2P<TypeTag>::initialize()
{
@@ -951,6 +1017,11 @@ void FVSaturation2P<TypeTag>::initialize()
return;
}
+/*! \brief Updates constitutive relations and stores them in the variable class
+ *
+ * Stores mobility, fractional flow function and capillary pressure for all grid cells.
+ *
+ */
template<class TypeTag>
void FVSaturation2P<TypeTag>::updateMaterialLaws()
{
diff --git a/dumux/decoupled/2p/transport/fv/fvtransportproperties2p.hh b/dumux/decoupled/2p/transport/fv/fvtransportproperties2p.hh
index a88157fde1..0379c80ace 100644
--- a/dumux/decoupled/2p/transport/fv/fvtransportproperties2p.hh
+++ b/dumux/decoupled/2p/transport/fv/fvtransportproperties2p.hh
@@ -25,7 +25,7 @@
#include <dumux/decoupled/2p/transport/transportproperties2p.hh>
/*!
- * \ingroup Saturation2p
+ * \ingroup FVSaturation2p
* \ingroup Properties
*/
/*!
@@ -42,13 +42,13 @@ namespace Properties
// Type tags tags
//////////////////////////////////////////////////////////////////
-//! The type tag for models based on the diffusion-scheme
+//! The type tag for two-phase problems using a standard finite volume model
NEW_TYPE_TAG(FVTransportTwoP, INHERITS_FROM(TransportTwoP));
//////////////////////////////////////////////////////////////////
// Property tags
//////////////////////////////////////////////////////////////////
-NEW_PROP_TAG( PrecomputedConstRels );
+NEW_PROP_TAG( PrecomputedConstRels );//! < Bool property which tells the transport model if it should use constitutive relations which are precomputed at the begin of the time step or if it should recompute the relations
}
}
@@ -61,16 +61,16 @@ namespace Dumux
{
namespace Properties
{
+//! Set the default implementation of the cfl-condition
SET_TYPE_PROP(FVTransportTwoP, EvalCflFluxFunction, EvalCflFluxDefault<TypeTag>);
+//! Set the default implementation of a diffusive flux -> diffusive flux dissabled
SET_TYPE_PROP(FVTransportTwoP, CapillaryFlux, DiffusivePart<TypeTag>);
+//! Set the default implementation of an additional convective flux -> additional convective flux dissabled
SET_TYPE_PROP(FVTransportTwoP, GravityFlux, ConvectivePart<TypeTag>);
+//! \brief Set PrecomputedConstRels flag <tt>true</tt> as default
SET_BOOL_PROP( FVTransportTwoP, PrecomputedConstRels, true);
-
-// Set the model properties
-SET_PROP(FVTransportTwoP, TransportModel)
-{
- typedef Dumux::FVSaturation2P<TypeTag> type;
-};
+//! Set finite volume implementation of the two-phase saturation equation as default saturation model
+SET_TYPE_PROP(FVTransportTwoP, TransportModel, Dumux::FVSaturation2P<TypeTag>);
}
}
diff --git a/dumux/decoupled/2p/transport/fv/gravitypart.hh b/dumux/decoupled/2p/transport/fv/gravitypart.hh
index 1101e09874..6f0c1955d7 100644
--- a/dumux/decoupled/2p/transport/fv/gravitypart.hh
+++ b/dumux/decoupled/2p/transport/fv/gravitypart.hh
@@ -27,23 +27,25 @@
/**
* @file
- * @brief Class for defining the gravity term of a saturation equation
+ * @brief Class for defining the gravity term of a two-phase flow saturation equation
* @author Markus Wolff
*/
namespace Dumux
{
-/*!\ingroup Saturation2p
- * @brief Class for defining the gravity term of a saturation equation
+/*!\ingroup FVSaturation2p
+ * \brief Class for defining the gravity term of a two-phase flow saturation equation
*
* Defines the gravity term of the form
*
- * \f[\bar \lambda \boldsymbol{K} \, (\rho_n - \rho_w) \, g \, \text{grad} \, z,\f]
+ * \f[
+ * \bar \lambda \boldsymbol K \, (\rho_n - \rho_w) \, g \, \text{grad} \, z,
+ * \f]
*
- * where \f$\bar \lambda = \lambda_w f_n = \lambda_n f_w\f$ and \f$\lambda\f$ is a phase mobility and \f$f\f$ a phase fractional flow function,
- * \f$ \boldsymbol{K} \f$ is the intrinsic permeability, \f$\rho\f$ is a phase density and \f$g\f$ is the gravity constant.
+ * where \f$ \bar \lambda = \lambda_w f_n = \lambda_n f_w \f$ and \f$ \lambda \f$ is a phase mobility and \f$ f \f$ a phase fractional flow function,
+ * \f$ \boldsymbol K \f$ is the intrinsic permeability, \f$ \rho \f$ is a phase density and \f$ g \f$ is the gravity constant.
*
- * @tparam TypeTag The Type Tag
+ * \tparam TypeTag The Type Tag
*/
template<class TypeTag>
class GravityPart: public ConvectivePart<TypeTag>
@@ -79,13 +81,12 @@ private:
typedef Dune::FieldMatrix<Scalar,dim,dim> FieldMatrix;
public:
- //! Returns the gravity term
- /*! Returns convective term for current element face
- * @param[in] element entity of codim 0
- * @param[in] indexInInside face index in reference element
- * @param[in] satI saturation of current element
- * @param[in] satJ saturation of neighbor element
- * \return gravity term of a saturation equation
+ /*! \brief Returns convective term for current element face
+ *
+ * \param flux Flux vector (gets the flux from the function)
+ * \param intersection Intersection of two grid elements/global boundary
+ * \param satI saturation of current element
+ * \param satJ saturation of neighbor element
*/
void getFlux(FieldVector& flux, const Intersection& intersection, const Scalar satI, const Scalar satJ) const
{
@@ -172,9 +173,9 @@ public:
flux *= lambdaW*lambdaNW/(lambdaW+lambdaNW);
flux *= (density_[wPhaseIdx] - density_[nPhaseIdx]);
}
- /*! @brief Constructs a GravityPart object
- * @param problem an object of class Dumux::TransportProblem or derived
- * @param preComput if preCompute = true previous calculated mobilities are taken, if preCompute = false new mobilities will be computed (for implicit Scheme)
+ /*! \brief Constructs a GravityPart object
+ *
+ * \param problem A problem class object
*/
GravityPart (Problem& problem)
: ConvectivePart<TypeTag>(problem), problem_(problem), preComput_(GET_PROP_VALUE(TypeTag, PrecomputedConstRels))
diff --git a/dumux/decoupled/2p/transport/transportproblem2p.hh b/dumux/decoupled/2p/transport/transportproblem2p.hh
index 5206e6c1be..a99b7fac43 100644
--- a/dumux/decoupled/2p/transport/transportproblem2p.hh
+++ b/dumux/decoupled/2p/transport/transportproblem2p.hh
@@ -22,7 +22,7 @@
*****************************************************************************/
/*!
* \file
- * \brief Base class for all 2-phase transport problems which use an impes algorithm
+ * \brief Base class for two-phase transport problems
* @author Markus Wolff
*/
#ifndef DUMUX_TRANSPORTPROBLEM_2P_HH
@@ -47,10 +47,9 @@ SET_TYPE_PROP(TransportTwoP, Velocity, VelocityDefault<TypeTag>); //this Propert
/*!
* \ingroup Saturation2p
* \ingroup IMPETproblems
- * \brief Base class for a decoupled 2-phase transport problem
+ * \brief Base class for a decoupled two-phase transport problem
*
- * @tparam TypeTag The Type Tag
- * @tparam Implementation The Problem implementation
+ * @tparam TypeTag The problem Type Tag
*/
template<class TypeTag>
class TransportProblem2P : public OneModelProblem<TypeTag>
diff --git a/dumux/decoupled/2p/transport/transportproperties2p.hh b/dumux/decoupled/2p/transport/transportproperties2p.hh
index 82d40abd38..288545be09 100644
--- a/dumux/decoupled/2p/transport/transportproperties2p.hh
+++ b/dumux/decoupled/2p/transport/transportproperties2p.hh
@@ -43,7 +43,7 @@ namespace Properties
// Type tags tags
//////////////////////////////////////////////////////////////////
-//! The type tag for models based on the diffusion-scheme
+//! The type tag for transport part of a decoupled two-phase model
NEW_TYPE_TAG(TransportTwoP, INHERITS_FROM(Transport, DecoupledTwoP));
//////////////////////////////////////////////////////////////////
--
GitLab