Commit ff335816 authored by Markus Wolff's avatar Markus Wolff
Browse files

doxygen documentation + clean up



git-svn-id: svn://svn.iws.uni-stuttgart.de/DUMUX/dumux/trunk@4973 2fb0f335-1f38-0410-981e-8018bf24f1b0
parent 214fb590
......@@ -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
......
......@@ -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)
{
......
......@@ -35,7 +35,7 @@
/**
* @file
* @brief Single Phase Finite Volume Model
* @author Bernd Flemisch, Markus Wolff
* @author Markus Wolff
*/
namespace Dumux
......
......@@ -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();
......
......@@ -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
......
......@@ -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)
{
......
......@@ -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
......
......@@ -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()
{
......
......@@ -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>
......
......@@ -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
......
......@@ -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
{
......
......@@ -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>
......
......@@ -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)
......
......@@ -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>);
......
......@@ -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)
{
......
......@@ -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)
{
......
......@@ -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