Commit c0779a22 authored by Dennis Gläser's avatar Dennis Gläser

Merge branch 'feature/gravity-mpfa' into 'next'

Feature/gravity mpfa

See merge request !710
parents 0b3198f9 26dfeee8
add_subdirectory("omethod")
install(FILES
computetransmissibility
connectivitymap.hh
darcyslaw.hh
dualgridindexset.hh
......@@ -18,6 +19,8 @@ helper.hh
interactionvolumebase.hh
interactionvolumedatahandle.hh
interactionvolume.hh
localassembler.hh
localfacedata.hh
methods.hh
properties.hh
subcontrolvolumeface.hh
......
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
* See the file COPYING for full copying permissions. *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* 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
* \ingroup CCMpfaDiscretization
* \brief This file contains free functions to evaluate the transmissibilities
* associated with flux evaluations across sub-control volume faces
* in the context of cell-centered Mpfa schemes.
*/
#ifndef DUMUX_DISCRETIZATION_CC_MPFA_COMPUTE_TRANSMISSIBILITY_HH
#define DUMUX_DISCRETIZATION_CC_MPFA_COMPUTE_TRANSMISSIBILITY_HH
#include <dune/common/typetraits.hh>
#include <dune/common/fvector.hh>
#include <dumux/common/math.hh>
namespace Dumux
{
/*!
* \ingroup CCMpfaDiscretization
* \brief Free function to evaluate the Mpfa 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.
*
* \param scv The iv-local sub-control volume
* \param scvf The grid sub-control volume face
* \param T The tensor living in the scv
* \param extrusionFactor The extrusion factor of the scv
*/
template<class Scv, class Scvf, class Tensor>
Dune::FieldVector< typename Tensor::field_type, Scv::myDimension >
computeMpfaTransmissibility(const Scv& scv,
const Scvf& scvf,
const Tensor& T,
typename Scv::ctype extrusionFactor)
{
Dune::FieldVector< typename Tensor::field_type, Scv::myDimension > wijk;
for (unsigned int dir = 0; dir < Scv::myDimension; ++dir)
wijk[dir] = vtmv(scvf.unitOuterNormal(), T, scv.nu(dir));
wijk *= scvf.area()*extrusionFactor;
wijk /= scv.detX();
return wijk;
}
/*!
* \ingroup CCMpfaDiscretization
* \brief Free function to evaluate the Mpfa 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, where T is a scalar.
*
* \param scv The iv-local sub-control volume
* \param scvf The grid sub-control volume face
* \param t the scalar quantity living in the scv
* \param extrusionFactor The extrusion factor of the scv
*/
template< class Scv,
class Scvf,
class Tensor,
std::enable_if_t< Dune::IsNumber<Tensor>::value, int > = 1 >
Dune::FieldVector<Tensor, Scv::myDimension>
computeMpfaTransmissibility(const Scv& scv,
const Scvf& scvf,
Tensor t,
typename Scv::ctype extrusionFactor)
{
Dune::FieldVector<Tensor, Scv::myDimension> wijk;
for (unsigned int dir = 0; dir < Scv::myDimension; ++dir)
wijk[dir] = vtmv(scvf.unitOuterNormal(), t, scv.nu(dir));
wijk *= scvf.area()*extrusionFactor;
wijk /= scv.detX();
return wijk;
}
} // end namespace Dumux
#endif
......@@ -18,8 +18,11 @@
*****************************************************************************/
/*!
* \file
* \ingroup CCMpfaDiscretization
* \brief Stores the face indices corresponding to the neighbors of an element
* that contribute to the derivative calculation
* that contribute to the derivative calculation. Depending on if an
* mpfa scheme leads to a symmetric/unsymmetric sparsity pattern, the
* adequate implementation of the connectiviy map is chosen.
*/
#ifndef DUMUX_CC_MPFA_CONNECTIVITY_MAP_HH
#define DUMUX_CC_MPFA_CONNECTIVITY_MAP_HH
......@@ -35,15 +38,15 @@ namespace Dumux
template<class TypeTag, MpfaMethods method>
class CCMpfaConnectivityMapImplementation;
// //! The Assembly map for models using mpfa methods
//! The Assembly map for models using mpfa methods
template<class TypeTag>
using CCMpfaConnectivityMap = CCMpfaConnectivityMapImplementation<TypeTag, GET_PROP_VALUE(TypeTag, MpfaMethod)>;
//! The default is the general assembly map for mpfa schemes
//! The default is the general assembly map for mpfa schemes (non-symmetric schemes)
template<class TypeTag, MpfaMethods method>
class CCMpfaConnectivityMapImplementation : public CCMpfaGeneralConnectivityMap<TypeTag> {};
//! The o-method can use the simple assembly map
//! The o-method can use the simple (symmetric) assembly map
template<class TypeTag>
class CCMpfaConnectivityMapImplementation<TypeTag, MpfaMethods::oMethod> : public CCSimpleConnectivityMap<TypeTag> {};
}
......
......@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
* \ingroup CCMpfaDiscretization
* \brief Stores the face indices corresponding to the neighbors of an element
* that contribute to the derivative calculation
*/
......@@ -34,7 +35,7 @@ namespace Dumux
{
/*!
* \ingroup CellCentered
* \ingroup CCMpfaDiscretization
* \brief General version of the assembly map for cellcentered schemes. To each
* cell I we store a list of cells J that are needed to compute the fluxes
* in these cells J that depend on cell I. Furthermore, we store for each cell J
......@@ -47,7 +48,7 @@ class CCMpfaGeneralConnectivityMap
using MpfaHelper = typename GET_PROP_TYPE(TypeTag, MpfaHelper);
using FVGridGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry);
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using IndexType = typename GridView::IndexSet::IndexType;
using GridIndexType = typename GridView::IndexSet::IndexType;
using FluxStencil = Dumux::FluxStencil<TypeTag>;
// To each cell "globalI" there will be a list of "globalJ", in which globalI is part
......@@ -55,9 +56,9 @@ class CCMpfaGeneralConnectivityMap
// additional scvfs which are needed temporarily to set up the transmissibilities of the scvfsJ
struct DataJ
{
IndexType globalJ;
std::vector<IndexType> scvfsJ;
std::vector<IndexType> additionalScvfs;
GridIndexType globalJ;
std::vector<GridIndexType> scvfsJ;
std::vector<GridIndexType> additionalScvfs;
};
using Map = std::vector<std::vector<DataJ>>;
......@@ -81,7 +82,7 @@ public:
fvGeometry.bindElement(element);
// obtain the data of J in elements I
std::vector<std::pair<IndexType, std::vector<DataJ>>> dataJForI;
std::vector<std::pair<GridIndexType, std::vector<DataJ>>> dataJForI;
// loop over sub control faces
for (auto&& scvf : scvfs(fvGeometry))
......@@ -111,7 +112,7 @@ public:
// land in the list of additional scvfs. Of that list we will delete those
// that are already in the list of scvfsJ later...
const auto scvfVectorAtVertex = MpfaHelper::getScvFacesAtVertex(scvf.vertexIndex(), element, fvGeometry);
std::vector<IndexType> scvfIndicesAtVertex(scvfVectorAtVertex.size());
std::vector<GridIndexType> scvfIndicesAtVertex(scvfVectorAtVertex.size());
for (std::size_t i = 0; i < scvfVectorAtVertex.size(); ++i)
scvfIndicesAtVertex[i] = scvfVectorAtVertex[i]->index();
globalJDataJ.additionalScvfs.insert(globalJDataJ.additionalScvfs.end(),
......@@ -131,7 +132,7 @@ public:
// if entry for globalJ2 does not exist yet, add globalJ2 to the J-data of globalI
// with an empty set of scvfs over which I and J are coupled (i.e. they aren't coupled)
if (it2 == it->second.end())
it->second.push_back(DataJ({globalJ2, std::vector<IndexType>()}));
it->second.push_back(DataJ({globalJ2, std::vector<GridIndexType>()}));
}
}
else
......@@ -139,13 +140,13 @@ public:
// No DataJ for globalI exists yet. Make it and insert data on the actual
// global J as first entry in the vector of DataJs belonging to globalI
dataJForI.emplace_back(std::make_pair(globalI,
std::vector<DataJ>({DataJ({globalJ, std::vector<IndexType>({scvf.index()})})})));
std::vector<DataJ>({DataJ({globalJ, std::vector<GridIndexType>({scvf.index()})})})));
// Also, all scvfs connected to a vertex together with the actual scvf
// land in the list of additional scvfs. Of that list we will delete those
// that are already in the list of scvfsJ later...
const auto scvfVectorAtVertex = MpfaHelper::getScvFacesAtVertex(scvf.vertexIndex(), element, fvGeometry);
std::vector<IndexType> scvfIndicesAtVertex(scvfVectorAtVertex.size());
std::vector<GridIndexType> scvfIndicesAtVertex(scvfVectorAtVertex.size());
for (unsigned int i = 0; i < scvfVectorAtVertex.size(); ++i)
scvfIndicesAtVertex[i] = scvfVectorAtVertex[i]->index();
dataJForI.back().second[0].additionalScvfs.insert(dataJForI.back().second[0].additionalScvfs.end(),
......@@ -155,7 +156,7 @@ public:
// all the other dofs in the stencil will be "globalJ" to globalI as well
for (auto globalJ2 : stencil)
if (globalJ2 != globalJ && globalJ2 != globalI)
dataJForI.back().second.push_back(DataJ({globalJ2, std::vector<IndexType>()}));
dataJForI.back().second.push_back(DataJ({globalJ2, std::vector<GridIndexType>()}));
}
}
}
......@@ -191,7 +192,8 @@ public:
}
}
const std::vector<DataJ>& operator[] (const IndexType globalI) const
//! Returns the assembly map of the element with given grid index
const std::vector<DataJ>& operator[] (const GridIndexType globalI) const
{ return map_[globalI]; }
private:
......
......@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
* \brief The global object of flux var caches
* \ingroup CCMpfaDiscretization
* \brief Flux variable caches on a gridview
*/
#ifndef DUMUX_DISCRETIZATION_CCMPFA_GRID_FLUXVARSCACHE_HH
#define DUMUX_DISCRETIZATION_CCMPFA_GRID_FLUXVARSCACHE_HH
......@@ -30,54 +31,56 @@ namespace Dumux
{
/*!
* \ingroup Mpfa
* \brief Base class for the flux variables cache vector, we store one cache per face
* \ingroup CCMpfaDiscretization
* \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 CCMpfaGridFluxVariablesCache;
/*!
* \ingroup Mpfa
* \brief Spezialization when caching globally
* \ingroup CCMpfaDiscretization
* \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 CCMpfaGridFluxVariablesCache<TypeTag, true>
{
// the flux variables cache filler needs to be friend to fill
// the interaction volumes and data handles
friend CCMpfaFluxVariablesCacheFiller<TypeTag>;
using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using Element = typename GridView::template Codim<0>::Entity;
using IndexType = typename GridView::IndexSet::IndexType;
using FVGridGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry);
using FVElementGeometry = typename GET_PROP_TYPE(TypeTag, FVElementGeometry);
using SolutionVector = typename GET_PROP_TYPE(TypeTag, SolutionVector);
using GridVolumeVariables = typename GET_PROP_TYPE(TypeTag, GridVolumeVariables);
using ElementVolumeVariables = typename GET_PROP_TYPE(TypeTag, ElementVolumeVariables);
using IndexType = typename GridView::IndexSet::IndexType;
using FluxVariablesCache = typename GET_PROP_TYPE(TypeTag, FluxVariablesCache);
using ElementFluxVariablesCache = typename GET_PROP_TYPE(TypeTag, ElementFluxVariablesCache);
using SubControlVolumeFace = typename GET_PROP_TYPE(TypeTag, SubControlVolumeFace);
using PrimaryInteractionVolume = typename GET_PROP_TYPE(TypeTag, PrimaryInteractionVolume);
using PrimaryIvDataHandle = typename PrimaryInteractionVolume::Traits::DataHandle;
using SecondaryInteractionVolume = typename GET_PROP_TYPE(TypeTag, SecondaryInteractionVolume);
using DataHandle = typename PrimaryInteractionVolume::Traits::DataHandle;
using SecondaryIvDataHandle = typename SecondaryInteractionVolume::Traits::DataHandle;
using FluxVariablesCacheFiller = CCMpfaFluxVariablesCacheFiller<TypeTag>;
public:
//! The constructor
CCMpfaGridFluxVariablesCache(const Problem& problem) : problemPtr_(&problem) {}
// When global caching is enabled, precompute transmissibilities for all scv faces
//! When global caching is enabled, precompute transmissibilities for all scv faces
void update(const FVGridGeometry& fvGridGeometry,
const GridVolumeVariables& gridVolVars,
const SolutionVector& sol,
bool forceUpdate = false)
{
// only do the update if fluxes are solution dependent or if update is forced
// Update only if the filler puts solution-dependent
// stuff into the caches or if update is enforced
if (FluxVariablesCacheFiller::isSolDependent || forceUpdate)
{
// clear data if forced update is desired
// clear previous data if forced update is desired
if (forceUpdate)
{
clear_();
......@@ -89,17 +92,20 @@ public:
secondaryInteractionVolumes_.reserve(numSecondaryIVs);
primaryIvDataHandles_.reserve(numPrimaryIvs);
secondaryIvDataHandles_.reserve(numSecondaryIVs);
}
// reserve memory estimate for caches, interaction volumes and corresponding data
fluxVarsCache_.resize(fvGridGeometry.numScvf());
// reserve memory estimate for caches, interaction volumes and corresponding data
fluxVarsCache_.resize(fvGridGeometry.numScvf());
}
// instantiate helper class to fill the caches
FluxVariablesCacheFiller filler(problem());
// set all the caches to "outdated"
for (auto& cache : fluxVarsCache_)
cache.setUpdateStatus(false);
for (const auto& element : elements(fvGridGeometry.gridView()))
{
// Prepare the geometries within the elements of the stencil
auto fvGeometry = localView(fvGridGeometry);
fvGeometry.bind(element);
......@@ -118,7 +124,8 @@ public:
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars)
{
// update only if transmissibilities are solution-dependent
// Update only if the filler puts
// solution-dependent stuff into the caches
if (FluxVariablesCacheFiller::isSolDependent)
{
const auto& fvGridGeometry = fvGeometry.fvGridGeometry();
......@@ -150,7 +157,6 @@ public:
auto& scvfCache = fluxVarsCache_[scvfIdx];
if (!scvfCache.isUpdated())
{
// update cache
const auto& scvf = fvGeometry.scvf(scvfIdx);
filler.fill(*this, scvfCache, elementJ, fvGeometry, elemVolVars, scvf);
}
......@@ -167,18 +173,52 @@ public:
friend inline ElementFluxVariablesCache localView(const CCMpfaGridFluxVariablesCache& global)
{ return ElementFluxVariablesCache(global); }
// access operators in the case of caching
//! access operators in the case of caching
const FluxVariablesCache& operator [](const SubControlVolumeFace& scvf) const
{ return fluxVarsCache_[scvf.index()]; }
//! access operators in the case of caching
FluxVariablesCache& operator [](const SubControlVolumeFace& scvf)
{ return fluxVarsCache_[scvf.index()]; }
//! access to the stored interaction volumes
const std::vector<PrimaryInteractionVolume>& primaryInteractionVolumes() const
{ return primaryInteractionVolumes_; }
//! access to the stored interaction volumes
std::vector<PrimaryInteractionVolume>& primaryInteractionVolumes()
{ return primaryInteractionVolumes_; }
//! access to the stored data handles
const std::vector<PrimaryIvDataHandle>& primaryDataHandles() const
{ return primaryIvDataHandles_; }
//! access to the stored data handles
std::vector<PrimaryIvDataHandle>& primaryDataHandles()
{ return primaryIvDataHandles_; }
//! access to the stored interaction volumes
const std::vector<SecondaryInteractionVolume>& secondaryInteractionVolumes() const
{ return secondaryInteractionVolumes_; }
//! access to the stored interaction volumes
std::vector<SecondaryInteractionVolume>& secondaryInteractionVolumes()
{ return secondaryInteractionVolumes_; }
//! access to the stored data handles
const std::vector<SecondaryIvDataHandle>& secondaryDataHandles() const
{ return secondaryIvDataHandles_; }
//! access to the stored data handles
std::vector<SecondaryIvDataHandle>& secondaryDataHandles()
{ return secondaryIvDataHandles_; }
const Problem& problem() const
{ return *problemPtr_; }
private:
//! clear all containers
void clear_()
{
fluxVarsCache_.clear();
......@@ -194,13 +234,13 @@ private:
// store the interaction volumes and handles
std::vector<PrimaryInteractionVolume> primaryInteractionVolumes_;
std::vector<SecondaryInteractionVolume> secondaryInteractionVolumes_;
std::vector<DataHandle> primaryIvDataHandles_;
std::vector<DataHandle> secondaryIvDataHandles_;
std::vector<PrimaryIvDataHandle> primaryIvDataHandles_;
std::vector<SecondaryIvDataHandle> secondaryIvDataHandles_;
};
/*!
* \ingroup ImplicitModel
* \brief Spezialization when not using global caching
* \ingroup CCMpfaDiscretization
* \brief Flux variable caches on a gridview with grid caching disabled
*/
template<class TypeTag>
class CCMpfaGridFluxVariablesCache<TypeTag, false>
......@@ -216,14 +256,16 @@ class CCMpfaGridFluxVariablesCache<TypeTag, false>
using ElementVolumeVariables = typename GET_PROP_TYPE(TypeTag, ElementVolumeVariables);
public:
//! The constructor
CCMpfaGridFluxVariablesCache(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) {}
......@@ -243,6 +285,6 @@ private:
const Problem* problemPtr_;
};
} // end namespace
} // end namespace Dumux
#endif
......@@ -18,6 +18,7 @@
*****************************************************************************/
/*!
* \file
* \ingroup CCMpfaDiscretization
* \brief Class for the grid interaction volume index sets of mpfa schemes.
*/
#ifndef DUMUX_DISCRETIZATION_MPFA_O_GRIDINTERACTIONVOLUME_INDEXSETS_HH
......@@ -26,34 +27,39 @@
#include <memory>
#include <dumux/common/properties.hh>
#include "dualgridindexset.hh"
namespace Dumux
{
// forward declaration
template<class TypeTag>
class CCMpfaDualGridIndexSet;
/*!
* \ingroup Mpfa
* \brief The grid interaction volume index sets class for the mpfa-o scheme.
* \ingroup CCMpfaDiscretization
* \brief Class that holds all interaction volume index sets on a grid view.
*/
template<class TypeTag>
class CCMpfaGridInteractionVolumeIndexSets
{
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using IndexType = typename GridView::IndexSet::IndexType;
using GridIndexType = typename GridView::IndexSet::IndexType;
using FVGridGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry);
using SubControlVolumeFace = typename GET_PROP_TYPE(TypeTag, SubControlVolumeFace);
using PrimaryIV = typename GET_PROP_TYPE(TypeTag, PrimaryInteractionVolume);
using PrimaryIVIndexSet = typename PrimaryIV::Traits::IndexSet;
using SecondaryIV = typename GET_PROP_TYPE(TypeTag, SecondaryInteractionVolume);
using SecondaryIVIndexSet = typename SecondaryIV::Traits::IndexSet;
using Helper = typename GET_PROP_TYPE(TypeTag, MpfaHelper);
using DualGridIndexSet = CCMpfaDualGridIndexSet<TypeTag>;
static const int dim = GridView::dimension;
static constexpr int dim = GridView::dimension;
using LocalIndexType = typename PrimaryIV::Traits::LocalIndexType;
using DualGridIndexSet = CCMpfaDualGridIndexSet< GridIndexType, LocalIndexType, dim>;
public:
/*!
* \brief Construct all interaction volume index sets on the grid view
*
* \param fvGridGeometry The finite volume geometry on the grid view
* \param dualGridIdSet The index sets of the dual grid on the grid view
*/
void update(FVGridGeometry& fvGridGeometry, DualGridIndexSet&& dualGridIdSet)
{
dualGridIndexSet_ = std::make_unique<DualGridIndexSet>(std::move(dualGridIdSet));
......@@ -91,32 +97,37 @@ public:
}
}
//! Return the iv index set in which a given scvf is embedded in
const PrimaryIVIndexSet& primaryIndexSet(const SubControlVolumeFace& scvf) const
{ return primaryIndexSet(scvf.index()); }
const PrimaryIVIndexSet& primaryIndexSet(const IndexType scvfIdx) const
//! Return the iv index set in which a given scvf (index) is embedded in
const PrimaryIVIndexSet& primaryIndexSet(const GridIndexType scvfIdx) const
{ return primaryIVIndexSets_[scvfIndexMap_[scvfIdx]]; }
//! Return the iv index set in which a given scvf is embedded in
const SecondaryIVIndexSet& secondaryIndexSet(const SubControlVolumeFace& scvf) const
{ return secondaryIndexSet(scvf.index()); }
const SecondaryIVIndexSet& secondaryIndexSet(const IndexType scvfIdx) const
//! Return the iv index set in which a given scvf (index) is embedded in
const SecondaryIVIndexSet& secondaryIndexSet(const GridIndexType scvfIdx) const
{ return secondaryIVIndexSets_[scvfIndexMap_[scvfIdx]]; }
//! Returns number of primary/secondary interaction volumes on the grid view
std::size_t numPrimaryInteractionVolumes() const { return numPrimaryIV_; }
std::size_t numSecondaryInteractionVolumes() const { return numSecondaryIV_; }
private:
std::vector<PrimaryIVIndexSet> primaryIVIndexSets_;
std::vector<SecondaryIVIndexSet> secondaryIVIndexSets_;
std::vector<IndexType> scvfIndexMap_;
std::vector<GridIndexType> scvfIndexMap_;
std::size_t numPrimaryIV_;
std::size_t numSecondaryIV_;
std::unique_ptr<DualGridIndexSet> dualGridIndexSet_;
};
} // end namespace
} // end namespace Dumux
#endif
......@@ -18,7 +18,8 @@
*****************************************************************************/
/*!
* \file
* \brief Base classes for interaction volume of mpfa methods.
* \ingroup CCMpfaDiscretization
* \brief Class used for interaction volumes in mpfa schemes.
*/
#ifndef DUMUX_DISCRETIZATION_CC_MPFA_INTERACTIONVOLUME_HH
#define DUMUX_DISCRETIZATION_CC_MPFA_INTERACTIONVOLUME_HH
......@@ -28,18 +29,20 @@
namespace Dumux
{
// forward declaration of the base class
// forward declaration of the method-specific implementation
template<class TypeTag, MpfaMethods MpfaMethod>
class CCMpfaInteractionVolumeImplementation;
/*!
* \ingroup Mpfa
* \brief Base class for the interaction volumes of the mpfa method
* \ingroup CCMpfaDiscretization
* \brief Alias to select the correct implementation of the interactionvolume
* volume. The implementations for the schemes have to be included below.
*/
template<class TypeTag>
using CCMpfaInteractionVolume = CCMpfaInteractionVolumeImplementation<TypeTag, GET_PROP_VALUE(TypeTag, MpfaMethod)>;
} // end namespace
} // end namespace Dumux
// the specializations of this class for the available methods have to be included here
#include <dumux/discretization/cellcentered/mpfa/omethod/interactionvolume.hh>
......
This diff is collapsed.
......@@ -18,17 +18,23 @@
*****************************************************************************/
/*!
* \file
* \brief Available implemented mpfa schemes
* \ingroup CCMpfaDiscretization
* \brief The available mpfa schemes in Dumux
*/
#ifndef DUMUX_DISCRETIZATION_CC_MPFA_METHODS_HH
#define DUMUX_DISCRETIZATION_CC_MPFA_METHODS_HH
namespace Dumux
{
/*!
* \brief The available mpfa schemes in Dumux
* \ingroup CCMpfaDiscretization
*/
enum class MpfaMethods : unsigned int
{
oMethod
};
} // end namespace
} // end namespace Dumux
#endif
install(FILES
helper.hh
interactionvolume.hh
interactionvolumeindexset.hh
localassembler.hh
localsubcontrolentities.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/discretization/cellcentered/mpfa/omethod)
......@@ -17,13 +17,11 @@
* 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 multi-point flux approximation.
* \ingroup CCMpfaDiscretization
* \brief Properties for all models using cell-centered finite volume scheme with mpfa
* \note Inherit from these properties to use a cell-centered finite volume scheme with mpfa
*/
#ifndef DUMUX_CC_MPFA_PROPERTIES_HH
#define DUMUX_CC_MPFA_PROPERTIES_HH
......