Commit db4e9b22 authored by Lukas Riedel's avatar Lukas Riedel

Merge branch '62-gradientfluxadapter-problem' into 'master'

Resolve "GradientFluxAdapter problem"

Closes #65 and #62

See merge request !105
parents 28a1c255 1c8fb414
......@@ -27,6 +27,7 @@
* Infrastructure for the input of Miller scaling fields. !110
* Add logging framework 'spdlog' as submodule !106
* Support input of boundary segmentations !119
* Reconstruction of continuous fluxes using RT finite elements !105
### Changed
* `Simulation` is renamed `RichardsSimulation` and moved to
......
......@@ -41,7 +41,7 @@ dune_enable_all_packages()
dune_require_cxx_standard(MODULE "dorie" VERSION 14)
# add subdirectories
add_subdirectory(plugins/vendor)
add_subdirectory("plugins/vendor")
add_subdirectory("m4")
add_subdirectory("cmake/modules")
add_subdirectory("python")
......
......@@ -47,6 +47,7 @@ dune_cmake_sphinx_doc(SPHINX_CONF ${CMAKE_CURRENT_SOURCE_DIR}/conf.py.in
man-config-file.rst
man-parameter-file.rst
man-grid.rst
man-fluxes.rst
MODULE_ONLY)
if(TARGET sphinx_html)
......
......@@ -241,6 +241,37 @@ adding an empty line, make text **bold** or ``monospaced``.
</parameter>
</category>
<category name="fluxReconstruction">
<parameter name="enable">
<definition> Apply the flux reconstruction method to the solved matric
head and obtain conservative gradients. It always computes
(internally) the local lifting independent whether the ``lifting``
keyword is active or not.
</definition>
<suggestion> true </suggestion>
<values> true, false </values>
</parameter>
<parameter name="checkJumps">
<definition> Check that flux reconstruction engine is creating conforming
normal fluxes up to ``jumpTol``. ProTip: Setting warnings together
with a very low tolerance will let you track the changes on the
quality of the flux reconstruction.
</definition>
<suggestion> none </suggestion>
<values> none, warn, error </values>
</parameter>
<parameter name="checkTol">
<definition> Whenever ``checkJumps`` is activated, it check that flux
reconstruction engine is creating conforming normal fluxes up to ``jumpTol``.
</definition>
<values> float &gt; 0 </values>
<suggestion> 1E-10 </suggestion>
</parameter>
</category>
<category name="NewtonParameters">
<parameter name="ForceIteration" hidden="true">
<definition> Force the Newton solver to calculate at least one iteration,
......
......@@ -38,12 +38,6 @@ adding an empty line, make text **bold** or ``monospaced``.
<values> trace, debug, info, warning, error, critical </values>
</parameter>
<parameter name="verbose">
<definition> Overall verbosity of the program </definition>
<suggestion> 0 </suggestion>
<values> 0, 1, 2, 3 </values>
</parameter>
<parameter name="outputPath">
<definition> Path to the directory where most of the outputs are stored.
DORiE will attempt to create it if it does not exist. </definition>
......@@ -208,4 +202,32 @@ adding an empty line, make text **bold** or ``monospaced``.
<suggestion> 0.8 </suggestion>
</parameter>
</category>
<category name="fluxReconstruction">
<parameter name="enable">
<definition> Apply the flux reconstruction method to the solved solute
concentration and obtain conservative fluxes.
</definition>
<suggestion> true </suggestion>
<values> true, false </values>
</parameter>
<parameter name="checkJumps">
<definition> Check that flux reconstruction engine is creating conforming
normal fluxes up to ``jumpTol``. ProTip: Setting warnings together
with a very low tolerance will let you track the changes on the
quality of the flux reconstruction.
</definition>
<suggestion> none </suggestion>
<values> none, warn, error </values>
</parameter>
<parameter name="checkTol">
<definition> Whenever ``checkJumps`` is activated, it check that flux
reconstruction engine is creating conforming normal fluxes up to ``jumpTol``.
</definition>
<values> float &gt; 0 </values>
<suggestion> 1E-10 </suggestion>
</parameter>
</category>
</dorie>
......@@ -21,4 +21,4 @@ USE_MATHJAX = YES
# EXCLUDE += @top_srcdir@/...
# Include documents with other extesions
FILE_PATTERNS += *.dox
FILE_PATTERNS += *.dox
\ No newline at end of file
......@@ -50,6 +50,7 @@ Manual
python-dorie-wrapper
man-config-file
man-grid
man-fluxes
man-bcfile
man-parameter-file
man-initial
......
......@@ -97,7 +97,6 @@ Executing the Program
Analyzing Results
-----------------
Examples
========
......
Fluxes
======
Depending on the application for what you want to use DORiE, there might be the case that it is needed something more elaborated than the default fluxes that DORiE provides. Therefore, this section explains how to interpret the default fluxes and the flux reconstruction technique used to solve solute transport problems.
Understanding the water flux output
-----------------------------------
Firstly, we have to recall that DORiE solves a Discontinuous Galerking finite element problem with *matric head* as unknown. It means that the solution of the *matric head* (and therefore the *water flux*) is continuous only element-wise, or in other words, it is discontinuous on the intersections between elements. On the other hand, the dG method solves *numerical fluxes* on the intersections between elements composed together with a penalty term that increases with respect to the discontinuity of the *matric head*. This ensures that the local solution is conservative while keeps the discontinuity as low as possible.
From the description above one can infer that one has to distinguish between *water fluxes* at the interior of each element and at the intersections of all elements (we call these intersections skeleton of the grid). Unfortunately, there is no a standard form to write the skeleton fluxes on formats like VTK and that's the main reason why DORiE only provides the interior fluxes. However, assuming one can write both fluxes into some output format, they are still discontinuous (notice that direct use of discontinuous fluxes are useless for conservative computations since the transported quantities are very likely to get stagnated or over-transported in the nearby of intersections between elements). It means that it is needed some sort of post-processing that ensures that the *water mass* is still locally and globally conserved.
.. DORiE allow finite volume computations under certain specific conditions. In such case, if generated, the raw flux output generated by DORiE has no meaning. The reason is that finite volumes are computed with finite elements of order 0 where gradients are 0.
Flux reconstruction
-------------------
The flux reconstruction is a projection of the fluxes used in the Discontinuous Galerkin method into a vector field function. Using correct elements, this procedure can ensure that fluxes in normal direction to the element are *equivalent* to those computed by the Discontinuous Galerkin method, and most importantly, it can also ensure the continuity of them. Hence, the resulting vector field is useful to compute other problems that rely on the fluxes of the water (i.e. solute transport).
The flux reconstruction technique always use Raviar Thomas finite elements of one degree less than the one set for the Richards model. It can be identified in the vtk file by the name ``flux_RT{k-1}``, where ``k`` is the finite element order set for the Richards model. Flux reconstruction is not available for non-conforming grids (i.e. Cube-adaptive grids).
+---------------------------+---+---+---+
| Richards FEorder | 1 | 2 | 3 |
+============+====+=========+===+===+===+
| | 2D | Simplex | ✓ | ✓ | ✓ |
| | +---------+---+---+---+
| | | Cube | ✓ | ✓ | ✓ |
| Non-adapt. +----+---------+---+---+---+
| | 3D | Simplex | ✓ | ✓ | ✓ |
| | +---------+---+---+---+
| | | Cube | ✓ | ✓ | |
+------------+----+---------+---+---+---+
| | 2D | Simplex | ✓ | ✓ | ✓ |
| | +---------+---+---+---+
| | | Cube | | | |
| Adapt. +----+---------+---+---+---+
| | 3D | Simplex | ✓ | ✓ | ✓ |
| | +---------+---+---+---+
| | | Cube | | | |
+------------+----+---------+---+---+---+
Usage
-----
To activate/deactivate flux reconstruction use the keyword ``richards.numeric.fluxReconstruction = true/false`` in the :doc:`config file<man-config-file>`.
add_subdirectory("flux_reconstruction")
add_subdirectory("finite_element")
#install headers
install(FILES
boundary_condition.hh
......
add_subdirectory("dg")
add_subdirectory("raviart_thomas_dg")
add_subdirectory("raviart_thomas_volume")
#install headers
install(FILES
raviart_thomas_dg_fem.hh
raviart_thomas_fem.hh
raviart_thomas_volume_fem.hh
skeleton_fem.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/dorie/common/finite_element)
\ No newline at end of file
#install headers
install(FILES
local_coefficients.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/dorie/common/finite_element/dg)
\ No newline at end of file
#ifndef DUNE_DORIE_DG_LOCAL_COEFFICIENTS_HH
#define DUNE_DORIE_DG_LOCAL_COEFFICIENTS_HH
#include <vector>
#include <dune/localfunctions/common/localkey.hh>
namespace Dune{
namespace Dorie{
/*-------------------------------------------------------------------------*//**
* @brief General local keys for dg finite elements.
*
* @author Santiago Ospina De Los Ríos
* @date 2018
* @ingroup FiniteElement
*/
class DGLocalCoefficients
{
public:
/*-----------------------------------------------------------------------*//**
* @brief Constructs the coeffcients.
* @details All locall keys are associated to codimension 0.
*
* @param[in] s The size of the local basis.
*/
DGLocalCoefficients(unsigned int s)
: _s(s), li(_s)
{
for (unsigned int i = 0; i < size(); ++i)
li[i] = Dune::LocalKey(0,0,i);
}
/*-----------------------------------------------------------------------*//**
* @brief Number of local coefficients
*
* @return The size of the local coefficients
*/
std::size_t size() const
{
return _s;
}
/**
* @brief Local key for a given index.
*
* @param[in] i The index that identifies a shape function.
*
* @return The local key associated to the index i. (see Dune:.LocalKey in
* dune-localfunctions)
*/
const LocalKey& localKey (std::size_t i) const
{
return li[i];
}
private:
//! The size.
std::size_t _s;
//! The vector of local keys.
std::vector<Dune::LocalKey> li;
};
} // namespace Dorie
} // namespace Dune
#endif // DUNE_DORIE_DG_LOCAL_COEFFICIENTS_HH
// These groups should gather information strongly related portions of the code.
// In them we aim to explain to other developers:
// - The rationale of the design
// - How careful someone has to be when modifying it
// - Specific naming or other conventions upheld in the code
/**
@defgroup FiniteElement Finite element
@{
@ingroup Common
@brief Collection of finite elements for DORiE
This group collects implementations of the different finite elements and
finite element maps not provided by dune-localfunctions and dune-pdelab
respectively.
### Raviart Thomas for flux reconstruction.
The finite elements for raviart thomas, for dg raviart thomas and for skeleton
are associated to the flux reconstruction methods and most of them shouldn't
are used to generate grid function spaces as is used to in dune-pdelab. When
modifying the Raviart Thomas dg take into a account that the local key is used
from a local map to global coefficients of the vector, it means that the dg
local keys use more memory while the non-dg don't because they (the non-dg)
share degrees of freedom in codimension 1. However, shared coefficients
(non-dg) need to be oriented to be able to represent continuity in grid
function spaces. Since orientation is not available in general for simpleces,
we have to enforce dg keys.
@}
**/
#install headers
install(FILES
local_finite_element.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/dorie/common/finite_element/raviart_thomas_dg)
\ No newline at end of file
#ifndef DUNE_DORIE_RAVIART_THOMAS_SIMPLEX_DG_LOCAL_FINITE_ELEMENT_HH
#define DUNE_DORIE_RAVIART_THOMAS_SIMPLEX_DG_LOCAL_FINITE_ELEMENT_HH
#include <dune/localfunctions/utility/localfiniteelement.hh>
#include <dune/localfunctions/raviartthomas/raviartthomassimplex.hh>
#include <dune/dorie/common/finite_element/dg/local_coefficients.hh>
namespace Dune{
namespace Dorie{
/*-------------------------------------------------------------------------*//**
* @brief Discontinuous Galerkin Raviart thomas for simplices
* @f$\mathcal{RT}_k^{dg}\f$.
* @details This class is equivalent to
* Dune::RaviartThomasSimplexLocalFiniteElement but with local keys
* corresponding to discontinuous galerkin methods, that is, all
* shape functions are associated to entities of codimension 0.
* @author Santiago Ospina De Los Ríos
* @date 2018
* @ingroup FiniteElement
* @see Dune::Dorie::DGLocalCoefficients
*
* @tparam dim World dimension.
* @tparam DF Domain field.
* @tparam RF Range field.
* @tparam SF Storage field for basis matrix.
* @tparam CF Compute field for basis matrix.
*/
template<unsigned int dim, class DF, class RF,class SF=RF, class CF=SF>
class RaviartThomasSimplexDGLocalFiniteElement
: public Dune::RaviartThomasSimplexLocalFiniteElement<dim,DF,RF,SF,CF>
{
using LocalCoefficients = Dune::Dorie::DGLocalCoefficients;
using Base = Dune::RaviartThomasSimplexLocalFiniteElement<dim,DF,RF,SF,CF>;
public:
using Traits = Dune::LocalFiniteElementTraits<
typename Base::Traits::LocalBasisType,
LocalCoefficients,
typename Base::Traits::LocalInterpolationType>;
/*-----------------------------------------------------------------------*//**
* @brief Constructor of the class.
*
* @param[in] gt Geometry type (only simplices).
* @param[in] k Order of the Raviart Thomas finite element.
*/
RaviartThomasSimplexDGLocalFiniteElement(
const Dune::GeometryType &gt,
unsigned int k
) : Base(gt, k)
, local_coefficients((dim == 2) ? (k+1)*(k+3) : (k+1)*(k+2)*(k+4)/2)
{
assert(gt.isSimplex());
}
/*-----------------------------------------------------------------------*//**
* @brief The local basis for this finite element.
* @see Dune::RaviartThomasSimplexLocalFiniteElement.
*
* @return The local basis.
*/
const typename Traits::LocalBasisType& localBasis () const
{
return Base::localBasis();
}
/*-----------------------------------------------------------------------*//**
* @brief The local coefficients for this finite element.
* @see Dune::Dorie::DGLocalCoefficients
*
* @return The local coefficients.
*/
const typename Traits::LocalCoefficientsType& localCoefficients () const
{
return local_coefficients;
}
/*-----------------------------------------------------------------------*//**
* @brief The local interpolation for this finite element.
* @see Dune::RaviartThomasSimplexLocalFiniteElement.
*
* @return The local interpolation.
*/
const typename Traits::LocalInterpolationType& localInterpolation () const
{
return Base::localInterpolation();
}
private:
LocalCoefficients local_coefficients;
};
} // namespace Dorie
} // namespace Dune
#endif // DUNE_DORIE_RAVIART_THOMAS_SIMPLEX_DG_LOCAL_FINITE_ELEMENT_HH
#ifndef DUNE_DORIE_RAVIART_THOMAS_DG_FEM_HH
#define DUNE_DORIE_RAVIART_THOMAS_DG_FEM_HH
#include <dune/pdelab/finiteelementmap/finiteelementmap.hh>
#include <dune/dorie/common/finite_element/raviart_thomas_dg/local_finite_element.hh>
namespace Dune{
namespace Dorie{
/**
* @brief Finite element map for discontinuous galerkin raviart thomas
* elements
* @f$\mathcal{RT}_k^{dg}\f$ in simplicies.
* @details This class implements a dune-pdelab finite element map
* Dune::Dorie::RaviartThomasSimplexDGLocalFiniteElement
*
* Available elements:
* <table> <tr> <th colspan="2">Order</th> <th>0</th> <th>1</th>
* <th>2</th> <th>3</th> </tr> <tr> <td>2D</td> <td>Simplex</td>
* <td>✓</td> <td>✓</td> <td>✓</td> <td>✓</td> </tr> <tr>
* <td>3D</td> <td>Simplex</td> <td>✓</td> <td>✓</td> <td>✓</td>
* <td>✓</td> </tr> </table>
*
* @author Santiago Ospina De Los Ríos
* @date 2018
* @ingroup FluxReconstruction
* @ingroup FiniteElement
*
* @tparam GV Grid view type.
* @tparam DF Domain field type.
* @tparam RF Range field type.
* @tparam k Order.
*/
template<class GV, class DF, class RF, std::size_t k>
class RaviartThomasSimplexDGLocalFiniteElementMap
: public Dune::PDELab::SimpleLocalFiniteElementMap<
Dune::Dorie::RaviartThomasSimplexDGLocalFiniteElement<GV::dimension,DF,RF>,
GV::dimension>
{
static constexpr unsigned int dim = GV::dimension;
static constexpr unsigned int size_face = Dune::PB::PkSize<k,dim-1>::value;
static constexpr unsigned int faces = dim+1;
static constexpr unsigned int size_skeleton = faces*size_face;
static constexpr unsigned int size_volume = (dim == 2)
? dim*k*(k+1)/2 // for 2D
: dim*k*(k+1)*(k+2)/6;// for 3D
static constexpr unsigned int size_rt = (dim == 2)
? (k+1)*(k+3) // for 2D
: (k+1)*(k+2)*(k+4)/2;// for 3D
// Just in case
static_assert((size_skeleton + size_volume) == size_rt,
"(size_skeleton + size_volume) != size_rt");
static_assert(dim == 2 || dim == 3,
"Raviart Thomas for simplices are only implemented for dimension 2 and 3!");
using FE = Dune::Dorie::
RaviartThomasSimplexDGLocalFiniteElement<GV::dimension,DF,RF>;
using Base = Dune::PDELab::SimpleLocalFiniteElementMap<FE,GV::dimension>;
public:
RaviartThomasSimplexDGLocalFiniteElementMap(const GV& gv)
: Base(FE(Dune::GeometryTypes::simplex(GV::dimension),k))
, _fe(Dune::GeometryTypes::simplex(GV::dimension),k)
{}
#ifdef DOXYGEN /* Documentation of the code */
/*-----------------------------------------------------------------------*//**
* @brief Return finite element for the given entity.
*
* @details The return value is a reference to Traits::FiniteElementType.
* If there is a different finite element for two elements then
* this type must be polymorphic. In this specific case, any
* entity maps to the same finite element.
*
* @param[in] e The entity that maps to the finite element.
*
* @tparam EntityType The type of the entity. Usually an entity as
* defined by dune-grid.
*
* @return The finite element associated to the entity e.
*/
template<class EntityType>
const typename Traits::FiniteElementType&
find (const EntityType& e);
#endif /* Documentation of the code */
/*-----------------------------------------------------------------------*//**
* @brief A FiniteElementMap is fixedSize iif the size of the local
* functions space for each GeometryType is fixed.
*
* @return A fixed size bool.
*/
static constexpr bool fixedSize()
{
return true;
}
/*-----------------------------------------------------------------------*//**
* @brief Return if FiniteElementMap has degrees of freedom for given
* codimension.
*
* @param[in] codim The codimension.
*
* @return True if has degreed of freedom for codimension codim, False
* otherwise.
*/
static constexpr bool hasDOFs(int codim)
{
return (codim == 0);
}
/*-----------------------------------------------------------------------*//**
* @brief If the FiniteElementMap is fixedSize, the size methods computes
* the number of DOFs for given GeometryType.
*
* @param[in] geometry_type The geometry type.
*
* @return The size of the fem for fixed size map.
*/
std::size_t size(GeometryType geometry_type) const
{
return (geometry_type.dim() == dim) ? _fe.size(): 0;
}
/*-----------------------------------------------------------------------*//**
* @brief Computes an upper bound for the local number of DOFs.
*
* @details This upper bound is used to avoid reallocations in std::vectors
* used during the assembly.
*
* @return The maximum local size of all finite elements used by the map.
*/
std::size_t maxLocalSize() const
{
return _fe.size();
}
private:
const FE _fe;
};
} // namespace Dorie
} // namespace Dune
#endif // DUNE_DORIE_RAVIART_THOMAS_DG_FEM_HH
#ifndef DUNE_DORIE_RAVIART_THOMAS_FEM_HH
#define DUNE_DORIE_RAVIART_THOMAS_FEM_HH
#include <dune/pdelab/finiteelementmap/raviartthomasfem.hh>
#include <dune/dorie/common/finite_element/raviart_thomas_dg_fem.hh>
namespace Dune{
namespace Dorie{
/*-------------------------------------------------------------------------*//**
* @brief Raviart thomas finite element map selector. It siwtches between
* dune-pdelab implementation and dorie/dune-localfunctions
* implementation
*
* @author Santiago Ospina De Los Ríos
* @date 2018
*
* @tparam GV Grid view.
* @tparam DF Domain field.
* @tparam RF Range field.
* @tparam k Order.
* @tparam gt Geometry type.
* @tparam <unnamed> Never instantiate this argument! Implementation
* detail: Curiously recurring template pattern is used
* to select the correct map.
*/
template<class GV, class DF, class RF, std::size_t k,
GeometryType::BasicType gt, class = void>
struct RaviartThomasLocalFiniteElementMapBaseSelector
{
using type = Dune::PDELab::RaviartThomasLocalFiniteElementMap<GV,DF,RF,k,gt>;
};
template<class GV, class DF, class RF, std::size_t k>
struct RaviartThomasLocalFiniteElementMapBaseSelector<
GV,DF,RF,k,GeometryType::simplex,
std::enable_if_t<(GV::dimension>2)>
>
{
// We have to use dg here because the original elements are not oriented!
using type = RaviartThomasSimplexDGLocalFiniteElementMap<GV,DF,RF,k>;
};
template<class GV, class DF, class RF, std::size_t k>
struct RaviartThomasLocalFiniteElementMapBaseSelector<
GV,DF,RF,k,GeometryType::simplex,
std::enable_if_t<(GV::dimension==2 && k>1)>
>
{
// We have to use dg here because the original elements are not oriented!
using type = RaviartThomasSimplexDGLocalFiniteElementMap<GV,DF,RF,k>;
};
/*-------------------------------------------------------------------------*//**
* @brief Finite element map for raviart thomas elements
* @f$\mathcal{RT}_k^{(dg)}\f$.
* @details This class is equivalent to
* Dune::PDELab::RaviartThomasLocalFiniteElementMap plus elements
* for raviart thomas in dg in simplices (see
* Dune::Dorie::RaviartThomasSimplexDGLocalFiniteElementMap). A big
* difference with the dune-pdelab map is that these extra elements
* are not oriented, which make them to be not conforming in normal
* direction. In other words, they cannot be used for conforming
* finite element approximations. Nevertheless they are still useful
* for flux reconstruction since we prescribe the continuity by
* using the numerical fluxes solved by the dG/FV methods.
*
* Available elements: <table> <tr> <th colspan="2">Order</th>
* <th>0</th> <th>1</th> <th>2</th> <th>3</th> </tr> <tr> <td
* rowspan="2"><br>2D</td> <td>Simplex</td> <td>✓</td> <td>✓</td>
* <td>✓</td> <td>✓ <SUP>&dagger;</SUP></td> </tr> <tr>
* <td>Cube</td> <td>✓</td> <td>✓</td> <td>✓</td> <td>✗</td> </tr>
* <tr> <td rowspan="2"><br>3D</td> <td>Simplex</td> <td>✓
* <SUP>&dagger;</SUP></td> <td>✓ <SUP>&dagger;</SUP></td> <td>✓
* <SUP>&dagger;</SUP></td> <td>✓ <SUP>&dagger;</SUP></td> </tr>
* <tr> <td>Cube</td> <td>✓</td> <td>✓</td> <td>✗</td> <td>✗</td>
* </tr> </table>
*
* &dagger;: Implemented with DG local coefficients (see
* Dune::Dorie::RaviartThomasSimplexDGLocalFiniteElement and
* Dune::Dorie::DGLocalCoefficients).
*
* @warning This map should not be used to solve finite element problems. For
* that purpose use the
* Dune::PDELab::RaviartThomasLocalFiniteElementMap class directly.
*
* @author Santiago Ospina De Los Ríos
* @date 2018
* @ingroup FluxReconstruction
* @ingroup FiniteElement
*
* @tparam GV The Gird view.
* @tparam DF The domain field.
* @tparam RF The range field.
* @tparam k The order.
* @tparam gt The geometry type.
* @tparam d The dimension.
*/
template<class GV, class DF, class RF, int k, Dune::GeometryType::BasicType gt>
class RaviartThomasLocalFiniteElementMap
: public Dune::PDELab::RaviartThomasLocalFiniteElementMap<GV,DF,RF,k,gt>
{
using Base = Dune::PDELab::RaviartThomasLocalFiniteElementMap<GV,DF,RF,k,gt>;
public:
RaviartThomasLocalFiniteElementMap(const GV& gv) : Base(gv) {}
};
template<class GV, class DF, class RF, int k>
class RaviartThomasLocalFiniteElementMap<GV,DF,RF,k,Dune::GeometryType::simplex>
: public Dune::Dorie::RaviartThomasLocalFiniteElementMapBaseSelector<
GV,DF,RF,k,Dune::GeometryType::simplex>::type
{
using Base = typename Dune::Dorie::
RaviartThomasLocalFiniteElementMapBaseSelector<
GV,DF,RF,k,Dune::GeometryType::simplex
>::type;
public:
/*-----------------------------------------------------------------------*//**
* @brief Constructor of the finite element map.
*
* @param[in] gv The grid view.
*/
RaviartThomasLocalFiniteElementMap(const GV& gv) : Base(gv) {}
};
} // namespace Dorie
} // namespace Dune
#endif // DUNE_DORIE_RAVIART_THOMAS_FEM_HH