From ff335816056675d76e6dca98ae41c426661b24e1 Mon Sep 17 00:00:00 2001
From: Markus Wolff <markus.wolff@twt-gmbh.de>
Date: Fri, 7 Jan 2011 15:21:30 +0000
Subject: [PATCH] doxygen documentation + clean up
git-svn-id: svn://svn.iws.uni-stuttgart.de/DUMUX/dumux/trunk@4973 2fb0f335-1f38-0410-981e-8018bf24f1b0
---
dumux/decoupled/1p/1pproperties.hh | 24 ++++-----
.../1p/diffusion/diffusionproblem1p.hh | 22 ++++++--
.../decoupled/1p/diffusion/fv/fvpressure1p.hh | 2 +-
.../decoupled/1p/diffusion/fv/fvvelocity1p.hh | 23 ++++----
dumux/decoupled/2p/2pproperties.hh | 26 ++++-----
.../2p/diffusion/diffusionproblem2p.hh | 18 ++++++-
.../decoupled/2p/diffusion/fv/fvpressure2p.hh | 10 ++--
.../decoupled/2p/diffusion/fv/fvvelocity2p.hh | 37 ++++---------
.../2p/diffusion/fvmpfa/fvmpfaopressure2p.hh | 17 +++---
.../2p/diffusion/fvmpfa/fvmpfaovelocity2p.hh | 5 ++
.../2p/diffusion/mimetic/mimeticpressure2p.hh | 7 +--
dumux/decoupled/2p/impes/impesproblem2p.hh | 4 +-
.../2p/transport/transportproblem2p.hh | 11 +++-
.../2p/transport/transportproperties.hh | 2 +-
dumux/decoupled/2p/variableclass2p.hh | 14 ++---
dumux/decoupled/common/impet.hh | 7 ++-
dumux/decoupled/common/impetproperties.hh | 18 +++----
dumux/decoupled/common/onemodelproblem.hh | 28 +++++-----
dumux/decoupled/common/variableclass.hh | 54 ++++++-------------
19 files changed, 172 insertions(+), 157 deletions(-)
diff --git a/dumux/decoupled/1p/1pproperties.hh b/dumux/decoupled/1p/1pproperties.hh
index e227b59ee6..945da2a693 100644
--- a/dumux/decoupled/1p/1pproperties.hh
+++ b/dumux/decoupled/1p/1pproperties.hh
@@ -58,7 +58,7 @@ namespace Properties
// Type tags
//////////////////////////////////////////////////////////////////
-//! The type tag for the two-phase problems
+//! The type tag for the single-phase problem
NEW_TYPE_TAG(DecoupledOneP, INHERITS_FROM(DecoupledModel));
//////////////////////////////////////////////////////////////////
@@ -74,31 +74,31 @@ NEW_PROP_TAG( Fluid )
//Properties for linear solvers
NEW_PROP_TAG(PressureCoefficientMatrix)
-;
+;//!< Type of the coefficient matrix given to the linear solver
NEW_PROP_TAG(PressureRHSVector)
-;
+;//!< Type of the right hand side vector given to the linear solver
NEW_PROP_TAG( PressurePreconditioner )
-;
+;//!< Type of the preconditioner
NEW_PROP_TAG( PressureSolver )
-;
+;//!< Type of the solver
NEW_PROP_TAG( SolverParameters )
-;
+;//!< Container for the solver parameters
NEW_PROP_TAG(ReductionSolver)
-;
+;//!< Reduction value for linear solver
NEW_PROP_TAG(MaxIterationNumberSolver)
-;
+;//!< Maximum iteration number for linear solver
NEW_PROP_TAG(IterationNumberPreconditioner)
-;
+;//!< Iteration number for preconditioner
NEW_PROP_TAG(VerboseLevelSolver)
-;
+;//!<Verbose level of linear solver and preconditioner
NEW_PROP_TAG(RelaxationPreconditioner)
-;
+;//!< Relaxation factor for preconditioner
//////////////////////////////////////////////////////////////////
// Properties
//////////////////////////////////////////////////////////////////
-SET_INT_PROP(DecoupledOneP, NumPhases, 1)
+SET_INT_PROP(DecoupledOneP, NumPhases, 1)//!< Single phase system
;
SET_INT_PROP(DecoupledOneP, NumComponents, 1); //!< Each phase consists of 1 pure component
diff --git a/dumux/decoupled/1p/diffusion/diffusionproblem1p.hh b/dumux/decoupled/1p/diffusion/diffusionproblem1p.hh
index c415c6a252..a4b817c904 100644
--- a/dumux/decoupled/1p/diffusion/diffusionproblem1p.hh
+++ b/dumux/decoupled/1p/diffusion/diffusionproblem1p.hh
@@ -21,7 +21,8 @@
*****************************************************************************/
/*!
* \file
- * \brief Base class for all single phase problems which use an impes algorithm
+ * \brief Base class for all single phase diffusion problem
+ * @author Markus Wolff
*/
#ifndef DUMUX_DIFFUSIONPROBLEM_1P_HH
#define DUMUX_DIFFUSIONPROBLEM_1P_HH
@@ -35,9 +36,10 @@ namespace Dumux
/*!
* \ingroup OnePhase
*
- * \brief Base class for all single phase problems which use an impes algorithm
+ * \brief Base class for all single phase diffusion problem
*
- * \todo Please doc me more!
+ * @tparam TypeTag The Type Tag
+ * @tparam Implementation The Problem implementation
*/
template<class TypeTag, class Implementation>
class DiffusionProblem1P: public OneModelProblem<TypeTag, Implementation>
@@ -59,6 +61,12 @@ class DiffusionProblem1P: public OneModelProblem<TypeTag, Implementation>
typedef Dune::FieldVector<Scalar, dimWorld> GlobalPosition;
public:
+ /*!
+ * \brief The constructor
+ *
+ * \param gridView The grid view
+ * \param verbose Output flag for the time manager.
+ */
DiffusionProblem1P(const GridView &gridView, bool verbose = true) :
ParentType(gridView, verbose), gravity_(0)
{
@@ -68,7 +76,13 @@ public:
if (GET_PROP_VALUE(TypeTag, PTAG(EnableGravity)))
gravity_[dim - 1] = -9.81;
}
-
+ /*!
+ * \brief The constructor
+ *
+ * \param gridView The grid view
+ * \param spatialParameters SpatialParameters instantiation
+ * \param verbose Output flag for the time manager.
+ */
DiffusionProblem1P(const GridView &gridView, SpatialParameters &spatialParameters, bool verbose = true) :
ParentType(gridView, verbose), gravity_(0), spatialParameters_(&spatialParameters)
{
diff --git a/dumux/decoupled/1p/diffusion/fv/fvpressure1p.hh b/dumux/decoupled/1p/diffusion/fv/fvpressure1p.hh
index 23a9ea4264..275ca97f3c 100644
--- a/dumux/decoupled/1p/diffusion/fv/fvpressure1p.hh
+++ b/dumux/decoupled/1p/diffusion/fv/fvpressure1p.hh
@@ -35,7 +35,7 @@
/**
* @file
* @brief Single Phase Finite Volume Model
- * @author Bernd Flemisch, Markus Wolff
+ * @author Markus Wolff
*/
namespace Dumux
diff --git a/dumux/decoupled/1p/diffusion/fv/fvvelocity1p.hh b/dumux/decoupled/1p/diffusion/fv/fvvelocity1p.hh
index 869616c687..16e38ef5f2 100644
--- a/dumux/decoupled/1p/diffusion/fv/fvvelocity1p.hh
+++ b/dumux/decoupled/1p/diffusion/fv/fvvelocity1p.hh
@@ -23,7 +23,7 @@
/**
* @file
- * @brief Finite Volume Diffusion Model
+ * @brief Single Phase Finite Volume Model
* @author Markus Wolff
*/
@@ -32,16 +32,14 @@
namespace Dumux
{
//! \ingroup OnePhase
-//! \brief Single Phase Finite Volume Diffusion Model
-/*! Calculates non-wetting phase velocities from a known pressure field in context of a Finite Volume implementation for the evaluation
+//! \brief Single Phase Finite Volume Model
+/*! Calculates velocities from a known pressure field in context of a Finite Volume implementation for the evaluation
* of equations of the form
- * \f[\text{div}\, \boldsymbol{v}_{total} = q.\f]
- * The wetting or the non-wetting phase pressure has to be given as piecewise constant cell values.
+ * \f[\text{div}\, \boldsymbol{v} = q.\f]
+ * The pressure has to be given as piecewise constant cell values.
* The velocity is calculated following Darcy's law as
- * \f[\boldsymbol{v}_n = \lambda_n \boldsymbol{K} \left(\text{grad}\, p_n + \rho_n g \text{grad}\, z\right),\f]
- * where, \f$p_n\f$ denotes the wetting phase pressure, \f$\boldsymbol{K}\f$ the absolute permeability, \f$\lambda_n\f$ the non-wetting phase mobility, \f$\rho_n\f$ the non-wetting phase density and \f$g\f$ the gravity constant.
- * As in the two-phase pressure equation a total flux depending on a total velocity is considered one has to be careful at neumann flux boundaries. Here, a phase velocity is only uniquely defined, if
- * the saturation is at the maximum (\f$1-S_{rw}\f$, \f$\boldsymbol{v}_{total} = \boldsymbol{v}_n\f$) or at the minimum (\f$ S_{rn} \f$, \f$\boldsymbol{v}_n = 0\f$)
+ * \f[\boldsymbol{v} = -\frac{1}{\mu} \boldsymbol{K} \left(\text{grad}\, p + \rho g \text{grad}\, z\right),\f]
+ * where, \f$p\f$ is the pressure, \f$\boldsymbol{K}\f$ the absolute permeability, \f$\mu\f$ the viscosity, \f$\rho\f$ the density and \f$g\f$ the gravity constant.
*
* @tparam TypeTag The Type Tag
*/
@@ -74,7 +72,7 @@ typedef typename GridView::Traits::template Codim<0>::Entity Element;
typedef Dune::FieldMatrix<Scalar,dim,dim> FieldMatrix;
public:
- //! Constructs a FVNonWettingPhaseVelocity2P object
+ //! The Constructor
/**
* \param problem a problem class object
*/
@@ -87,12 +85,11 @@ public:
/*!
*
* Given the piecewise constant pressure \f$p\f$,
- * this method calculates the velocity
- * The method is needed in the IMPES (Implicit Pressure Explicit Saturation) algorithm which is used for a fractional flow formulation
- * to provide the velocity field required for the solution of the saturation equation.
+ * this method calculates the velocity field
*/
void calculateVelocity();
+
void initialize()
{
ParentType::initialize();
diff --git a/dumux/decoupled/2p/2pproperties.hh b/dumux/decoupled/2p/2pproperties.hh
index ae72ba22a2..25a0b061ed 100644
--- a/dumux/decoupled/2p/2pproperties.hh
+++ b/dumux/decoupled/2p/2pproperties.hh
@@ -92,27 +92,27 @@ NEW_PROP_TAG( SaturationFormulation)
NEW_PROP_TAG( VelocityFormulation)
; //!< The formulation of the model
NEW_PROP_TAG( EnableCompressibility)
-;// ! Returns whether compressibility is allowed
+;// !< Returns whether compressibility is allowed
NEW_PROP_TAG( WettingPhase)
; //!< The wetting phase for two-phase models
NEW_PROP_TAG( NonwettingPhase)
; //!< The non-wetting phase for two-phase models
-NEW_PROP_TAG( FluidSystem )
+NEW_PROP_TAG( FluidSystem )//!< Defines the fluid system
;
-NEW_PROP_TAG( FluidState )
+NEW_PROP_TAG( FluidState )//!< Defines the fluid state
;
//Properties for linear solvers
-NEW_PROP_TAG(PressureCoefficientMatrix);
-NEW_PROP_TAG(PressureRHSVector);
-NEW_PROP_TAG( PressurePreconditioner );
-NEW_PROP_TAG( PressureSolver );
-NEW_PROP_TAG( SolverParameters );
-NEW_PROP_TAG(ReductionSolver);
-NEW_PROP_TAG(MaxIterationNumberSolver);
-NEW_PROP_TAG(IterationNumberPreconditioner);
-NEW_PROP_TAG(VerboseLevelSolver);
-NEW_PROP_TAG(RelaxationPreconditioner);
+NEW_PROP_TAG(PressureCoefficientMatrix);//!< Type of the coefficient matrix given to the linear solver
+NEW_PROP_TAG(PressureRHSVector);//!< Type of the right hand side vector given to the linear solver
+NEW_PROP_TAG( PressurePreconditioner );//!< Type of the pressure preconditioner
+NEW_PROP_TAG( PressureSolver );//!< Type of the pressure solver
+NEW_PROP_TAG( SolverParameters );//!< Container for the solver parameters
+NEW_PROP_TAG(ReductionSolver);//!< Reduction value for linear solver
+NEW_PROP_TAG(MaxIterationNumberSolver);//!< Maximum iteration number for linear solver
+NEW_PROP_TAG(IterationNumberPreconditioner);//!< Iteration number for preconditioner
+NEW_PROP_TAG(VerboseLevelSolver);//!<Verbose level of linear solver and preconditioner
+NEW_PROP_TAG(RelaxationPreconditioner);//!< Relaxation factor for preconditioner
//////////////////////////////////////////////////////////////////
// Properties
diff --git a/dumux/decoupled/2p/diffusion/diffusionproblem2p.hh b/dumux/decoupled/2p/diffusion/diffusionproblem2p.hh
index 24a6118dba..1a2354ee73 100644
--- a/dumux/decoupled/2p/diffusion/diffusionproblem2p.hh
+++ b/dumux/decoupled/2p/diffusion/diffusionproblem2p.hh
@@ -22,6 +22,7 @@
/*!
* \file
* \brief Base class for stationary sequential 2-phase problems
+ * @author Markus Wolff
*/
#ifndef DUMUX_DIFFUSIONPROBLEM_2P_HH
#define DUMUX_DIFFUSIONPROBLEM_2P_HH
@@ -38,7 +39,8 @@ namespace Dumux
* \ingroup Pressure2p
* \brief Base class for stationary sequential 2-phase problems
*
- * \todo Please doc me more!
+ * @tparam TypeTag The Type Tag
+ * @tparam Implementation The Problem implementation
*/
template<class TypeTag, class Implementation>
class DiffusionProblem2P: public OneModelProblem<TypeTag, Implementation>
@@ -64,6 +66,12 @@ class DiffusionProblem2P: public OneModelProblem<TypeTag, Implementation>
{}
public:
+ /*!
+ * \brief The constructor
+ *
+ * \param gridView The grid view
+ * \param verbose Output flag for the time manager
+ */
DiffusionProblem2P(const GridView &gridView, bool verbose = true) :
ParentType(gridView, verbose), gravity_(0)
{
@@ -73,7 +81,13 @@ public:
if (GET_PROP_VALUE(TypeTag, PTAG(EnableGravity)))
gravity_[dim - 1] = -9.81;
}
-
+ /*!
+ * \brief The constructor
+ *
+ * \param gridView The grid view
+ * \param spatialParameters SpatialParameters instantiation
+ * \param verbose Output flag for the time manager.
+ */
DiffusionProblem2P(const GridView &gridView, SpatialParameters &spatialParameters, bool verbose = true) :
ParentType(gridView, verbose), gravity_(0), spatialParameters_(&spatialParameters)
{
diff --git a/dumux/decoupled/2p/diffusion/fv/fvpressure2p.hh b/dumux/decoupled/2p/diffusion/fv/fvpressure2p.hh
index 035cf1be03..53814cd213 100644
--- a/dumux/decoupled/2p/diffusion/fv/fvpressure2p.hh
+++ b/dumux/decoupled/2p/diffusion/fv/fvpressure2p.hh
@@ -125,7 +125,7 @@ protected:
}
public:
-
+ //! updates and stores constitutive relations
void updateMaterialLaws();
//! \copydoc Dumux::FVPressure1P::initialize()
void initialize(bool solveTwice = true)
@@ -173,7 +173,7 @@ public:
return;
}
- //! What is this method here fore???
+ //! updates the pressure field (analog to update function in Dumux::IMPET)
void update()
{
updateMaterialLaws();
@@ -184,12 +184,14 @@ public:
}
// serialization methods
+ //! \copydoc Dumux::FVPressure1P::serialize(Restarter &res)
template<class Restarter>
void serialize(Restarter &res)
{
return;
}
+ //! \copydoc Dumux::FVPressure1P::deserialize(Restarter &res)
template<class Restarter>
void deserialize(Restarter &res)
{
@@ -277,8 +279,8 @@ private:
protected:
const Dune::FieldVector<Scalar, dimWorld>& gravity; //!< vector including the gravity constant
static const bool compressibility = GET_PROP_VALUE(TypeTag, PTAG(EnableCompressibility));
- static const int pressureType = GET_PROP_VALUE(TypeTag, PTAG(PressureFormulation)); //!< gives kind of pressure used (\f$ 0 = p_w\f$, \f$ 1 = p_n\f$, \f$ 2 = p_{global}\f$)
- static const int saturationType = GET_PROP_VALUE(TypeTag, PTAG(SaturationFormulation)); //!< gives kind of saturation used (\f$ 0 = S_w\f$, \f$ 1 = S_n\f$)
+ static const int pressureType = GET_PROP_VALUE(TypeTag, PTAG(PressureFormulation)); //!< gives kind of pressure used (\f$p_w\f$, \f$p_n\f$, \f$p_{global}\f$)
+ static const int saturationType = GET_PROP_VALUE(TypeTag, PTAG(SaturationFormulation)); //!< gives kind of saturation used (\f$S_w\f$, \f$S_n\f$)
};
//initializes the matrix to store the system of equations
diff --git a/dumux/decoupled/2p/diffusion/fv/fvvelocity2p.hh b/dumux/decoupled/2p/diffusion/fv/fvvelocity2p.hh
index 45ace5ba83..f3680c9ffe 100644
--- a/dumux/decoupled/2p/diffusion/fv/fvvelocity2p.hh
+++ b/dumux/decoupled/2p/diffusion/fv/fvvelocity2p.hh
@@ -36,12 +36,14 @@ namespace Dumux
/*! Calculates phase velocities or total velocity from a known pressure field in context of a Finite Volume implementation for the evaluation
* of equations of the form
* \f[\text{div}\, \boldsymbol{v}_{total} = q.\f]
- * The wetting or the non-wetting phase pressure has to be given as piecewise constant cell values.
- * The velocity is calculated following Darcy's law as
- * \f[\boldsymbol{v}_n = \lambda_n \boldsymbol{K} \left(\text{grad}\, p_n + \rho_n g \text{grad}\, z\right),\f]
- * where, \f$p_n\f$ denotes the wetting phase pressure, \f$\boldsymbol{K}\f$ the absolute permeability, \f$\lambda_n\f$ the non-wetting phase mobility, \f$\rho_n\f$ the non-wetting phase density and \f$g\f$ the gravity constant.
- * As in the two-phase pressure equation a total flux depending on a total velocity is considered one has to be careful at neumann flux boundaries. Here, a phase velocity is only uniquely defined, if
- * the saturation is at the maximum (\f$1-S_{rw}\f$, \f$\boldsymbol{v}_{total} = \boldsymbol{v}_n\f$) or at the minimum (\f$ S_{rn} \f$, \f$\boldsymbol{v}_n = 0\f$)
+ * The wetting or the non-wetting phase pressure, or the global pressure has to be given as piecewise constant cell values.
+ * The phase velocities are calculated following Darcy's law as
+ * \f[\boldsymbol{v}_\alpha = \lambda_\alpha \boldsymbol{K} \left(\text{grad}\, p_\alpha + \rho_\alpha g \text{grad}\, z\right),\f]
+ * where \f$p_\alpha\f$ denotes the pressure of phase \f$_\alpha\f$ (wetting or non-wetting), \f$\boldsymbol{K}\f$ the absolute permeability, \f$\lambda_\alpha\f$ the phase mobility, \f$\rho_\alpha\f$ the phase density and \f$g\f$ the gravity constant.
+ * The total velocity is either calculated as sum of the phase velocities
+ * \f[\boldsymbol{v}_{total} = \boldsymbol{v}_{wetting}+\boldsymbol{v}_{non-wetting},\f]
+ * or with a given global pressure
+ * \f[\boldsymbol{v}_{total} = \lambda_{total} \boldsymbol{K} \left(\text{grad}\, p_{global} + \sum f_\alpha \rho_\alpha g \text{grad}\, z\right).\f]
*
* \tparam TypeTag The Type Tag
*/
@@ -95,7 +97,7 @@ typedef typename GridView::Traits::template Codim<0>::Entity Element;
typedef Dune::FieldMatrix<Scalar,dim,dim> FieldMatrix;
public:
- //! Constructs a FVNonWettingPhaseVelocity2P object
+ //! Constructs a FVVelocity2P object
/*!
* \param problem a problem class object
*/
@@ -111,25 +113,6 @@ public:
DUNE_THROW(Dune::NotImplemented, "Velocity type not supported!");
}
}
- //! Constructs a FVNonWettingPhaseVelocity2P object
- /**
- * \param problem a problem class object
- * \param solverName a string giving the type of solver used (could be: CG, BiCGSTAB, Loop)
- * \param preconditionerName a string giving the type of the matrix preconditioner used (could be: Dune::SeqILU0, SeqPardiso)
- */
- FVVelocity2P(Problem& problem, std::string solverName,
- std::string preconditionerName)
- : FVPressure2P<TypeTag>(problem, solverName, preconditionerName)
- {
- if (GET_PROP_VALUE(TypeTag, PTAG(EnableCompressibility)) && velocityType_ == vt)
- {
- DUNE_THROW(Dune::NotImplemented, "Total velocity - global pressure - model cannot be used with compressible fluids!");
- }
- if (velocityType_ != vw && velocityType_ != vn && velocityType_ != vt)
- {
- DUNE_THROW(Dune::NotImplemented, "Velocity type not supported!");
- }
- }
//! Calculate the velocity.
/*!
@@ -212,7 +195,7 @@ public:
private:
static const int velocityType_ = GET_PROP_VALUE(TypeTag, PTAG(VelocityFormulation)); //!< gives kind of velocity used (\f$ 0 = v_w\f$, \f$ 1 = v_n\f$, \f$ 2 = v_t\f$)
};
-//! \copydoc Dumux::FVVelocity1P::calculateVelocity()
+
template<class TypeTag>
void FVVelocity2P<TypeTag>::calculateVelocity()
{
diff --git a/dumux/decoupled/2p/diffusion/fvmpfa/fvmpfaopressure2p.hh b/dumux/decoupled/2p/diffusion/fvmpfa/fvmpfaopressure2p.hh
index db83331768..48132a3253 100644
--- a/dumux/decoupled/2p/diffusion/fvmpfa/fvmpfaopressure2p.hh
+++ b/dumux/decoupled/2p/diffusion/fvmpfa/fvmpfaopressure2p.hh
@@ -58,10 +58,8 @@ namespace Dumux
* \f$p\f$ denotes the pressure, \f$K\f$ the absolute permeability,
* and \f$\lambda\f$ the total mobility, possibly depending on the
* saturation.
- Template parameters are:
-
- - GridView a DUNE gridView type
- - Scalar type used for return values
+ *
+ * \tparam TypeTag The Type Tag
*/
template<class TypeTag>
class FVMPFAOPressure2P
@@ -132,6 +130,7 @@ protected:
public:
//constitutive functions are initialized and stored in the variables object
+ //! updates and stores constitutive relations
void updateMaterialLaws();
void initialize(bool solveTwice = true)
@@ -145,12 +144,14 @@ public:
}
// serialization methods
+ //! \copydoc Dumux::FVPressure1P::serialize(Restarter &res)
template<class Restarter>
void serialize(Restarter &res)
{
return;
}
+ //! \copydoc Dumux::FVPressure1P::deserialize(Restarter &res)
template<class Restarter>
void deserialize(Restarter &res)
{
@@ -184,6 +185,7 @@ public:
return;
}
+ //! \copydoc Dumux::FVPressure1P::pressure()
void pressure(bool solveTwice = true)
{
// Dune::Timer timer;
@@ -199,7 +201,10 @@ public:
return;
}
-
+ //! Constructs a FVMPFAOPressure2P object
+ /**
+ * \param problem a problem class object
+ */
FVMPFAOPressure2P(Problem& problem)
: problem_(problem), A_(problem.variables().gridSize(), problem.variables().gridSize(), (4*dim+(dim-1))*problem.variables().gridSize(), Matrix::random),
f_(problem.variables().gridSize())
@@ -212,7 +217,7 @@ private:
Matrix A_;
Vector f_;
protected:
- static const int saturationType = GET_PROP_VALUE(TypeTag, PTAG(SaturationFormulation)); //!< gives kind of saturation used (\f$ 0 = S_w\f$, \f$ 1 = S_n\f$)
+ static const int saturationType = GET_PROP_VALUE(TypeTag, PTAG(SaturationFormulation)); //!< gives kind of saturation used (\f$S_w\f$, \f$S_n\f$)
};
template<class TypeTag>
diff --git a/dumux/decoupled/2p/diffusion/fvmpfa/fvmpfaovelocity2p.hh b/dumux/decoupled/2p/diffusion/fvmpfa/fvmpfaovelocity2p.hh
index 9c538c637e..294d81fa2b 100644
--- a/dumux/decoupled/2p/diffusion/fvmpfa/fvmpfaovelocity2p.hh
+++ b/dumux/decoupled/2p/diffusion/fvmpfa/fvmpfaovelocity2p.hh
@@ -84,11 +84,16 @@ template<class TypeTag> class FVMPFAOVelocity2P: public FVMPFAOPressure2P<TypeTa
typedef Dune::FieldVector<Scalar, dim> FieldVector;
public:
+ //! Constructs a FVMPFAOVelocity2P object
+ /*!
+ * \param problem a problem class object
+ */
FVMPFAOVelocity2P(Problem& problem) :
ParentType(problem)
{
}
+ //! \copydoc Dumux::FVVelocity2P::calculateVelocity()
void calculateVelocity();
}; // end of template
diff --git a/dumux/decoupled/2p/diffusion/mimetic/mimeticpressure2p.hh b/dumux/decoupled/2p/diffusion/mimetic/mimeticpressure2p.hh
index cf0128f405..57f4331964 100644
--- a/dumux/decoupled/2p/diffusion/mimetic/mimeticpressure2p.hh
+++ b/dumux/decoupled/2p/diffusion/mimetic/mimeticpressure2p.hh
@@ -59,12 +59,7 @@ namespace Dumux
* For all cases, \f$p = p_D\f$ on \f$\Gamma_{Neumann}\f$, and \f$\boldsymbol{v}_{total} = q_N\f$
* on \f$\Gamma_{Dirichlet}\f$.
*
- * Template parameters are:
- *
- - GridView a DUNE gridview type
- - Scalar type used for scalar quantities
- - VC type of a class containing different variables of the model
- - Problem class defining the physical problem
+ *\tparam TypeTag The Type Tag
*/
template<class TypeTag> class MimeticPressure2P
{
diff --git a/dumux/decoupled/2p/impes/impesproblem2p.hh b/dumux/decoupled/2p/impes/impesproblem2p.hh
index 3e6cb153e6..40e634c987 100644
--- a/dumux/decoupled/2p/impes/impesproblem2p.hh
+++ b/dumux/decoupled/2p/impes/impesproblem2p.hh
@@ -22,6 +22,7 @@
/*!
* \file
* \brief Base class for all 2-phase problems which use an impes algorithm
+ * @author Markus Wolff
*/
#ifndef DUMUX_IMPESPROBLEM_2P_HH
#define DUMUX_IMPESPROBLEM_2P_HH
@@ -40,7 +41,8 @@ namespace Dumux
* \ingroup IMPES
* \brief Base class for all 2-phase problems which use an impes algorithm
*
- * \todo Please doc me more!
+ * @tparam TypeTag The Type Tag
+ * @tparam Implementation The Problem implementation
*/
template<class TypeTag, class Implementation>
class IMPESProblem2P : public IMPETProblem<TypeTag, Implementation>
diff --git a/dumux/decoupled/2p/transport/transportproblem2p.hh b/dumux/decoupled/2p/transport/transportproblem2p.hh
index 9ff7b3d081..38949aebf6 100644
--- a/dumux/decoupled/2p/transport/transportproblem2p.hh
+++ b/dumux/decoupled/2p/transport/transportproblem2p.hh
@@ -22,6 +22,7 @@
/*!
* \file
* \brief Base class for all 2-phase transport problems which use an impes algorithm
+ * @author Markus Wolff
*/
#ifndef DUMUX_TRANSPORTPROBLEM_2P_HH
#define DUMUX_TRANSPORTPROBLEM_2P_HH
@@ -37,9 +38,10 @@ namespace Dumux
/*!
* \ingroup Saturation2p
* \ingroup IMPESproblems
- * \brief Base class for all 2-phase transport problems which use an impes algorithm
+ * \brief Base class for a decoupled 2-phase transport problem
*
- * \todo Please doc me more!
+ * @tparam TypeTag The Type Tag
+ * @tparam Implementation The Problem implementation
*/
template<class TypeTag, class Implementation>
class TransportProblem2P : public OneModelProblem<TypeTag, Implementation>
@@ -70,6 +72,11 @@ class TransportProblem2P : public OneModelProblem<TypeTag, Implementation>
{}
public:
+ /*!
+ * \brief The constructor
+ *
+ * \param gridView The grid view
+ */
TransportProblem2P(const GridView &gridView)
: ParentType(gridView),
gravity_(0),spatialParameters_(gridView)
diff --git a/dumux/decoupled/2p/transport/transportproperties.hh b/dumux/decoupled/2p/transport/transportproperties.hh
index 4f687f660d..1a71d59986 100644
--- a/dumux/decoupled/2p/transport/transportproperties.hh
+++ b/dumux/decoupled/2p/transport/transportproperties.hh
@@ -80,7 +80,7 @@ NEW_PROP_TAG( EnableCompressibility );
NEW_PROP_TAG( PressureFormulation );
NEW_PROP_TAG( SaturationFormulation );
NEW_PROP_TAG( VelocityFormulation );
-NEW_PROP_TAG( EvalCflFluxFunction );
+NEW_PROP_TAG( EvalCflFluxFunction ); //!< Type of the evaluation of the CFL-condition
NEW_PROP_TAG( CFLFactor );
SET_TYPE_PROP(Transport, DiffusivePart, DiffusivePart<TypeTag>);
diff --git a/dumux/decoupled/2p/variableclass2p.hh b/dumux/decoupled/2p/variableclass2p.hh
index bc9133e534..532828fdca 100644
--- a/dumux/decoupled/2p/variableclass2p.hh
+++ b/dumux/decoupled/2p/variableclass2p.hh
@@ -34,18 +34,15 @@
namespace Dumux
{
/*!
- * \ingroup Immiscible IMPES
+ * \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.
*
- * Template parameters are:
-
- - GridView a DUNE gridview type
- - Scalar type used for scalar quantities
- */
+ * @tparam TypeTag The Type Tag
+1*/
template<class TypeTag>
class VariableClass2P: public VariableClass<TypeTag>
{
@@ -137,22 +134,26 @@ public:
}
// serialization methods
+ //! Function needed for restart option.
template<class Restarter>
void serialize(Restarter &res)
{
res.template serializeEntities<0> (*this, this->gridView());
}
+ //! Function needed for restart option.
template<class Restarter>
void deserialize(Restarter &res)
{
res.template deserializeEntities<0> (*this, this->gridView());
}
+ //! Function needed for restart option.
void serializeEntity(std::ostream &outstream, const Element &element)
{
int globalIdx = this->elementMapper().map(element);
outstream << this->pressure()[globalIdx] << " " << saturation_[globalIdx];
}
+ //! Function needed for restart option.
void deserializeEntity(std::istream &instream, const Element &element)
{
int globalIdx = this->elementMapper().map(element);
@@ -190,6 +191,7 @@ private:
public:
//Write saturation and pressure into file
+ //! adds variables to output
template<class MultiWriter>
void addOutputVtkFields(MultiWriter &writer)
{
diff --git a/dumux/decoupled/common/impet.hh b/dumux/decoupled/common/impet.hh
index a37842e979..ec486f0351 100644
--- a/dumux/decoupled/common/impet.hh
+++ b/dumux/decoupled/common/impet.hh
@@ -34,7 +34,7 @@ namespace Dumux
{
/**
* \ingroup IMPET
- * \brief IMplicit Pressure Explicit Transport (IMPET) scheme for the solution of weakly coupled diffusion/transport problems.
+ * \brief IMplicit Pressure Explicit Transport (IMPET) scheme for the solution of weakly coupled diffusion-transport formulations.
*
* The model implements the decoupled equations of two-phase flow.
* These equations can be derived from the two-phase flow equations shown for the two-phase box model (TwoPBoxModel).
@@ -46,6 +46,8 @@ namespace Dumux
* second the transport equation can be solved explicitly. This solution procedure is called IMPES algorithm
* (IMplicit Pressure Explicit Saturation) for immiscible flow or IMPEC algorithm
* (IMplicit Pressure Explicit Concentration) for miscible flow.
+ *
+ * \tparam TypeTag The Type Tag
*/
template<class TypeTag> class IMPET
{
@@ -188,11 +190,14 @@ public:
}
// serialization methods
+ //! Function needed for restart option.
template<class Restarter>
void serialize(Restarter &res)
{
problem.variables().serialize<Restarter> (res);
}
+
+ //! Function needed for restart option.
template<class Restarter>
void deserialize(Restarter &res)
{
diff --git a/dumux/decoupled/common/impetproperties.hh b/dumux/decoupled/common/impetproperties.hh
index 73c0c17986..674ad0a7b5 100644
--- a/dumux/decoupled/common/impetproperties.hh
+++ b/dumux/decoupled/common/impetproperties.hh
@@ -56,22 +56,22 @@ NEW_TYPE_TAG(IMPET, INHERITS_FROM(DecoupledModel));
// Property tags
//////////////////////////////////////////////////////////////////
-NEW_PROP_TAG(PressureModel); //!< The type of the discretizations
-NEW_PROP_TAG(TransportModel); //!< The type of the discretizations
+NEW_PROP_TAG(PressureModel); //!< The type of the discretization
+NEW_PROP_TAG(TransportModel); //!< The type of the discretization
-NEW_PROP_TAG(CFLFactor);
-NEW_PROP_TAG(IterationFlag);
-NEW_PROP_TAG(IterationNumber);
-NEW_PROP_TAG(MaximumDefect);
-NEW_PROP_TAG(RelaxationFactor);
+NEW_PROP_TAG(CFLFactor); //!< Scalar factor for additional scaling of the time step
+NEW_PROP_TAG(IterationFlag); //!< Flag to switch the iteration type of the IMPET scheme
+NEW_PROP_TAG(IterationNumber); //!< Number of iterations if IMPET iterations are enabled by the IterationFlags
+NEW_PROP_TAG(MaximumDefect); //!< Maximum Defect if IMPET iterations are enabled by the IterationFlags
+NEW_PROP_TAG(RelaxationFactor); //!< Used for IMPET iterations
SET_TYPE_PROP(IMPET, Model, IMPET<TypeTag>);
SET_SCALAR_PROP(IMPET, CFLFactor, 1);
-SET_INT_PROP(IMPET, IterationFlag, 0);
+SET_INT_PROP(IMPET, IterationFlag, 0); //!< 0 = no iterations, 1 = iterate IterationNumber iterations, 2 = iterate until converged or IterationNumber is reached
SET_INT_PROP(IMPET, IterationNumber, 2);
SET_SCALAR_PROP(IMPET, MaximumDefect, 1e-5);
-SET_SCALAR_PROP(IMPET, RelaxationFactor, 1);
+SET_SCALAR_PROP(IMPET, RelaxationFactor, 1);//!< 1 = new solution is new solution, 0 = old solution is new solution
}
}
diff --git a/dumux/decoupled/common/onemodelproblem.hh b/dumux/decoupled/common/onemodelproblem.hh
index 6aacba2fff..92a2e217d0 100644
--- a/dumux/decoupled/common/onemodelproblem.hh
+++ b/dumux/decoupled/common/onemodelproblem.hh
@@ -31,8 +31,8 @@
/**
* @file
- * @brief Base class for defining an instance of the diffusion problem
- * @author Bernd Flemisch
+ * @brief Base class for definition of an decoupled diffusion (pressure) or transport problem
+ * @author Markus Wolff
*/
namespace Dumux
@@ -40,16 +40,7 @@ namespace Dumux
/*! \ingroup IMPET
*
- * @brief base class that defines the parameters of loosely coupled diffusion and transport equations
- *
- * An interface for defining parameters for the stationary diffusion equation
- * \f[\text{div}\, \boldsymbol{v} = q\f]
- * and a scalar transport equation
- * \f[
- * \frac{\partial S}{\partial t} + \text{div}\, \boldsymbol{v_\alpha} = 0,
- * \f]
- * where, the velocity \f$\boldsymbol{v} \sim \boldsymbol{K} \nabla p \f$,
- * \f$p\f$ is a pressure and q a source/sink term, \f$S\f$ denotes a phase saturation and \f$\boldsymbol{v_\alpha}\f$ is a phase velocity.
+ * @brief Base class for definition of an decoupled diffusion (pressure) or transport problem
*
* @tparam TypeTag The Type Tag
*/
@@ -142,6 +133,13 @@ public:
void preTimeStep()
{ };
+ /*!
+ * \brief Called by Dumux::TimeManager in order to do a time
+ * integration on the model.
+ */
+ void timeIntegration()
+ { };
+
/*!
* \brief Called by Dumux::TimeManager whenever a solution for a
* timestep has been computed and the simulation time has
@@ -291,9 +289,15 @@ public:
const TimeManager &timeManager() const
{ return timeManager_; }
+ /*!
+ * \brief Returns variables object.
+ */
Variables& variables ()
{ return variables_; }
+ /*!
+ * \brief \copybrief Dumux::OneModelProblem::variables()
+ */
const Variables& variables () const
{ return variables_; }
diff --git a/dumux/decoupled/common/variableclass.hh b/dumux/decoupled/common/variableclass.hh
index 50ff5890d3..201f6060d4 100644
--- a/dumux/decoupled/common/variableclass.hh
+++ b/dumux/decoupled/common/variableclass.hh
@@ -38,10 +38,13 @@ namespace Dumux
/*!
* \ingroup Sequential
*/
-//! Class holding the variables and discretized data for sequential models.
+//! Base class holding the variables and discretized data for sequential models.
/*!
- * For multi-phase flow, the common variable in all sequential models is the saturation, stored in this class.
- * Additionally, general access to grids and serialize methods is prepared.
+ * Stores global information and variables that are common for all sequential models and also functions needed to access these variables.
+ * Can be directly used for a single phase model.
+ *
+ * @tparam TypeTag The Type Tag
+ *
*/
template<class TypeTag>
class VariableClass
@@ -115,31 +118,38 @@ public:
}
// serialization methods
+ //! Function needed for restart option.
template<class Restarter>
void serialize(Restarter &res)
{
res.template serializeEntities<0> (*this, gridView_);
}
+
+ //! Function needed for restart option.
template<class Restarter>
void deserialize(Restarter &res)
{
res.template deserializeEntities<0> (*this, gridView_);
}
+ //! Function needed for restart option.
void serializeEntity(std::ostream &outstream, const Element &element)
{
int globalIdx = elementMapper_.map(element);
outstream << pressure_[globalIdx];
}
+
+ //! Function needed for restart option.
void deserializeEntity(std::istream &instream, const Element &element)
{
int globalIdx = elementMapper_.map(element);
instream >> pressure_[globalIdx];
}
- void initializePotentials(Dune::FieldVector<Scalar, dim>& initialVel)
+ //! initializes the potential differences stored at the element faces.
+ void initializePotentials(Dune::FieldVector<Scalar, dim>& initialPot)
{
- if (initialVel.two_norm())
+ if (initialPot.two_norm())
{
// compute update vector
ElementIterator eItEnd = gridView_.template end<0> ();
@@ -157,7 +167,7 @@ public:
Dune::FieldVector<Scalar, dimWorld> unitOuterNormal = isIt->centerUnitOuterNormal();
- for (int i = 0; i < numPhase; i++) {potential_[globalIdxI][indexInInside][i] = initialVel * unitOuterNormal;}
+ for (int i = 0; i < numPhase; i++) {potential_[globalIdxI][indexInInside][i] = initialPot * unitOuterNormal;}
}
}
}
@@ -179,39 +189,9 @@ private:
//initialise variables
pressure_ = 0;
velocity_ = initialVel;
+ initializePotentials(initialVel);
}
-// void initializePotentials(Dune::FieldVector<Scalar, dim>& initialVel)
-// {
-// if (initialVel.two_norm())
-// {
-// // compute update vector
-// ElementIterator eItEnd = gridView_.template end<0> ();
-// for (ElementIterator eIt = gridView_.template begin<0> (); eIt != eItEnd; ++eIt)
-// {
-// // cell index
-// int globalIdxI = elementMapper_.map(*eIt);
-//
-// // run through all intersections with neighbors and boundary
-// IntersectionIterator isItEnd = gridView_.iend(*eIt);
-// for (IntersectionIterator isIt = gridView_.ibegin(*eIt); isIt != isItEnd; ++isIt)
-// {
-// // local number of facet
-// int indexInInside = isIt->indexInInside();
-//
-// Dune::FieldVector<Scalar, dimWorld> unitOuterNormal = isIt->centerUnitOuterNormal();
-//
-// for (int i = 0; i < numPhase; i++) {potential_[globalIdxI][indexInInside][i] = initialVel * unitOuterNormal;}
-// }
-// }
-// }
-// else
-// {
-// potential_ = Dune::FieldVector<Scalar, numPhase> (0);
-// }
-// return;
-// }
-
//Write saturation and pressure into file
template<class MultiWriter>
void addOutputVtkFields(MultiWriter &writer)
--
GitLab