diff --git a/doc/doxygen/modules.txt b/doc/doxygen/modules.txt
index e5f2e1980047ca76ac1c0ff62902bb762536f89d..e5585c0d3b4795ab5820af17a560b53df00c6605 100644
--- a/doc/doxygen/modules.txt
+++ b/doc/doxygen/modules.txt
@@ -235,37 +235,36 @@
/* ***************** Discretization ******************/
/*!
* \defgroup Discretization Discretization schemes
+ * \brief The discretization schemes available in DuMu<sup>x</sup>
*/
/*!
* \ingroup Discretization
- * \defgroup BoxDiscretization Box finite volume scheme
+ * \defgroup BoxDiscretization Box FV scheme
*
- * \copydetails ./discretization/box/properties.hh
+ * \brief The box method is a collocated finite volume scheme with control volumes centered at grid nodes
*/
/*!
* \ingroup Discretization
- * \defgroup CCDiscretization Cell-centered finite volume scheme
- * # Tpfa
- * \copybrief ./discretization/cellcentered/tpfa/properties.hh
- * # Mpfa
- * \copybrief ./discretization/cellcentered/mpfa/properties.hh
+ * \defgroup CCDiscretization Cell-centered FV scheme
+ * \brief Finite volume schemes with degrees of freedom located at grid cell centers
*/
/*!
* \ingroup CCDiscretization
- * \defgroup CCTpfaDiscretization Cell-centered finite volume scheme with two-point flux-approximuation (Tpfa)
+ * \defgroup CCTpfaDiscretization Two-point flux approximation (Tpfa)
*
- * \copydetails ./discretization/cellcentered/tpfa/properties.hh
+ * \brief A cell-centered finite volume scheme with two-point flux approximation
*/
/*!
* \ingroup CCDiscretization
- * \defgroup CCMpfaDiscretization Cell-centered finite volume scheme with multi-point flux-approximuation (Mpfa)
+ * \defgroup CCMpfaDiscretization Multi-point flux approximation (Mpfa)
*
- * \copydetails ./discretization/cellcentered/mpfa/properties.hh
+ * \brief A cell-centered finite volume scheme with multi-point flux approximation
*/
/*!
* \ingroup Discretization
- * \defgroup StaggeredDiscretization Staggered finite volume scheme
- * \copydetails ./discretization/staggered/properties.hh
+ * \defgroup StaggeredDiscretization Staggered FV scheme
+ *
+ * \brief A staggered finite volume scheme with degrees of freedom at cell-centers and facets
*/
/* ***************** Material ******************/
diff --git a/dumux/discretization/basefvgridgeometry.hh b/dumux/discretization/basefvgridgeometry.hh
index 8a674d44125a44c5d69ecefed46ebf448de673c4..6e5064f9058683e22659ad8800b4f455e0ff56e5 100644
--- a/dumux/discretization/basefvgridgeometry.hh
+++ b/dumux/discretization/basefvgridgeometry.hh
@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
+ * \ingroup Discretization
* \brief Base class for all finite volume grid geometries
*/
#ifndef DUMUX_DISCRETIZATION_BASE_FV_GRID_GEOMETRY_HH
@@ -35,7 +36,7 @@ namespace Dumux
{
/*!
- * \ingroup ImplicitModel
+ * \ingroup Discretization
* \brief Base class for all finite volume grid geometries
*/
template<class TypeTag>
@@ -56,7 +57,7 @@ class BaseFVGridGeometry
using GlobalPosition = Dune::FieldVector<CoordScalar, dimWorld>;
public:
- //! Constructor
+ //! Constructor computes the bouding box of the entire domain, for e.g. setting boundary conditions
BaseFVGridGeometry(const GridView& gridView)
: gridView_(gridView)
#if DUNE_VERSION_NEWER(DUNE_COMMON,2,6)
@@ -69,13 +70,12 @@ public:
, bBoxMin_(std::numeric_limits<double>::max())
, bBoxMax_(-std::numeric_limits<double>::max())
{
- //! Compute the bouding box of the entire domain, for e.g. setting boundary conditions
computeGlobalBoundingBox_();
}
/*!
- * \brief Return a local restriction of this global object
- * The local object is only functional after calling its bind/bindElement method
+ * \brief Return a local restriction of this global object.
+ * The local object is only functional after calling its bind/bindElement method.
* This is a free function that will be found by means of ADL
*/
friend inline FVElementGeometry localView(const Implementation& fvGridGeometry)
@@ -99,7 +99,7 @@ public:
}
/*!
- * \brief Return the gridView this global object lives on
+ * \brief Return the gridView this grid geometry object lives on
*/
const GridView& gridView() const
{ return gridView_; }
@@ -196,20 +196,20 @@ private:
}
}
- // the process grid view
+ //! the process grid view
const GridView gridView_;
- // entity mappers
+ //! entity mappers
ElementMapper elementMapper_;
VertexMapper vertexMapper_;
- // the bounding box tree of the grid view for effecient element intersections
+ //! the bounding box tree of the grid view for effecient element intersections
mutable std::unique_ptr<BoundingBoxTree> boundingBoxTree_;
- // a map from element index to elements (needed in the bounding box tree and for assembling cell-centered discretization)
+ //! a map from element index to elements (needed in the bounding box tree and for assembling cell-centered discretization)
mutable std::shared_ptr<ElementMap> elementMap_;
- // the bounding box of the whole domain
+ //! the bounding box of the whole domain
GlobalPosition bBoxMin_;
GlobalPosition bBoxMax_;
};
diff --git a/dumux/discretization/cellcentered/connectivitymap.hh b/dumux/discretization/cellcentered/connectivitymap.hh
index 5c69551e779f3e361c2753411ba21e616d9d84ff..efca535243efd8066a8ee7abbabf31981083fb74 100644
--- a/dumux/discretization/cellcentered/connectivitymap.hh
+++ b/dumux/discretization/cellcentered/connectivitymap.hh
@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
+ * \ingroup CCDiscretization
* \brief Stores the face indices corresponding to the neighbors of an element
* that contribute to the derivative calculation. This is used for
* finite-volume schemes with symmetric sparsity pattern in the global matrix.
@@ -34,7 +35,7 @@ namespace Dumux
{
/*!
- * \ingroup CellCentered
+ * \ingroup CCDiscretization
* \brief A simple version of the connectivity map for cellcentered schemes.
* This implementation works for schemes in which for a given cell I only
* those cells J have to be prepared in whose stencil the cell I appears.
diff --git a/dumux/discretization/cellcentered/elementboundarytypes.hh b/dumux/discretization/cellcentered/elementboundarytypes.hh
index 82baa1e88e80d829309a077c97fb946ef01ae227..188439bb480e030a0e8b624ee9b78b0174ab6928 100644
--- a/dumux/discretization/cellcentered/elementboundarytypes.hh
+++ b/dumux/discretization/cellcentered/elementboundarytypes.hh
@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
+ * \ingroup CCDiscretization
* \brief Boundary types gathered on an element
*/
#ifndef DUMUX_CC_ELEMENT_BOUNDARY_TYPES_HH
@@ -29,8 +30,9 @@ namespace Dumux
{
/*!
- * \ingroup CCModel
- * \brief This class exists only for compatibility purposes with the
+ * \ingroup CCDiscretization
+ * \brief Boundary types gathered on an element
+ * \note This class exists only for compatibility purposes with the
* box scheme. The cell-centered schemes and the box scheme use
* a common base local residual, which passes an ElementBoundaryTypes
* object to the implemented interfaces.
diff --git a/dumux/discretization/cellcentered/elementsolution.hh b/dumux/discretization/cellcentered/elementsolution.hh
index 6cc65557f0720cb197086bccbc1b225d19a8b0fb..1ab481db9b31b871b7dc260d41b6ac01c635e7fb 100644
--- a/dumux/discretization/cellcentered/elementsolution.hh
+++ b/dumux/discretization/cellcentered/elementsolution.hh
@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
+ * \ingroup CCDiscretization
* \brief The local element solution class for cell-centered methods
*/
#ifndef DUMUX_CC_ELEMENT_SOLUTION_HH
@@ -30,7 +31,7 @@ namespace Dumux
{
/*!
- * \ingroup CCModel
+ * \ingroup CCDiscretization
* \brief The element solution vector
*/
template<class TypeTag>
@@ -46,7 +47,6 @@ class CCElementSolution
public:
using PrimaryVariables = typename GET_PROP_TYPE(TypeTag, PrimaryVariables);
- //! Default constructors
CCElementSolution() = default;
//! Constructor with element and solution
diff --git a/dumux/discretization/cellcentered/gridvolumevariables.hh b/dumux/discretization/cellcentered/gridvolumevariables.hh
index e1322345f3289538caefbec56c5546308c1f9bc8..9f970c2c4bef5f5e44998500d90a19f688984241 100644
--- a/dumux/discretization/cellcentered/gridvolumevariables.hh
+++ b/dumux/discretization/cellcentered/gridvolumevariables.hh
@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
+ * \ingroup CCDiscretization
* \brief The grid volume variables class for cell centered models
*/
#ifndef DUMUX_DISCRETIZATION_CC_GRID_VOLUMEVARIABLES_HH
@@ -29,8 +30,11 @@ namespace Dumux
{
/*!
- * \ingroup CCModel
+ * \ingroup CCDiscretization
* \brief Base class for the grid volume variables
+ * \note This class has a cached version and a non-cached version
+ * \tparam TypeTag the TypeTag
+ * \tparam enableGridVolVarsCache if the cache is enabled
*/
template<class TypeTag, bool enableGridVolVarsCache>
class CCGridVolumeVariables
diff --git a/dumux/discretization/cellcentered/subcontrolvolume.hh b/dumux/discretization/cellcentered/subcontrolvolume.hh
index f8875526ff5f8602001239761db6aeaff233d797..c9521b8bbe4481579a1b7d376edfbda546523c61 100644
--- a/dumux/discretization/cellcentered/subcontrolvolume.hh
+++ b/dumux/discretization/cellcentered/subcontrolvolume.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief Base class for a sub control volume
+ * \ingroup CCDiscretization
+ * \brief Sub control volumes for cell-centered discretization schemes
*/
#ifndef DUMUX_DISCRETIZATION_CC_SUBCONTROLVOLUME_HH
#define DUMUX_DISCRETIZATION_CC_SUBCONTROLVOLUME_HH
@@ -28,6 +29,10 @@
namespace Dumux
{
+/*!
+ * \ingroup CCDiscretization
+ * \brief Sub control volumes for cell-centered discretization schemes
+ */
template<class ScvGeometryTraits>
class CCSubControlVolume : public SubControlVolumeBase<CCSubControlVolume<ScvGeometryTraits>, ScvGeometryTraits>
{
@@ -42,7 +47,6 @@ public:
//! state the traits public and thus export all types
using Traits = ScvGeometryTraits;
- // the default constructor
CCSubControlVolume() = default;
// the contructor in the cc case
diff --git a/dumux/discretization/cellcentered/tpfa/computetransmissibility.hh b/dumux/discretization/cellcentered/tpfa/computetransmissibility.hh
index 04be34b5c87de935bec949883aa0283ef67e0bac..d0c8a430e5119dfeda2f429f3882ea72e5a81631 100644
--- a/dumux/discretization/cellcentered/tpfa/computetransmissibility.hh
+++ b/dumux/discretization/cellcentered/tpfa/computetransmissibility.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief This file contains free functions to evaluate the transmissibilities
+ * \ingroup CCTpfaDiscretization
+ * \brief Free functions to evaluate the transmissibilities
* associated with flux evaluations across sub-control volume faces
* in the context of the cell-centered TPFA scheme.
*/
@@ -32,10 +33,9 @@ namespace Dumux
{
/*!
- * \ingroup Tpfa
- *
- * \brief Free function to evaluate the Tpfa transmissibility associated
- * with the flux (in the form of flux = T*gradU) across a
+ * \ingroup CCTpfaDiscretization
+ * \brief Free function to evaluate the Tpfa transmissibility
+ * associated with the flux (in the form of flux = T*gradU) across a
* sub-control volume face stemming from a given sub-control
* volume with corresponding tensor T.
*
@@ -62,9 +62,11 @@ typename Tensor::field_type computeTpfaTransmissibility(const SubControlVolumeFa
}
/*!
- * \ingroup Tpfa
- *
- * \brief Specialization of the above function for scalar T.
+ * \ingroup CCTpfaDiscretization
+ * \brief Free function to evaluate the Tpfa transmissibility
+ * associated with the flux (in the form of flux = T*gradU) across a
+ * sub-control volume face stemming from a given sub-control
+ * volume for the case where T is just a scalar
*
* \param scvf The sub-control volume face
* \param scv The neighboring sub-control volume
diff --git a/dumux/discretization/cellcentered/tpfa/darcyslaw.hh b/dumux/discretization/cellcentered/tpfa/darcyslaw.hh
index 1dcb394f668242aeec8996cc5ec48aaeb6901da4..aa2f60977f61451fbd714a7c4e40484ed89d99c5 100644
--- a/dumux/discretization/cellcentered/tpfa/darcyslaw.hh
+++ b/dumux/discretization/cellcentered/tpfa/darcyslaw.hh
@@ -18,9 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief This file contains the data which is required to calculate
- * volume and mass fluxes of fluid phases over a face of a finite volume by means
- * of the Darcy approximation. Specializations are provided for the different discretization methods.
+ * \ingroup CCTpfaDiscretization
+ * \brief Darcy's law for cell-centered finite volume schemes with two-point flux approximation
*/
#ifndef DUMUX_DISCRETIZATION_CC_TPFA_DARCYS_LAW_HH
#define DUMUX_DISCRETIZATION_CC_TPFA_DARCYS_LAW_HH
@@ -42,15 +41,19 @@ template<class TypeTag, bool isNetwork>
class CCTpfaDarcysLaw;
/*!
- * \ingroup DarcysLaw
- * \brief Specialization of Darcy's Law for the CCTpfa method.
+ * \ingroup CCTpfaDiscretization
+ * \brief Darcy's law for cell-centered finite volume schemes with two-point flux approximation
+ * \note Darcy's law is speialized for network and surface grids (i.e. if grid dim < dimWorld)
*/
template <class TypeTag>
class DarcysLawImplementation<TypeTag, DiscretizationMethods::CCTpfa>
- : public CCTpfaDarcysLaw<TypeTag, (GET_PROP_TYPE(TypeTag, Grid)::dimension < GET_PROP_TYPE(TypeTag, Grid)::dimensionworld) >
+: public CCTpfaDarcysLaw<TypeTag, (GET_PROP_TYPE(TypeTag, Grid)::dimension < GET_PROP_TYPE(TypeTag, Grid)::dimensionworld) >
{};
-//! Class that fills the cache corresponding to tpfa Darcy's Law
+/*!
+ * \ingroup CCTpfaDiscretization
+ * \brief Class that fills the cache corresponding to tpfa Darcy's Law
+ */
template<class TypeTag>
class TpfaDarcysLawCacheFiller
{
@@ -77,7 +80,10 @@ public:
}
};
-//! the cache corresponding to tpfa Darcy's Law
+/*!
+ * \ingroup CCTpfaDiscretization
+ * \brief The cache corresponding to tpfa Darcy's Law
+ */
template<class TypeTag>
class TpfaDarcysLawCache
{
@@ -108,7 +114,10 @@ private:
Scalar tij_;
};
-//! Specialization of the CCTpfaDarcysLaw grids where dim=dimWorld
+/*!
+ * \ingroup CCTpfaDiscretization
+ * \brief Specialization of the CCTpfaDarcysLaw grids where dim=dimWorld
+ */
template<class TypeTag>
class CCTpfaDarcysLaw<TypeTag, /*isNetwork*/ false>
{
@@ -133,12 +142,13 @@ class CCTpfaDarcysLaw<TypeTag, /*isNetwork*/ false>
using GlobalPosition = Dune::FieldVector<Scalar, dimWorld>;
public:
- // state the discretization method this implementation belongs to
+ //! state the discretization method this implementation belongs to
static const DiscretizationMethods myDiscretizationMethod = DiscretizationMethods::CCTpfa;
- // state the type for the corresponding cache
+ //! state the type for the corresponding cache
using Cache = TpfaDarcysLawCache<TypeTag>;
+ //! Compute the advective flux
static Scalar flux(const Problem& problem,
const Element& element,
const FVElementGeometry& fvGeometry,
@@ -260,7 +270,10 @@ class CCTpfaDarcysLaw<TypeTag, /*isNetwork*/ false>
}
};
-//! Specialization of the CCTpfaDarcysLaw for network/surface grids
+/*!
+ * \ingroup CCTpfaDiscretization
+ * \brief Specialization of the CCTpfaDarcysLaw grids where dim < dimWorld (network/surface grids)
+ */
template<class TypeTag>
class CCTpfaDarcysLaw<TypeTag, /*isNetwork*/ true>
{
@@ -285,12 +298,13 @@ class CCTpfaDarcysLaw<TypeTag, /*isNetwork*/ true>
using GlobalPosition = Dune::FieldVector<Scalar, dimWorld>;
public:
- // state the discretization method this implementation belongs to
+ //! state the discretization method this implementation belongs to
static const DiscretizationMethods myDiscretizationMethod = DiscretizationMethods::CCTpfa;
- // state the type for the corresponding cache
+ //! state the type for the corresponding cache
using Cache = TpfaDarcysLawCache<TypeTag>;
+ //! Compute the advective flux
static Scalar flux(const Problem& problem,
const Element& element,
const FVElementGeometry& fvGeometry,
diff --git a/dumux/discretization/cellcentered/tpfa/elementfluxvariablescache.hh b/dumux/discretization/cellcentered/tpfa/elementfluxvariablescache.hh
index 0ab9da19087b930b7fd5f8caa850f52235ea0d95..c0a210c6f2d5956d4eda15f9c0117b116d0b183a 100644
--- a/dumux/discretization/cellcentered/tpfa/elementfluxvariablescache.hh
+++ b/dumux/discretization/cellcentered/tpfa/elementfluxvariablescache.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief The global object of flux var caches
+ * \ingroup CCTpfaDiscretization
+ * \brief The flux variables caches for an element
*/
#ifndef DUMUX_DISCRETIZATION_CCTPFA_ELEMENT_FLUXVARSCACHE_HH
#define DUMUX_DISCRETIZATION_CCTPFA_ELEMENT_FLUXVARSCACHE_HH
@@ -31,15 +32,19 @@ namespace Dumux
{
/*!
- * \ingroup ImplicitModel
- * \brief Base class for the stencil local flux variables cache
+ * \ingroup CCTpfaDiscretization
+ * \brief The flux variables caches for an element
+ * \note The class is specialized for a version with and without caching
+ * If grid caching is enabled the flux caches are stored for the whole gridview in the corresponding
+ * GridFluxVariablesCache which is memory intensive but faster. For caching disabled the
+ * flux caches are locally computed for each element whenever needed.
*/
template<class TypeTag, bool EnableGridFluxVariablesCache>
class CCTpfaElementFluxVariablesCache;
/*!
- * \ingroup ImplicitModel
- * \brief Spezialization when caching globally
+ * \ingroup CCTpfaDiscretization
+ * \brief The flux variables caches for an element with caching enabled
*/
template<class TypeTag>
class CCTpfaElementFluxVariablesCache<TypeTag, true>
@@ -58,23 +63,23 @@ public:
CCTpfaElementFluxVariablesCache(const GridFluxVariablesCache& global)
: gridFluxVarsCachePtr_(&global) {}
- // Specialization for the global caching being enabled - do nothing here
+ //! Specialization for the global caching being enabled - do nothing here
void bindElement(const Element& element,
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars) {}
- // Specialization for the global caching being enabled - do nothing here
+ //! Specialization for the global caching being enabled - do nothing here
void bind(const Element& element,
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars) {}
- // Specialization for the global caching being enabled - do nothing here
+ //! Specialization for the global caching being enabled - do nothing here
void bindScvf(const Element& element,
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars,
const SubControlVolumeFace& scvf) {}
- // Specialization for the global caching being enabled - do nothing here
+ //! Specialization for the global caching being enabled - do nothing here
void update(const Element& element,
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars)
@@ -82,7 +87,7 @@ public:
DUNE_THROW(Dune::InvalidStateException, "In case of enabled caching, the grid flux variables cache has to be updated");
}
- // access operators in the case of caching
+ //! access operators in the case of caching
const FluxVariablesCache& operator [](const SubControlVolumeFace& scvf) const
{ return gridFluxVarsCache()[scvf]; }
@@ -95,8 +100,8 @@ private:
};
/*!
- * \ingroup ImplicitModel
- * \brief Spezialization when not using global caching
+ * \ingroup CCTpfaDiscretization
+ * \brief The flux variables caches for an element with caching disabled
*/
template<class TypeTag>
class CCTpfaElementFluxVariablesCache<TypeTag, false>
@@ -116,8 +121,11 @@ public:
CCTpfaElementFluxVariablesCache(const GridFluxVariablesCache& global)
: gridFluxVarsCachePtr_(&global) {}
- // This function has to be called prior to flux calculations on the element.
- // Prepares the transmissibilities of the scv faces in an element. The FvGeometry is assumed to be bound.
+ /*!
+ * \brief Prepares the transmissibilities of the scv faces in an element
+ * \note the fvGeometry is assumed to be bound to the same element
+ * \note this function has to be called prior to flux calculations on the element.
+ */
void bindElement(const Element& element,
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars)
@@ -140,8 +148,11 @@ public:
}
}
- // This function is called by the CCLocalResidual before flux calculations during assembly.
- // Prepares the transmissibilities of the scv faces in the stencil. The FvGeometries are assumed to be bound.
+ /*!
+ * \brief Prepares the transmissibilities of the scv faces in the stencil of an element
+ * \note the fvGeometry is assumed to be bound to the same element
+ * \note this function has to be called prior to flux calculations on the element.
+ */
void bind(const Element& element,
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars)
@@ -185,6 +196,11 @@ public:
}
}
+ /*!
+ * \brief Prepares the transmissibilities of a single scv face
+ * \note the fvGeometry is assumed to be bound to the same element
+ * \note this function has to be called prior to flux calculations on the element.
+ */
void bindScvf(const Element& element,
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars,
@@ -200,8 +216,10 @@ public:
globalScvfIndices_[0] = scvf.index();
}
- // This function is used to update the transmissibilities if the volume variables have changed
- // Results in undefined behaviour if called before bind() or with a different element
+ /*!
+ * \brief Update the transmissibilities if the volume variables have changed
+ * \note Results in undefined behaviour if called before bind() or with a different element
+ */
void update(const Element& element,
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars)
@@ -229,10 +247,11 @@ public:
}
}
- // access operators in the case of no caching
+ //! access operators in the case of no caching
const FluxVariablesCache& operator [](const SubControlVolumeFace& scvf) const
{ return fluxVarsCache_[getLocalScvfIdx_(scvf.index())]; }
+ //! access operators in the case of no caching
FluxVariablesCache& operator [](const SubControlVolumeFace& scvf)
{ return fluxVarsCache_[getLocalScvfIdx_(scvf.index())]; }
@@ -243,7 +262,7 @@ public:
private:
const GridFluxVariablesCache* gridFluxVarsCachePtr_;
- // get index of scvf in the local container
+ //! get index of scvf in the local container
int getLocalScvfIdx_(const int scvfIdx) const
{
auto it = std::find(globalScvfIndices_.begin(), globalScvfIndices_.end(), scvfIdx);
@@ -255,6 +274,6 @@ private:
std::vector<IndexType> globalScvfIndices_;
};
-} // end namespace
+} // end namespace Dumux
#endif
diff --git a/dumux/discretization/cellcentered/tpfa/elementvolumevariables.hh b/dumux/discretization/cellcentered/tpfa/elementvolumevariables.hh
index 35e2ddf7b6d6da7ad75b079344ee548f8881abc5..ba2bda23e0bf1447a74caca6fdc336544e7d4e60 100644
--- a/dumux/discretization/cellcentered/tpfa/elementvolumevariables.hh
+++ b/dumux/discretization/cellcentered/tpfa/elementvolumevariables.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief The local (stencil) volume variables class for cell centered models
+ * \ingroup CCTpfaDiscretization
+ * \brief The local (stencil) volume variables class for cell centered tpfa models
*/
#ifndef DUMUX_DISCRETIZATION_CCTPFA_ELEMENT_VOLUMEVARIABLES_HH
#define DUMUX_DISCRETIZATION_CCTPFA_ELEMENT_VOLUMEVARIABLES_HH
@@ -29,14 +30,19 @@ namespace Dumux
{
/*!
- * \ingroup ImplicitModel
- * \brief Base class for the volume variables vector
+ * \ingroup CCTpfaDiscretization
+ * \brief The local (stencil) volume variables class for cell centered tpfa models
+ * \note The class is specilized for versions with and without caching
*/
template<class TypeTag, bool enableGridVolVarsCache>
class CCTpfaElementVolumeVariables
{};
-// specialization in case of storing the volume variables globally
+/*!
+ * \ingroup CCTpfaDiscretization
+ * \brief The local (stencil) volume variables class for cell centered tpfa models with caching
+ * \note the volume variables are stored for the whole grid view in the corresponding GridVolumeVariables class
+ */
template<class TypeTag>
class CCTpfaElementVolumeVariables<TypeTag, /*enableGridVolVarsCache*/true>
{
@@ -58,22 +64,21 @@ public:
CCTpfaElementVolumeVariables(const GridVolumeVariables& gridVolVars)
: gridVolVarsPtr_(&gridVolVars) {}
+ //! operator for the access with an index
const VolumeVariables& operator [](const SubControlVolume& scv) const
{ return gridVolVars().volVars(scv.dofIndex()); }
- // operator for the access with an index
- // needed for cc methods for the access to the boundary volume variables
+ //! operator for the access with an index
const VolumeVariables& operator [](const IndexType scvIdx) const
{ return gridVolVars().volVars(scvIdx); }
- // For compatibility reasons with the case of not storing the vol vars.
- // function to be called before assembling an element, preparing the vol vars within the stencil
+ //! precompute all volume variables in a stencil of an element - do nothing volVars: are cached
void bind(const Element& element,
const FVElementGeometry& fvGeometry,
const SolutionVector& sol)
{}
- // function to prepare the vol vars within the element
+ //! precompute the volume variables of an element - do nothing: volVars are cached
void bindElement(const Element& element,
const FVElementGeometry& fvGeometry,
const SolutionVector& sol)
@@ -87,8 +92,10 @@ private:
const GridVolumeVariables* gridVolVarsPtr_;
};
-
-// Specialization when the current volume variables are not stored
+/*!
+ * \ingroup CCTpfaDiscretization
+ * \brief The local (stencil) volume variables class for cell centered tpfa models with caching
+ */
template<class TypeTag>
class CCTpfaElementVolumeVariables<TypeTag, /*enableGridVolVarsCache*/false>
{
@@ -111,8 +118,7 @@ public:
CCTpfaElementVolumeVariables(const GridVolumeVariables& gridVolVars)
: gridVolVarsPtr_(&gridVolVars) {}
- // Binding of an element, prepares the volume variables within the element stencil
- // called by the local jacobian to prepare element assembly
+ //! Prepares the volume variables within the element stencil
void bind(const Element& element,
const FVElementGeometry& fvGeometry,
const SolutionVector& sol)
@@ -198,8 +204,7 @@ public:
// }
}
- // Binding of an element, prepares only the volume variables of the element
- // specialization for cc models
+ //! Prepares the volume variables of an element
void bindElement(const Element& element,
const FVElementGeometry& fvGeometry,
const SolutionVector& sol)
@@ -219,15 +224,19 @@ public:
volVarIndices_[0] = scv.dofIndex();
}
+ //! access operator with scv
const VolumeVariables& operator [](const SubControlVolume& scv) const
{ return volumeVariables_[getLocalIdx_(scv.dofIndex())]; }
+ //! access operator with scv
VolumeVariables& operator [](const SubControlVolume& scv)
{ return volumeVariables_[getLocalIdx_(scv.dofIndex())]; }
+ //! access operator with scv index
const VolumeVariables& operator [](IndexType scvIdx) const
{ return volumeVariables_[getLocalIdx_(scvIdx)]; }
+ //! access operator with scv index
VolumeVariables& operator [](IndexType scvIdx)
{ return volumeVariables_[getLocalIdx_(scvIdx)]; }
@@ -244,6 +253,7 @@ public:
private:
const GridVolumeVariables* gridVolVarsPtr_;
+ //! map a global scv index to the local storage index
int getLocalIdx_(const int volVarIdx) const
{
auto it = std::find(volVarIndices_.begin(), volVarIndices_.end(), volVarIdx);
@@ -255,6 +265,6 @@ private:
std::vector<VolumeVariables> volumeVariables_;
};
-} // end namespace
+} // end namespace Dumux
#endif
diff --git a/dumux/discretization/cellcentered/tpfa/fickslaw.hh b/dumux/discretization/cellcentered/tpfa/fickslaw.hh
index ae84a0203fdefd09ee7edf44009cbc095327cf31..b1f4bf7b47e3d66f29eaff1e437e5bb50ff154d9 100644
--- a/dumux/discretization/cellcentered/tpfa/fickslaw.hh
+++ b/dumux/discretization/cellcentered/tpfa/fickslaw.hh
@@ -18,8 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief This file contains the data which is required to calculate
- * diffusive mass fluxes due to molecular diffusion with Fick's law.
+ * \ingroup CCTpfaDiscretization
+ * \brief Fick's law for cell-centered finite volume schemes with two-point flux approximation
*/
#ifndef DUMUX_DISCRETIZATION_CC_TPFA_FICKS_LAW_HH
#define DUMUX_DISCRETIZATION_CC_TPFA_FICKS_LAW_HH
@@ -37,8 +37,8 @@ template<class TypeTag, DiscretizationMethods discMethod>
class FicksLawImplementation;
/*!
- * \ingroup CCTpfaFicksLaw
- * \brief Specialization of Fick's Law for the CCTpfa method.
+ * \ingroup CCTpfaDiscretization
+ * \brief Fick's law for cell-centered finite volume schemes with two-point flux approximation
*/
template <class TypeTag>
class FicksLawImplementation<TypeTag, DiscretizationMethods::CCTpfa>
@@ -114,12 +114,13 @@ class FicksLawImplementation<TypeTag, DiscretizationMethods::CCTpfa>
};
public:
- // state the discretization method this implementation belongs to
+ //! state the discretization method this implementation belongs to
static const DiscretizationMethods myDiscretizationMethod = DiscretizationMethods::CCTpfa;
//! state the type for the corresponding cache and its filler
using Cache = TpfaFicksLawCache;
+ //! return diffusive fluxes for all components in a phase
static ComponentFluxVector flux(const Problem& problem,
const Element& element,
const FVElementGeometry& fvGeometry,
@@ -159,6 +160,7 @@ public:
return componentFlux;
}
+ //! compute diffusive transmissibilities
static Scalar calculateTransmissibility(const Problem& problem,
const Element& element,
const FVElementGeometry& fvGeometry,
@@ -257,6 +259,7 @@ private:
return rho/(scvf.numOutsideScvs()+1);
}
};
-} // end namespace
+
+} // end namespace Dumux
#endif
diff --git a/dumux/discretization/cellcentered/tpfa/fluxvariablescachefiller.hh b/dumux/discretization/cellcentered/tpfa/fluxvariablescachefiller.hh
index 8b282b69c467e419ce2a0bb321a7fef1425dcc14..17d8890746ef5e65def282daf5a37c44df386d15 100644
--- a/dumux/discretization/cellcentered/tpfa/fluxvariablescachefiller.hh
+++ b/dumux/discretization/cellcentered/tpfa/fluxvariablescachefiller.hh
@@ -16,9 +16,10 @@
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*****************************************************************************/
-/*!
+ /*!
* \file
- * \brief The flux variables cache filler class for the cell-centered TPFA scheme
+ * \ingroup CCTpfaDiscretization
+ * \brief A helper class to fill the flux variable caches used in the flux constitutive laws
*/
#ifndef DUMUX_DISCRETIZATION_CCTPFA_FLUXVARSCACHE_FILLER_HH
#define DUMUX_DISCRETIZATION_CCTPFA_FLUXVARSCACHE_FILLER_HH
@@ -30,9 +31,9 @@ namespace Dumux
{
/*!
- * \ingroup ImplicitModel
- * \brief Helper class to fill the flux var caches
- */
+* \ingroup CCTpfaDiscretization
+* \brief A helper class to fill the flux variable caches used in the flux constitutive laws
+*/
template<class TypeTag>
class CCTpfaFluxVariablesCacheFiller
{
@@ -193,6 +194,6 @@ private:
const Problem* problemPtr_;
};
-} // end namespace
+} // end namespace Dumux
#endif
diff --git a/dumux/discretization/cellcentered/tpfa/fourierslaw.hh b/dumux/discretization/cellcentered/tpfa/fourierslaw.hh
index bc468651361549342a25a94496dc015a64351e96..c6ba00912f2a744cf3b3c16884bce903ca84df46 100644
--- a/dumux/discretization/cellcentered/tpfa/fourierslaw.hh
+++ b/dumux/discretization/cellcentered/tpfa/fourierslaw.hh
@@ -17,10 +17,10 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*****************************************************************************/
/*!
- * \file
- * \brief This file contains the data which is required to calculate
- * heat conduction fluxes with Fourier's law.
- */
+* \file
+* \ingroup CCTpfaDiscretization
+* \brief Fourier's law for cell-centered finite volume schemes with two-point flux approximation
+*/
#ifndef DUMUX_DISCRETIZATION_CC_TPFA_FOURIERS_LAW_HH
#define DUMUX_DISCRETIZATION_CC_TPFA_FOURIERS_LAW_HH
@@ -37,9 +37,9 @@ template<class TypeTag, DiscretizationMethods discMethod>
class FouriersLawImplementation;
/*!
- * \ingroup FouriersLaw
- * \brief Specialization of Fourier's Law for the CCTpfa method.
- */
+* \ingroup CCTpfaDiscretization
+* \brief Fourier's law for cell-centered finite volume schemes with two-point flux approximation
+*/
template <class TypeTag>
class FouriersLawImplementation<TypeTag, DiscretizationMethods::CCTpfa>
{
@@ -106,12 +106,13 @@ class FouriersLawImplementation<TypeTag, DiscretizationMethods::CCTpfa>
};
public:
- // state the discretization method this implementation belongs to
+ //! state the discretization method this implementation belongs to
static const DiscretizationMethods myDiscretizationMethod = DiscretizationMethods::CCTpfa;
//! export the type for the corresponding cache
using Cache = TpfaFouriersLawCache;
+ //! Compute the heat condution flux assuming thermal equilibrium
static Scalar flux(const Problem& problem,
const Element& element,
const FVElementGeometry& fvGeometry,
@@ -130,6 +131,7 @@ public:
return tij*(tInside - tOutside);
}
+ //! Compute transmissibilities
static Scalar calculateTransmissibility(const Problem& problem,
const Element& element,
const FVElementGeometry& fvGeometry,
diff --git a/dumux/discretization/cellcentered/tpfa/fvelementgeometry.hh b/dumux/discretization/cellcentered/tpfa/fvelementgeometry.hh
index 9205a26c806547ea4bbc3ec680ccfb9663d2c524..12837c09b265a23fdba0819608df3a9daac31aeb 100644
--- a/dumux/discretization/cellcentered/tpfa/fvelementgeometry.hh
+++ b/dumux/discretization/cellcentered/tpfa/fvelementgeometry.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief Base class for a local finite volume geometry for cell-centered TPFA models
+ * \ingroup CCTpfaDiscretization
+ * \brief Stencil-local finite volume geometry (scvs and scvfs) for cell-centered TPFA models
* This builds up the sub control volumes and sub control volume faces
* for each element in the local scope we are restricting to, e.g. stencil or element.
*/
@@ -38,17 +39,22 @@ template<class TypeTag, bool EnableFVGridGeometryCache>
class CCTpfaFVGridGeometry;
/*!
- * \ingroup ImplicitModel
- * \brief Base class for the finite volume geometry vector for cell-centered TPFA models
+ * \ingroup CCTpfaDiscretization
+ * \brief Stencil-local finite volume geometry (scvs and scvfs) for cell-centered TPFA models
* This builds up the sub control volumes and sub control volume faces
- * for each element.
+ * for each element in the local scope we are restricting to, e.g. stencil or element.
+ * \note This class is specialized for versions with and without caching the fv geometries on the grid view
*/
template<class TypeTag, bool EnableFVGridGeometryCache>
class CCTpfaFVElementGeometry
{};
-//! specialization in case the FVElementGeometries are stored globally
-//! In this case we just forward internally to the global object
+/*!
+ * \ingroup CCTpfaDiscretization
+ * \brief Stencil-local finite volume geometry (scvs and scvfs) for cell-centered TPFA models
+ * Specialization for grid caching enabled
+ * \note The finite volume geometries are stored in the corresponding FVGridGeometry
+ */
template<class TypeTag>
class CCTpfaFVElementGeometry<TypeTag, true>
{
@@ -151,7 +157,11 @@ private:
const FVGridGeometry* fvGridGeometryPtr_;
};
-//! specialization in case the FVElementGeometries are not stored
+/*!
+ * \ingroup CCTpfaDiscretization
+ * \brief Stencil-local finite volume geometry (scvs and scvfs) for cell-centered TPFA models
+ * Specialization for grid caching disabled
+ */
template<class TypeTag>
class CCTpfaFVElementGeometry<TypeTag, false>
{
@@ -526,7 +536,7 @@ private:
flippedNeighborScvfIndices_.clear();
}
- // the bound element
+ //! the bound element
const Element* elementPtr_;
const FVGridGeometry* fvGridGeometryPtr_;
@@ -545,6 +555,6 @@ private:
std::vector<std::vector<IndexType>> flippedNeighborScvfIndices_;
};
-} // end namespace
+} // end namespace Dumux
#endif
diff --git a/dumux/discretization/cellcentered/tpfa/fvgridgeometry.hh b/dumux/discretization/cellcentered/tpfa/fvgridgeometry.hh
index 3373a48799657c5c6353d2ec7d9c884a47ac6df6..f71a30ea60989698801ff931a22dad27b616e5a4 100644
--- a/dumux/discretization/cellcentered/tpfa/fvgridgeometry.hh
+++ b/dumux/discretization/cellcentered/tpfa/fvgridgeometry.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief Base class for the finite volume geometry vector for cell-centered TPFA models
+ * \ingroup CCTpfaDiscretization
+ * \brief The finite volume geometry (scvs and scvfs) for cell-centered TPFA models on a grid view
* This builds up the sub control volumes and sub control volume faces
* for each element of the grid partition.
*/
@@ -35,16 +36,21 @@ namespace Dumux
{
/*!
- * \ingroup ImplicitModel
- * \brief Base class for the finite volume geometry vector for cell-centered TPFA models
+ * \ingroup CCTpfaDiscretization
+ * \brief The finite volume geometry (scvs and scvfs) for cell-centered TPFA models on a grid view
* This builds up the sub control volumes and sub control volume faces
- * for each element.
+ * \note This class is specialized for versions with and without caching the fv geometries on the grid view
*/
template<class TypeTag, bool EnableFVGridGeometryCache>
class CCTpfaFVGridGeometry
{};
-// specialization in case the FVElementGeometries are stored globally
+/*!
+ * \ingroup CCTpfaDiscretization
+ * \brief The finite volume geometry (scvs and scvfs) for cell-centered TPFA models on a grid view
+ * This builds up the sub control volumes and sub control volume faces
+ * \note For caching enabled we store the fv geometries for the whole grid view which is memory intensive but faster
+ */
template<class TypeTag>
class CCTpfaFVGridGeometry<TypeTag, true> : public BaseFVGridGeometry<TypeTag>
{
@@ -100,11 +106,11 @@ public:
std::size_t numDofs() const
{ return this->gridView().size(0); }
- // Get an element from a sub control volume contained in it
+ //! Get an element from a sub control volume contained in it
Element element(const SubControlVolume& scv) const
{ return this->elementMap()[scv.elementIndex()]; }
- // Get an element from a global element index
+ //! Get an element from a global element index
Element element(IndexType eIdx) const
{ return this->elementMap()[eIdx]; }
@@ -285,20 +291,26 @@ private:
DUNE_THROW(Dune::InvalidStateException, "No flipped version of this scvf found!");
}
- // connectivity map for efficient assembly
+ //! connectivity map for efficient assembly
ConnectivityMap connectivityMap_;
- // containers storing the global data
+ //! containers storing the global data
std::vector<SubControlVolume> scvs_;
std::vector<SubControlVolumeFace> scvfs_;
std::vector<std::vector<IndexType>> scvfIndicesOfScv_;
IndexType numBoundaryScvf_;
- // needed for embedded surface and network grids (dim < dimWorld)
+ //! needed for embedded surface and network grids (dim < dimWorld)
std::vector<std::vector<IndexType>> flipScvfIndices_;
};
-// specialization in case the FVElementGeometries are not stored
+/*!
+ * \ingroup CCTpfaDiscretization
+ * \brief The finite volume geometry (scvs and scvfs) for cell-centered TPFA models on a grid view
+ * This builds up the sub control volumes and sub control volume faces
+ * \note For caching disabled we store only some essential index maps to build up local systems on-demand in
+ * the corresponding FVElementGeometry
+ */
template<class TypeTag>
class CCTpfaFVGridGeometry<TypeTag, false> : public BaseFVGridGeometry<TypeTag>
{
@@ -468,15 +480,15 @@ public:
private:
- // Information on the global number of geometries
+ //! Information on the global number of geometries
IndexType numScvs_;
IndexType numScvf_;
IndexType numBoundaryScvf_;
- // connectivity map for efficient assembly
+ //! connectivity map for efficient assembly
ConnectivityMap connectivityMap_;
- // vectors that store the global data
+ //! vectors that store the global data
std::vector<std::vector<IndexType>> scvfIndicesOfScv_;
std::vector<std::vector<std::vector<IndexType>>> neighborVolVarIndices_;
};
diff --git a/dumux/discretization/cellcentered/tpfa/gridfluxvariablescache.hh b/dumux/discretization/cellcentered/tpfa/gridfluxvariablescache.hh
index da39f3755cb01816b3e41ef6b9f648e4da7eefc6..88a551240492507080e1b6524b024b9cf61bce6a 100644
--- a/dumux/discretization/cellcentered/tpfa/gridfluxvariablescache.hh
+++ b/dumux/discretization/cellcentered/tpfa/gridfluxvariablescache.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief The global object of flux var caches
+ * \ingroup CCTpfaDiscretization
+ * \brief Flux variable caches on a gridview
*/
#ifndef DUMUX_DISCRETIZATION_CCTPFA_GRID_FLUXVARSCACHE_HH
#define DUMUX_DISCRETIZATION_CCTPFA_GRID_FLUXVARSCACHE_HH
@@ -30,15 +31,17 @@ namespace Dumux
{
/*!
- * \ingroup ImplicitModel
- * \brief Base class for the flux variables cache vector, we store one cache per face
+ * \ingroup CCTpfaDiscretization
+ * \brief Flux variable caches on a gridview
+ * \note The class is specialized for a version with and without grid caching
*/
template<class TypeTag, bool EnableGridFluxVariablesCache>
class CCTpfaGridFluxVariablesCache;
/*!
- * \ingroup ImplicitModel
- * \brief Spezialization when caching globally
+ * \ingroup CCTpfaDiscretization
+ * \brief Flux variable caches on a gridview with grid caching enabled
+ * \note The flux caches of the gridview are stored which is memory intensive but faster
*/
template<class TypeTag>
class CCTpfaGridFluxVariablesCache<TypeTag, true>
@@ -145,8 +148,8 @@ private:
};
/*!
- * \ingroup ImplicitModel
- * \brief Spezialization when not using global caching
+ * \ingroup CCTpfaDiscretization
+ * \brief Flux variable caches on a gridview with grid caching disabled
*/
template<class TypeTag>
class CCTpfaGridFluxVariablesCache<TypeTag, false>
@@ -165,12 +168,13 @@ public:
// The constructor
CCTpfaGridFluxVariablesCache(const Problem& problem) : problemPtr_(&problem) {}
- // When global flux variables caching is disabled, we don't need to update the cache
+ //! When global flux variables caching is disabled, we don't need to update the cache
void update(const FVGridGeometry& fvGridGeometry,
const GridVolumeVariables& gridVolVars,
const SolutionVector& sol,
bool forceUpdate = false) {}
+ //! When global flux variables caching is disabled, we don't need to update the cache
void updateElement(const Element& element,
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars) {}
@@ -190,6 +194,6 @@ private:
const Problem* problemPtr_;
};
-} // end namespace
+} // end namespace Dumux
#endif
diff --git a/dumux/discretization/cellcentered/tpfa/properties.hh b/dumux/discretization/cellcentered/tpfa/properties.hh
index 22de02dac9bcea98cb47c6bb64bfb9933ba7b965..8e2bca2a4857885649ade46a74e54528762004b1 100644
--- a/dumux/discretization/cellcentered/tpfa/properties.hh
+++ b/dumux/discretization/cellcentered/tpfa/properties.hh
@@ -17,11 +17,10 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*****************************************************************************/
/*!
- * \ingroup Properties
* \file
- *
- * \brief Defines a type tag and some properties for models using
- * a cell-centered scheme with two-point flux approximation.
+ * \ingroup CCTpfaDiscretization
+ * \brief Properties for all models using cell-centered finite volume scheme with TPFA
+ * \note Inherit from these properties to use a cell-centered finite volume scheme with TPFA
*/
#ifndef DUMUX_CC_TPFA_PROPERTIES_HH
diff --git a/dumux/discretization/cellcentered/tpfa/subcontrolvolumeface.hh b/dumux/discretization/cellcentered/tpfa/subcontrolvolumeface.hh
index 5cdd51465e4d6afffced44b4acf5f8d623bf244f..58c837af98aa0982817d2e04d1f706a75baa93c9 100644
--- a/dumux/discretization/cellcentered/tpfa/subcontrolvolumeface.hh
+++ b/dumux/discretization/cellcentered/tpfa/subcontrolvolumeface.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief Base class for a sub control volume face
+ * \ingroup CCTpfaDiscretization
+ * \brief The sub control volume face
*/
#ifndef DUMUX_DISCRETIZATION_CC_TPFA_SUBCONTROLVOLUMEFACE_HH
#define DUMUX_DISCRETIZATION_CC_TPFA_SUBCONTROLVOLUMEFACE_HH
@@ -31,9 +32,8 @@ namespace Dumux
{
/*!
- * \ingroup Discretization
- * \brief Class for a sub control volume face in the box method, i.e a part of the boundary
- * of a sub control volume we compute fluxes on. We simply use the base class here.
+ * \ingroup CCTpfaDiscretization
+ * \brief The sub control volume face
*/
template<class ScvfGeometryTraits>
class CCTpfaSubControlVolumeFace : public SubControlVolumeFaceBase<CCTpfaSubControlVolumeFace<ScvfGeometryTraits>,ScvfGeometryTraits>
@@ -170,6 +170,6 @@ private:
BoundaryFlag boundaryFlag_;
};
-} // end namespace
+} // end namespace Dumux
#endif
diff --git a/dumux/discretization/darcyslaw.hh b/dumux/discretization/darcyslaw.hh
index 44c1523c8ea5564a5f67441683c8282cddb5b52f..f63e7fb77a6035279eed7a2f71f20c2a8d012786 100644
--- a/dumux/discretization/darcyslaw.hh
+++ b/dumux/discretization/darcyslaw.hh
@@ -18,7 +18,9 @@
*****************************************************************************/
/*!
* \file
- * \brief This file contains the data which is required to calculate
+ * \ingroup Discretization
+ * \brief Darcy's law specialized for different discretization schemes
+ * This file contains the data which is required to calculate
* volume and mass fluxes of fluid phases over a face of a finite volume by means
* of the Darcy approximation. Specializations are provided for the different discretization methods.
*/
@@ -35,16 +37,15 @@ class DarcysLawImplementation
{};
/*!
- * \ingroup DarcysLaw
- * \brief Evaluates the normal component of the Darcy velocity
- * on a (sub)control volume face. Specializations are provided
- * for the different discretization methods. These specializations
- * are found in the headers included below.
+ * \ingroup Discretization
+ * \brief Evaluates the normal component of the Darcy velocity on a (sub)control volume face.
+ * \note Specializations are provided for the different discretization methods.
+ * These specializations are found in the headers included below.
*/
template <class TypeTag>
using DarcysLaw = DarcysLawImplementation<TypeTag, GET_PROP_VALUE(TypeTag, DiscretizationMethod)>;
-} // end namespace
+} // end namespace Dumux
#include <dumux/discretization/box/darcyslaw.hh>
#include <dumux/discretization/cellcentered/tpfa/darcyslaw.hh>
diff --git a/dumux/discretization/evalgradients.hh b/dumux/discretization/evalgradients.hh
index 2b0e7f7316234bca217ea3d9b5519bcc3543045f..bd16f4b67ceadeca91284bdb4fa09e9a3a504c2b 100644
--- a/dumux/discretization/evalgradients.hh
+++ b/dumux/discretization/evalgradients.hh
@@ -18,7 +18,6 @@
*****************************************************************************/
/*!
* \file
- *
* \ingroup Discretization
* \brief free functions for the evaluation of primary variable gradients inside elements.
*/
@@ -35,9 +34,10 @@ namespace Dumux
/*!
* \brief Evaluates the gradient of a given box element solution to a given global position.
+ * \ingroup Discretization
*
- * \return the interpolated Primary Variables
* \param element The element
+ * \param geometry The element geometry
* \param fvGridGeometry The finite volume grid geometry
* \param elemSol The primary variables at the dofs of the element
* \param globalPos The global position
@@ -91,22 +91,23 @@ evalGradients(const Element& element,
}
/*!
+ * \ingroup Discretization
* \brief Evaluates the gradient of a given CCElementSolution to a given global position.
* This function is only here for (compilation) compatibility reasons with the box scheme.
* The solution within the control volumes is constant and thus gradients are zero.
* One can compute gradients towards the sub-control volume faces after reconstructing
- * the solution on the faces. However, this has to be done manually. Here, we simply
- * throw an exception that this shouldn't be used.
+ * the solution on the faces.
*
- * \return throw statement
* \param element The element
+ * \param geometry The element geometry
* \param fvGridGeometry The finite volume grid geometry
* \param elemSol The primary variables at the dofs of the element
* \param globalPos The global position
+ * \throws Dune::NotImplemented
*/
- template< class Element, class FVGridGeometry, class TypeTag >
- Dune::FieldVector<typename Element::Geometry::GlobalCoordinate,
- CCElementSolution<TypeTag>::PrimaryVariables::dimension>
+template< class Element, class FVGridGeometry, class TypeTag >
+Dune::FieldVector<typename Element::Geometry::GlobalCoordinate,
+ CCElementSolution<TypeTag>::PrimaryVariables::dimension>
evalGradients(const Element& element,
const typename Element::Geometry& geometry,
const FVGridGeometry& fvGridGeometry,
diff --git a/dumux/discretization/evalsolution.hh b/dumux/discretization/evalsolution.hh
index 74668851d75cbee908ecac5e9585e2c95afabb41..14588be953e46ef92f50dd54c22b4d21b5da12fa 100644
--- a/dumux/discretization/evalsolution.hh
+++ b/dumux/discretization/evalsolution.hh
@@ -18,7 +18,6 @@
*****************************************************************************/
/*!
* \file
- *
* \ingroup Discretization
* \brief free functions for the evaluation of primary variables inside elements.
*/
@@ -34,10 +33,11 @@ namespace Dumux
{
/*!
- * \brief Interpolates a given box element solution to a given global position.
+ * \brief Interpolates a given box element solution at a given global position.
* Uses the finite element cache of the grid geometry.
+ * \ingroup Discretization
*
- * \return the interpolated Primary Variables
+ * \return the interpolated primary variables
* \param element The element
* \param geometry The element geometry
* \param fvGridGeometry The finite volume grid geometry
@@ -75,11 +75,12 @@ evalSolution(const Element& element,
}
/*!
- * \brief Interpolates a given box element solution to a given global position.
+ * \ingroup Discretization
+ * \brief Interpolates a given box element solution at a given global position.
* Overload of the above evalSolution() function without a given fvGridGeometry.
* The local basis is computed on the fly.
*
- * \return the interpolated Primary Variables
+ * \return the interpolated primary variables
* \param element The element
* \param geometry The element geometry
* \param elemSol The primary variables at the dofs of the element
@@ -122,9 +123,10 @@ evalSolution(const Element& element,
}
/*!
- * \brief Interpolates a given CCElementSolution to a given global position.
+ * \brief Interpolates a given cell-centered element solution at a given global position.
+ * \ingroup Discretization
*
- * \return the (constant over the element) Primary Variables
+ * \return the primary variables (constant over the element)
* \param element The element
* \param geometry The element geometry
* \param fvGridGeometry The finite volume grid geometry
@@ -143,11 +145,12 @@ evalSolution(const Element& element,
}
/*!
- * \brief Interpolates a given CCElementSolution to a given global position.
+ * \brief Interpolates a given cell-centered element solution at a given global position.
* Overload of the above evalSolution() function without a given fvGridGeometry.
* For compatibility reasons with the box scheme.
+ * \ingroup Discretization
*
- * \return the (constant over the element) Primary Variables
+ * \return the primary variables (constant over the element)
* \param element The element
* \param geometry The element geometry
* \param elemSol The primary variables at the dofs of the element
diff --git a/dumux/discretization/fickslaw.hh b/dumux/discretization/fickslaw.hh
index c0e975085b7f3e5e298273f352f0221fc02c2664..bb880162b2cec7f8a6f31b8c8d966fb040b8e74a 100644
--- a/dumux/discretization/fickslaw.hh
+++ b/dumux/discretization/fickslaw.hh
@@ -18,7 +18,9 @@
*****************************************************************************/
/*!
* \file
- * \brief This file contains the data which is required to calculate
+ * \ingroup Discretization
+ * \brief Fick's law specilized for different discretization schemes.
+ * This file contains the data which is required to calculate
* diffusive mass fluxes due to molecular diffusion with Fick's law.
*/
#ifndef DUMUX_DISCRETIZATION_FICKS_LAW_HH
@@ -34,13 +36,13 @@ template <class TypeTag, DiscretizationMethods Method>
class FicksLawImplementation;
/*!
- * \ingroup CCTpfaFicksLaw
+ * \ingroup Discretization
* \brief Evaluates the diffusive mass flux according to Fick's law
*/
template <class TypeTag>
using FicksLaw = FicksLawImplementation<TypeTag, GET_PROP_VALUE(TypeTag, DiscretizationMethod)>;
-} // end namespace
+} // end namespace Dumux
#include <dumux/discretization/cellcentered/tpfa/fickslaw.hh>
#include <dumux/discretization/cellcentered/mpfa/fickslaw.hh>
diff --git a/dumux/discretization/fluxstencil.hh b/dumux/discretization/fluxstencil.hh
index 23a6090db01892b6af9db1f99a12bd9e4a10bc2a..0f24ee01654c42b9d7f7e074f9c0915a65b96ab1 100644
--- a/dumux/discretization/fluxstencil.hh
+++ b/dumux/discretization/fluxstencil.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief Base class the flux stencil
+ * \ingroup Discretization
+ * \brief The flux stencil specialized for different discretization schemes
*/
#ifndef DUMUX_DISCRETIZATION_FLUXSTENCIL_HH
#define DUMUX_DISCRETIZATION_FLUXSTENCIL_HH
@@ -35,7 +36,7 @@ class FluxStencilImplementation;
/*!
* \ingroup Discretization
- * \brief The flux stencil specialized for each discretization method
+ * \brief The flux stencil specialized for different discretization schemes
* \note There might be different stencils used for e.g. advection and diffusion for schemes
* where the stencil depends on variables. Also schemes might even have solution dependent
* stencil. However, we always reserve the stencil or all DOFs that are possibly involved
@@ -45,7 +46,10 @@ class FluxStencilImplementation;
template<class TypeTag>
using FluxStencil = FluxStencilImplementation<TypeTag, GET_PROP_VALUE(TypeTag, DiscretizationMethod)>;
-//! Flux stencil for the cell-centered TPFA scheme
+/*
+ * \ingroup Discretization
+ * \brief Flux stencil specialization for the cell-centered tpfa scheme
+ */
template<class TypeTag>
class FluxStencilImplementation<TypeTag, DiscretizationMethods::CCTpfa>
{
@@ -75,7 +79,10 @@ public:
}
};
-//! Specialization for cell-centered MPFA schemes
+/*
+ * \ingroup Discretization
+ * \brief Flux stencil specialization for the cell-centered mpfa scheme
+ */
template<class TypeTag>
class FluxStencilImplementation<TypeTag, DiscretizationMethods::CCMpfa>
{
diff --git a/dumux/discretization/fluxvariablesbase.hh b/dumux/discretization/fluxvariablesbase.hh
index 5df9c1dfd89c798ac1e907fb9c0ced86d322398a..1de501c7a26fb301adae6a850d3929377cb89e3e 100644
--- a/dumux/discretization/fluxvariablesbase.hh
+++ b/dumux/discretization/fluxvariablesbase.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief Base class for the flux variables
+ * \ingroup Discretization
+ * \brief Base class for the flux variables living on a sub control volume face
*/
#ifndef DUMUX_DISCRETIZATION_FLUXVARIABLESBASE_HH
#define DUMUX_DISCRETIZATION_FLUXVARIABLESBASE_HH
@@ -28,23 +29,24 @@
namespace Dumux
{
+// forward declaration
template<class TypeTag, class UpwindScheme>
class FluxVariablesBaseImplementation;
/*!
* \ingroup Discretization
- * \brief The flux variables base class class
- * The upwind scheme is chosen depending on the discretization method
+ * \brief Base class for the flux variables living on a sub control volume face
+ * \note The upwind scheme is chosen depending on the discretization method
*/
template<class TypeTag>
using FluxVariablesBase = FluxVariablesBaseImplementation<TypeTag, UpwindScheme<TypeTag>>;
/*!
* \ingroup Discretization
- * \brief Implementation of the base class of the flux variables
+ * \brief Base class for the flux variables living on a sub control volume face
*
- * \param TypeTag The type tag
- * \param UpwindScheme The type used for the upwinding of the advective fluxes
+ * \tparam TypeTag The type tag
+ * \tparam UpwindScheme The type of the upwind scheme used for upwinding of advective fluxes
*/
template<class TypeTag, class UpwindScheme>
class FluxVariablesBaseImplementation
@@ -62,6 +64,7 @@ class FluxVariablesBaseImplementation
public:
+ //! Initialize the flux variables storing some temporary pointers
void init(const Problem& problem,
const Element& element,
const FVElementGeometry& fvGeometry,
diff --git a/dumux/discretization/fluxvariablescaching.hh b/dumux/discretization/fluxvariablescaching.hh
index cb4abf11eb71cf2e237835e5175441b2c1e8a592..b8168b61e9e3ac1250b1b86a9266c1471554ed9f 100644
--- a/dumux/discretization/fluxvariablescaching.hh
+++ b/dumux/discretization/fluxvariablescaching.hh
@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
+ * \ingroup Discretization
* \brief Classes related to flux variables caching
*/
#ifndef DUMUX_DISCRETIZATION_FLUXVAR_CACHING_HH
@@ -25,11 +26,11 @@
#include <dumux/common/properties.hh>
-namespace Dumux
-{
-
+namespace Dumux {
namespace FluxVariablesCaching {
+#ifndef DOXYGEN // hide the empty caches from doxygen
+
//! The empty filler class corresponding to EmptyCache
template<class TypeTag>
class EmptyCacheFiller
@@ -42,7 +43,7 @@ class EmptyCacheFiller
using SubControlVolumeFace = typename GET_PROP_TYPE(TypeTag, SubControlVolumeFace);
using FluxVariablesCache = typename GET_PROP_TYPE(TypeTag, FluxVariablesCache);
public:
- //! For advection filler
+ //! Fill, signature for advection filler
template<class FluxVariablesCacheFiller>
static void fill(FluxVariablesCache& scvfFluxVarsCache,
const Problem& problem,
@@ -53,7 +54,7 @@ public:
const FluxVariablesCacheFiller& fluxVarsCacheFiller)
{}
- //! For diffusion filler
+ //! Fill, signature for diffusion filler
template<class FluxVariablesCacheFiller>
static void fill(FluxVariablesCache& scvfFluxVarsCache,
unsigned int phaseIdx, unsigned int compIdx,
@@ -67,20 +68,21 @@ public:
};
// an empty cache filler
+// \note Never use the _EmptyCache directly as it lead to ambiguous definitions
template<class TypeTag> struct _EmptyCache
{ using Filler = EmptyCacheFiller<TypeTag>; };
+#endif // DOXYGEN
+
/*!
- * \ingroup ImplicitModel
- * \brief Empty caches to use in a law/process, e.g. Darcy's law
- * \note Never use the _EmptyCache directly as it lead to ambiguous definitions
+ * \ingroup Discretization
+ * \brief Empty caches to use in a constitutive flux law/process, e.g. Darcy's law
*/
template<class TypeTag> class EmptyAdvectionCache : public _EmptyCache<TypeTag> {};
template<class TypeTag> class EmptyDiffusionCache : public _EmptyCache<TypeTag> {};
template<class TypeTag> class EmptyHeatConductionCache : public _EmptyCache<TypeTag> {};
} // end namespace FluxVariablesCaching
-
} // end namespace Dumux
#endif
diff --git a/dumux/discretization/fourierslaw.hh b/dumux/discretization/fourierslaw.hh
index 1b674f59d40a44fdac975a7d8493f5de762e8415..ff5efe572860cac26bc03c419dfb39a3102389d1 100644
--- a/dumux/discretization/fourierslaw.hh
+++ b/dumux/discretization/fourierslaw.hh
@@ -18,7 +18,9 @@
*****************************************************************************/
/*!
* \file
- * \brief This file contains the data which is required to calculate
+ * \ingroup Discretization
+ * \brief Fourier's law specialized for different discretization schemes
+ * This file contains the data which is required to calculate
* diffusive mass fluxes due to molecular diffusion with Fourier's law.
*/
#ifndef DUMUX_DISCRETIZATION_FOURIERS_LAW_HH
@@ -27,15 +29,15 @@
#include <dumux/common/properties.hh>
#include <dumux/discretization/methods.hh>
-namespace Dumux
-{
+namespace Dumux {
+
// forward declaration
template <class TypeTag, DiscretizationMethods Method>
class FouriersLawImplementation
{};
/*!
- * \ingroup FouriersLaw
+ * \ingroup Discretization
* \brief Evaluates the heat conduction flux according to Fouriers's law
*/
template <class TypeTag>
diff --git a/dumux/discretization/fvgridvariables.hh b/dumux/discretization/fvgridvariables.hh
index 0f7d69e474d2590972851c6a367b6f8810e26993..926c8aa3dfce79a5be75d103bff6a402c9652981 100644
--- a/dumux/discretization/fvgridvariables.hh
+++ b/dumux/discretization/fvgridvariables.hh
@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief Class storing scv and scvf variables
+ * \ingroup Discretization
+ * \brief The grid variable class for finite volume schemes storing variables on scv and scvf (volume and flux variables)
*/
#ifndef DUMUX_FV_GRID_VARIABLES_HH
#define DUMUX_FV_GRID_VARIABLES_HH
@@ -30,7 +31,8 @@ namespace Dumux
{
/*!
- * \brief Class storing scv and scvf variables
+ * \ingroup Discretization
+ * \brief The grid variable class for finite volume schemes storing variables on scv and scvf (volume and flux variables)
*/
template<class TypeTag>
class FVGridVariables
@@ -42,7 +44,6 @@ class FVGridVariables
using SolutionVector = typename GET_PROP_TYPE(TypeTag, SolutionVector);
public:
- //! Constructor
FVGridVariables(std::shared_ptr<const Problem> problem,
std::shared_ptr<const FVGridGeometry> fvGridGeometry)
: problem_(problem)
@@ -85,8 +86,10 @@ public:
prevGridVolVars_.update(*fvGridGeometry_, initSol);
}
- //! Sets the current state as the previous for next time step
- //! this has to be called at the end of each time step
+ /*!
+ * \brief Sets the current state as the previous for next time step
+ * \note this has to be called at the end of each time step
+ */
void advanceTimeStep()
{
prevGridVolVars_ = curGridVolVars_;
@@ -102,34 +105,38 @@ public:
gridFluxVarsCache_.update(*fvGridGeometry_, curGridVolVars_, solution);
}
+ //! return the flux variables cache
const GridFluxVariablesCache& gridFluxVarsCache() const
{ return gridFluxVarsCache_; }
- const GridVolumeVariables& curGridVolVars() const
- { return curGridVolVars_; }
-
- const GridVolumeVariables& prevGridVolVars() const
- { return prevGridVolVars_; }
-
+ //! return the flux variables cache
GridFluxVariablesCache& gridFluxVarsCache()
{ return gridFluxVarsCache_; }
+ //! return the current volume variables
+ const GridVolumeVariables& curGridVolVars() const
+ { return curGridVolVars_; }
+
+ //! return the current volume variables
GridVolumeVariables& curGridVolVars()
{ return curGridVolVars_; }
+ //! return the volume variables of the previous time step (for instationary problems)
+ const GridVolumeVariables& prevGridVolVars() const
+ { return prevGridVolVars_; }
+
+ //! return the volume variables of the previous time step (for instationary problems)
GridVolumeVariables& prevGridVolVars()
{ return prevGridVolVars_; }
private:
- std::shared_ptr<const Problem> problem_;
- std::shared_ptr<const FVGridGeometry> fvGridGeometry_;
+ std::shared_ptr<const Problem> problem_; //!< pointer to the constant problem definition
+ std::shared_ptr<const FVGridGeometry> fvGridGeometry_; //!< pointer to the constant grid geometry
- // the current and previous variables (primary and secondary variables)
- GridVolumeVariables curGridVolVars_;
- GridVolumeVariables prevGridVolVars_;
+ GridVolumeVariables curGridVolVars_; //!< the current volume variables (primary and secondary variables)
+ GridVolumeVariables prevGridVolVars_; //!< the previous time step's volume variables (primary and secondary variables)
- // the flux variables cache vector vector
- GridFluxVariablesCache gridFluxVarsCache_;
+ GridFluxVariablesCache gridFluxVarsCache_; //!< the flux variables cache
};
} // end namespace Dumux
diff --git a/dumux/discretization/fvproperties.hh b/dumux/discretization/fvproperties.hh
index 2fe65eda292af480f0580a4c80c2a9a01898575f..56e2e5fe3b3ff4406cfd495ae7859c31b7924fd7 100644
--- a/dumux/discretization/fvproperties.hh
+++ b/dumux/discretization/fvproperties.hh
@@ -17,9 +17,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*****************************************************************************/
/*!
- * \ingroup Properties
* \file
- *
+ * \ingroup Discretization
* \brief Declares properties required for finite-volume models models.
*/
@@ -77,9 +76,9 @@ public:
using type = typename Dune::BCRSMatrix<MatrixBlock>;
};
-// set the block level to 1, suitable for e.g. a simple Dune::BCRSMatrix.
-// Set this to more than one if the matrix to solve is nested multiple times
-// e.g. for Dune::MultiTypeBlockMatrix'es. TODO: move to LinearAlgebra traits
+//! set the block level to 1, suitable for e.g. a simple Dune::BCRSMatrix.
+//! Set this to more than one if the matrix to solve is nested multiple times
+//! e.g. for Dune::MultiTypeBlockMatrix'es. TODO: move to LinearAlgebra traits
SET_INT_PROP(FiniteVolumeModel, LinearSolverPreconditionerBlockLevel, 1);
} // namespace Properties
diff --git a/dumux/discretization/methods.hh b/dumux/discretization/methods.hh
index 7648bcd42eb0623a4e1f2f77f53b8a301b8589f9..d6a216a4d350c9c04f0fb03fa8a1ece8525aa9b9 100644
--- a/dumux/discretization/methods.hh
+++ b/dumux/discretization/methods.hh
@@ -18,7 +18,7 @@
*****************************************************************************/
/*!
* \file
- *
+ * \ingroup Discretization
* \brief The available discretization methods in Dumux
*/
#ifndef DUMUX_DISCRETIZARION_METHODS_HH
@@ -26,10 +26,13 @@
namespace Dumux
{
- //! The discretization methods
- //! \note Use none if specifying a discretization method is required but
- //! the class in question is not specific to a a discretization method
- //! or the classification is non-applicable
+ /*!
+ * \brief The available discretization methods in Dumux
+ * \ingroup Discretization
+ * \note Use none if specifying a discretization method is required but
+ * the class in question is not specific to a a discretization method
+ * or the classification is non-applicable
+ */
enum class DiscretizationMethods : unsigned int
{
None, Box, CCTpfa, CCMpfa, Staggered
diff --git a/dumux/discretization/scvandscvfiterators.hh b/dumux/discretization/scvandscvfiterators.hh
index fc947d9e41a8d91b203c1e9c5e950bafdf070cb3..d37341e588bebce233467939ac19415259c4f9f3 100644
--- a/dumux/discretization/scvandscvfiterators.hh
+++ b/dumux/discretization/scvandscvfiterators.hh
@@ -18,8 +18,8 @@
*****************************************************************************/
/*!
* \file
- * \brief Class providing iterators over sub control volumes and sub control
- * volume faces of an element.
+ * \ingroup Discretization
+ * \brief Class providing iterators over sub control volumes and sub control volume faces of an element.
*/
#ifndef DUMUX_SCV_AND_SCVF_ITERATORS_HH
#define DUMUX_SCV_AND_SCVF_ITERATORS_HH
@@ -27,12 +27,12 @@
#include <dune/common/iteratorrange.hh>
#include <dune/common/iteratorfacades.hh>
-namespace Dumux
-{
+namespace Dumux {
/*!
* \ingroup Discretization
- * \brief An iterator over sub control volumes
+ * \brief Iterators over sub control volumes
+ * \note usage: for(const auto& scv : scvs(fvGeometry))
*/
template<class SubControlVolume, class Vector, class FVElementGeometry>
class ScvIterator : public Dune::ForwardIteratorFacade<ScvIterator<SubControlVolume,
@@ -46,9 +46,9 @@ public:
ScvIterator(const Iterator& it, const FVElementGeometry& fvGeometry)
: it_(it), fvGeometryPtr_(&fvGeometry) {}
- //! default constructor
ScvIterator() : it_(Iterator()), fvGeometryPtr_(nullptr) {}
+ //! dereferencing yields a subcontrol volume
const SubControlVolume& dereference() const
{
return fvGeometryPtr_->scv(*it_);
@@ -70,8 +70,9 @@ private:
};
/*!
- * \ingroup ImplcititModel
- * \brief An iterator over sub control volume faces
+ * \ingroup Discretization
+ * \brief Iterators over sub control volume faces of an fv geometry
+ * \note usage: for(const auto& scvf : scvfs(fvGeometry))
*/
template<class SubControlVolumeFace, class Vector, class FVElementGeometry>
class ScvfIterator : public Dune::ForwardIteratorFacade<ScvfIterator<SubControlVolumeFace,
@@ -85,9 +86,9 @@ public:
ScvfIterator(const Iterator& it, const FVElementGeometry& fvGeometry)
: it_(it), fvGeometryPtr_(&fvGeometry) {}
- //! default constructor
ScvfIterator() : it_(Iterator()), fvGeometryPtr_(nullptr) {}
+ //! dereferencing yields a subcontrol volume face
const SubControlVolumeFace& dereference() const
{
return fvGeometryPtr_->scvf(*it_);
diff --git a/dumux/discretization/scvoperator.hh b/dumux/discretization/scvoperator.hh
index 6f44a68a3f9d3756ca24ad3ce87241b8a986700b..2856fc6e570a744ab70ec7e6fc151fa371271534 100644
--- a/dumux/discretization/scvoperator.hh
+++ b/dumux/discretization/scvoperator.hh
@@ -19,7 +19,7 @@
/*!
* \file
*
- * \ingroup Material
+ * \ingroup Discretization
* \brief Class for the evaluation of primary variables and gradients on sub-control volumes.
*/
#ifndef DUMUX_SUBCONTROL_VOLUME_OPERATOR_HH
diff --git a/dumux/discretization/stationaryvelocityfield.hh b/dumux/discretization/stationaryvelocityfield.hh
index ec798f73aa7d5bb51126222d3458fca2948b555a..d7a304fa058c23d83646dd9be020c97d9de68958 100644
--- a/dumux/discretization/stationaryvelocityfield.hh
+++ b/dumux/discretization/stationaryvelocityfield.hh
@@ -18,7 +18,9 @@
*****************************************************************************/
/*!
* \file
- * \brief This file contains the data which is required to calculate
+ * \ingroup Discretization
+ * \brief Constant velocity advective law for transport models.
+ * This file contains the data which is required to calculate
* volume and mass fluxes of fluid phases over a face of a finite volume.
* A stationary velocity field is given by the user for use in tracer models.
*/
@@ -32,7 +34,7 @@
namespace Dumux
{
/*!
- * \ingroup StationaryVelocityField
+ * \ingroup Discretization
* \brief Evaluates a user given velocity field
*/
template <class TypeTag>
@@ -48,13 +50,13 @@ class StationaryVelocityField
using Element = typename GridView::template Codim<0>::Entity;
public:
- // state the discretization method this implementation belongs to
+ //! state the discretization method this implementation belongs to
static const DiscretizationMethods myDiscretizationMethod = DiscretizationMethods::None;
//! state the type for the corresponding cache
- //! We don't cache anything for this law
using Cache = FluxVariablesCaching::EmptyAdvectionCache<TypeTag>;
+ //! returns the volume flux given in the spatial params
static Scalar flux(const Problem& problem,
const Element& element,
const FVElementGeometry& fvGeometry,
diff --git a/dumux/discretization/subcontrolvolumebase.hh b/dumux/discretization/subcontrolvolumebase.hh
index 810fcee75948743594a6274100251b74fa2292a7..6479200dd3092c1199e10ca667411800ab824d1d 100644
--- a/dumux/discretization/subcontrolvolumebase.hh
+++ b/dumux/discretization/subcontrolvolumebase.hh
@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
+ * \ingroup Discretization
* \brief Base class for a sub control volume
*/
#ifndef DUMUX_SUBCONTROLVOLUME_HH
@@ -26,9 +27,11 @@
namespace Dumux
{
/*!
- * \ingroup ImplicitModel
+ * \ingroup Discretization
* \brief Base class for a sub control volume, i.e a part of the control
* volume we are making the balance for. Defines the general interface.
+ * \tparam Imp the implementation
+ * \tparam ScvGeometryTraits traits of this class
*/
template<class Imp, class ScvGeometryTraits>
class SubControlVolumeBase
@@ -61,7 +64,7 @@ public:
return asImp_().dofIndex();
}
- //! The index of the dof this scv is embedded in (box)
+ //! The index of the dof this scv is embedded in (box)
LocalIndexType indexInElement() const
{
return asImp_().indexInElement();
@@ -87,6 +90,6 @@ private:
{ return *static_cast<Implementation*>(this);}
};
-} // end namespace
+} // end namespace Dumux
#endif
diff --git a/dumux/discretization/subcontrolvolumefacebase.hh b/dumux/discretization/subcontrolvolumefacebase.hh
index 20bea52cbd63565764e1b0afad7901cbf5dd3332..3a19a7f0afa309084c7ca4da4f4936b69c790dd5 100644
--- a/dumux/discretization/subcontrolvolumefacebase.hh
+++ b/dumux/discretization/subcontrolvolumefacebase.hh
@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
+ * \ingroup Discretization
* \brief Base class for a sub control volume face
*/
#ifndef DUMUX_DISCRETIZATION_SUBCONTROLVOLUMEFACEBASE_HH
@@ -33,6 +34,8 @@ namespace Dumux
* \ingroup Discretization
* \brief Base class for a sub control volume face, i.e a part of the boundary
* of a sub control volume we computing a flux on.
+ * \tparam Imp the implementation
+ * \tparam ScvGeometryTraits traits of this class
*/
template<class Imp, class ScvfGeometryTraits>
class SubControlVolumeFaceBase
@@ -71,6 +74,7 @@ public:
return asImp_().boundary();
}
+ //! the unit outward pointing normal on the scv face
GlobalPosition unitOuterNormal() const
{
return asImp_().unitOuterNormal();
@@ -106,5 +110,4 @@ private:
} // end namespace Dumux
-
#endif
diff --git a/dumux/discretization/upwindscheme.hh b/dumux/discretization/upwindscheme.hh
index 620d1a03f96ba2e386c0e5d08216147ed9d4958e..38eb68b2299b36883176f3e61143c08bb56ab213 100644
--- a/dumux/discretization/upwindscheme.hh
+++ b/dumux/discretization/upwindscheme.hh
@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
+ * \ingroup Discretization
* \brief Base class for the upwind scheme
*/
#ifndef DUMUX_DISCRETIZATION_UPWINDSCHEME_HH
@@ -71,7 +72,7 @@ public:
}
};
-//! Upwind scheme for the cell-centered TPFA scheme
+//! Upwind scheme for the cell-centered tpfa scheme
template<class TypeTag>
class UpwindSchemeImplementation<TypeTag, DiscretizationMethods::CCTpfa>
{
@@ -185,7 +186,7 @@ public:
}
};
-//! Specialization for cell-centered MPFA schemes
+//! Upwind scheme for cell-centered mpfa schemes
template<class TypeTag>
class UpwindSchemeImplementation<TypeTag, DiscretizationMethods::CCMpfa>
: public UpwindSchemeImplementation<TypeTag, DiscretizationMethods::CCTpfa> {};
diff --git a/dumux/discretization/volumevariables.hh b/dumux/discretization/volumevariables.hh
index 304740e6f483dd9f629a141db9cab1ae4e5d68aa..b6e5056a1f7c84303e7c6b455d26ceb62e4dc110 100644
--- a/dumux/discretization/volumevariables.hh
+++ b/dumux/discretization/volumevariables.hh
@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
+ * \ingroup PorousMediumFlow
* \brief Base class for the model specific class which provides
* access to all volume averaged quantities.
*/