12#ifndef DUMUX_DISCRETIZATION_FACECENTERED_STAGGERED_FV_GRID_GEOMETRY 
   13#define DUMUX_DISCRETIZATION_FACECENTERED_STAGGERED_FV_GRID_GEOMETRY 
   17#include <dune/common/rangeutilities.hh> 
   18#include <dune/grid/common/scsgmapper.hh> 
   48template<
class Gr
idView>
 
   57    template<
class Gr
idGeometry>
 
   60    template<
class Gr
idGeometry, 
bool enableCache>
 
   65        static constexpr auto dim = GridView::Grid::dimension;
 
 
 
   83template<
class GridView,
 
   84         bool cachingEnabled = 
false,
 
   94template<
class GV, 
class Traits>
 
  103    using Element = 
typename GV::template Codim<0>::Entity;
 
  106    using ConnectivityMap = 
typename Traits::template ConnectivityMap<ThisType>;
 
  108    using Scalar = 
typename GV::ctype;
 
  110    static constexpr auto dim = Traits::StaticInfo::dim;
 
  111    static constexpr auto numScvsPerElement = Traits::StaticInfo::numScvsPerElement;
 
  112    static constexpr auto numLateralScvfsPerScv = Traits::StaticInfo::numLateralScvfsPerScv;
 
  113    static constexpr auto numLateralScvfsPerElement = Traits::StaticInfo::numLateralScvfsPerElement;
 
  114    static constexpr auto minNumScvfsPerElement = Traits::StaticInfo::minNumScvfsPerElement;
 
  115    static constexpr auto maxNumScvfsPerElement = Traits::StaticInfo::maxNumScvfsPerElement;
 
  117    using ScvfCornerStorage = 
typename Traits::SubControlVolumeFace::Traits::CornerStorage;
 
  118    using ScvCornerStorage = 
typename Traits::SubControlVolume::Traits::CornerStorage;
 
  123    static constexpr DiscretizationMethod discMethod{};
 
  125    static constexpr bool cachingEnabled = 
true;
 
  130    using LocalView = 
typename Traits::template LocalView<ThisType, true>;
 
  132    using SubControlVolume = 
typename Traits::SubControlVolume;
 
  134    using SubControlVolumeFace = 
typename Traits::SubControlVolumeFace;
 
  138    using GeometryHelper = 
typename Traits::GeometryHelper;
 
  140    using LocalIntersectionMapper = 
typename Traits::LocalIntersectionMapper;
 
  142    using StaticInformation = 
typename Traits::StaticInfo;
 
  150    : ParentType(std::move(gg))
 
  151    , intersectionMapper_(this->gridView())
 
  152    , periodicGridTraits_(this->gridView().grid())
 
  156            DUNE_THROW(Dune::InvalidStateException, 
"The staggered discretization method needs overlap of exactly 1 for parallel computations. " 
  157                                                     << 
" Set the parameter \"Grid.Overlap\" in the input file.");
 
  163    FaceCenteredStaggeredFVGridGeometry(
const GridView& gridView, 
const std::string& paramGroup = 
"")
 
  164    : FaceCenteredStaggeredFVGridGeometry(std::make_shared<BasicGridGeometry>(gridView), paramGroup)
 
  168    std::size_t numScv()
 const 
  169    { 
return scvs_.size(); }
 
  172    std::size_t numScvf()
 const 
  173    { 
return scvfs_.size(); }
 
  176    std::size_t numBoundaryScv()
 const 
  177    { 
return numBoundaryScv_; }
 
  180    std::size_t numBoundaryScvf()
 const 
  181    { 
return numBoundaryScvf_; }
 
  184    std::size_t numIntersections()
 const 
  185    { 
return intersectionMapper_.numIntersections(); }
 
  188    std::size_t numDofs()
 const 
  189    { 
return this->gridView().size(1); }
 
  192    void update(
const GridView& gridView)
 
  194        ParentType::update(gridView);
 
  199    void update(GridView&& gridView)
 
  201        ParentType::update(std::move(gridView));
 
  206    const SubControlVolume& scv(GridIndexType scvIdx)
 const 
  207    { 
return scvs_[scvIdx]; }
 
  211    auto scvs(
const LocalView& fvGeometry)
 const 
  213        auto begin = scvs_.cbegin() + numScvsPerElement*fvGeometry.elementIndex();
 
  214        const auto end = begin + numScvsPerElement;
 
  215        return Dune::IteratorRange<std::decay_t<
decltype(begin)>>(begin, end);
 
  219    const SubControlVolumeFace& scvf(GridIndexType scvfIdx)
 const 
  220    { 
return scvfs_[scvfIdx]; }
 
  223    const std::vector<GridIndexType>& scvfIndicesOfElement(GridIndexType eIdx)
 const 
  224    { 
return scvfIndicesOfElement_[eIdx]; }
 
  230    const ConnectivityMap& connectivityMap()
 const 
  231    { 
return connectivityMap_; }
 
  234    bool hasBoundaryScvf(GridIndexType eIdx)
 const 
  235    { 
return hasBoundaryScvf_[eIdx]; }
 
  238    const IntersectionMapper& intersectionMapper()
 const 
  239    { 
return intersectionMapper_; }
 
  242    bool dofOnPeriodicBoundary(GridIndexType dofIdx)
 const 
  243    { 
return periodicFaceMap_.count(dofIdx); }
 
  246    GridIndexType periodicallyMappedDof(GridIndexType dofIdx)
 const 
  247    { 
return periodicFaceMap_.at(dofIdx); }
 
  250    const std::unordered_map<GridIndexType, GridIndexType>& periodicDofMap()
 const 
  251    { 
return periodicFaceMap_; }
 
  261        scvfIndicesOfElement_.clear();
 
  262        intersectionMapper_.update(this->gridView());
 
  265        const auto numElements = this->gridView().size(0);
 
  266        scvfIndicesOfElement_.resize(numElements);
 
  267        hasBoundaryScvf_.resize(numElements, 
false);
 
  269        outSideBoundaryVolVarIdx_ = 0;
 
  271        numBoundaryScvf_ = 0;
 
  273        GeometryHelper geometryHelper(this->gridView());
 
  276        GridIndexType numScvfs = 0;
 
  277        for (
const auto& element : elements(this->gridView()))
 
  279            assert(numScvsPerElement == 
element.subEntities(1));
 
  281            for (
const auto& intersection : intersections(this->gridView(), element))
 
  287                numScvfs += numLateralScvfsPerScv;
 
  290                if (onDomainBoundary_(intersection))
 
  293                    numBoundaryScv_ += numLateralScvfsPerScv; 
 
  302        const auto numScvs = numElements*numScvsPerElement;
 
  303        scvs_.resize(numScvs);
 
  304        scvfs_.reserve(numScvfs);
 
  307        std::size_t globalScvfIdx = 0;
 
  308        for (
const auto& element : elements(this->gridView()))
 
  310            const auto eIdx = this->elementMapper().index(element);
 
  311            auto& globalScvfIndices = scvfIndicesOfElement_[eIdx];
 
  312            globalScvfIndices.resize(minNumScvfsPerElement);
 
  313            globalScvfIndices.reserve(maxNumScvfsPerElement);
 
  315            auto getGlobalScvIdx = [&](
const auto elementIdx, 
const auto localScvIdx)
 
  316            { 
return numScvsPerElement*elementIdx + localScvIdx; };
 
  318            LocalIntersectionMapper localIsMapper;
 
  319            localIsMapper.update(this->gridView(), element);
 
  321            for (
const auto& intersection : intersections(this->gridView(), element))
 
  323                const auto& intersectionUnitOuterNormal = intersection.centerUnitOuterNormal();
 
  324                const auto localScvIdx = localIsMapper.realToRefIdx(intersection.indexInInside());
 
  325                auto localScvfIdx = localScvIdx*(1 + numLateralScvfsPerScv);
 
  327                const auto globalScvIdx = getGlobalScvIdx(eIdx, localScvIdx);
 
  328                const auto dofIndex = intersectionMapper().globalIntersectionIndex(element, intersection.indexInInside());
 
  329                const auto localOppositeScvIdx = geometryHelper.localOppositeIdx(localScvIdx);
 
  330                const auto& intersectionGeometry = intersection.geometry();
 
  331                const auto& elementGeometry = 
element.geometry();
 
  333                assert(localIsMapper.refToRealIdx(localScvIdx) == intersection.indexInInside());
 
  336                if (onPeriodicBoundary_(intersection))
 
  340                    const auto& otherElement = intersection.outside();
 
  342                    SmallLocalIndexType otherIntersectionLocalIdx = 0;
 
  343                    bool periodicFaceFound = 
false;
 
  345                    for (
const auto& otherIntersection : intersections(this->gridView(), otherElement))
 
  347                        if (periodicFaceFound)
 
  350                        if (Dune::FloatCmp::eq(intersectionUnitOuterNormal*otherIntersection.centerUnitOuterNormal(), -1.0, 1e-7))
 
  352                            const auto periodicDofIdx = intersectionMapper().globalIntersectionIndex(otherElement, otherIntersectionLocalIdx);
 
  353                            periodicFaceMap_[dofIndex] = periodicDofIdx;
 
  354                            periodicFaceFound = 
true;
 
  357                        ++otherIntersectionLocalIdx;
 
  362                scvs_[globalScvIdx] = SubControlVolume(
 
  364                    intersectionGeometry,
 
  369                    this->elementMapper().index(element),
 
  370                    onDomainBoundary_(intersection)
 
  374                scvfs_.emplace_back(elementGeometry,
 
  375                    intersectionGeometry,
 
  376                    std::array{globalScvIdx, getGlobalScvIdx(eIdx, localOppositeScvIdx)},
 
  379                    intersectionUnitOuterNormal,
 
  380                    SubControlVolumeFace::FaceType::frontal,
 
  381                    SubControlVolumeFace::BoundaryType::interior
 
  384                globalScvfIndices[localScvfIdx] = globalScvfIdx++;
 
  388                for (
const auto lateralFacetIndex : Dune::transformedRangeView(geometryHelper.localLaterFaceIndices(localScvIdx),
 
  389                                                                                [&](
auto&& idx) { return localIsMapper.refToRealIdx(idx) ;})
 
  392                    const auto& lateralIntersection = geometryHelper.intersection(lateralFacetIndex, element);
 
  395                    const auto globalScvIndicesForLateralFace = [&]
 
  397                        const auto globalOutsideScvIdx = [&]
 
  399                            if (lateralIntersection.neighbor())
 
  401                                const auto parallelElemIdx = this->elementMapper().index(lateralIntersection.outside());
 
  402                                return getGlobalScvIdx(parallelElemIdx, localScvIdx);
 
  404                            else if (onDomainBoundary_(lateralIntersection))
 
  405                                return numScvs + outSideBoundaryVolVarIdx_++;
 
  410                        return std::array{globalScvIdx, globalOutsideScvIdx};
 
  413                    const auto boundaryType = [&]
 
  415                        if (onProcessorBoundary_(lateralIntersection))
 
  416                            return SubControlVolumeFace::BoundaryType::processorBoundary;
 
  417                        else if (onDomainBoundary_(lateralIntersection))
 
  418                            return SubControlVolumeFace::BoundaryType::physicalBoundary;
 
  420                            return SubControlVolumeFace::BoundaryType::interior;
 
  425                        intersectionGeometry,
 
  426                        geometryHelper.facet(lateralFacetIndex, element).geometry(),
 
  427                        globalScvIndicesForLateralFace, 
 
  430                        lateralIntersection.centerUnitOuterNormal(),
 
  431                        SubControlVolumeFace::FaceType::lateral,
 
  435                    globalScvfIndices[localScvfIdx] = globalScvfIdx++;
 
  438                    if (onDomainBoundary_(lateralIntersection))
 
  441                        hasBoundaryScvf_[eIdx] = 
true;
 
  448            int localScvfIdx = minNumScvfsPerElement;
 
  449            for (
const auto& intersection : intersections(this->gridView(), element))
 
  452                if (onDomainBoundary_(intersection))
 
  454                    const auto localScvIdx = localIsMapper.realToRefIdx(intersection.indexInInside());
 
  455                    const auto globalScvIdx = getGlobalScvIdx(eIdx, localScvIdx);
 
  461                        intersection.geometry(),
 
  462                        std::array{globalScvIdx, globalScvIdx}, 
 
  465                        intersection.centerUnitOuterNormal(),
 
  466                        SubControlVolumeFace::FaceType::frontal,
 
  467                        SubControlVolumeFace::BoundaryType::physicalBoundary
 
  470                    globalScvfIndices.push_back(globalScvfIdx);
 
  473                    hasBoundaryScvf_[eIdx] = 
true;
 
  478        connectivityMap_.update(*
this);
 
  481    bool onDomainBoundary_(
const typename GridView::Intersection& intersection)
 const 
  483        return !intersection.neighbor() && intersection.boundary();
 
  486    bool onProcessorBoundary_(
const typename GridView::Intersection& intersection)
 const 
  488        return !intersection.neighbor() && !intersection.boundary();
 
  491    bool onPeriodicBoundary_(
const typename GridView::Intersection& intersection)
 const 
  493        return periodicGridTraits_.isPeriodic(intersection);
 
  497    ConnectivityMap connectivityMap_;
 
  498    IntersectionMapper intersectionMapper_;
 
  500    std::vector<SubControlVolume> scvs_;
 
  501    std::vector<SubControlVolumeFace> scvfs_;
 
  502    GridIndexType numBoundaryScv_;
 
  503    GridIndexType numBoundaryScvf_;
 
  504    GridIndexType outSideBoundaryVolVarIdx_;
 
  505    std::vector<bool> hasBoundaryScvf_;
 
  507    std::vector<std::vector<GridIndexType>> scvfIndicesOfElement_;
 
  510    std::unordered_map<GridIndexType, GridIndexType> periodicFaceMap_;
 
  512    PeriodicGridTraits<typename GridView::Grid> periodicGridTraits_;
 
  521template<
class GV, 
class Traits>
 
  525    using ThisType = FaceCenteredStaggeredFVGridGeometry<GV, false, Traits>;
 
  526    using ParentType = BaseGridGeometry<GV, Traits>;
 
  530    using Element = 
typename GV::template Codim<0>::Entity;
 
  532    using IntersectionMapper = 
typename Traits::IntersectionMapper;
 
  533    using ConnectivityMap = 
typename Traits::template ConnectivityMap<ThisType>;
 
  535    static constexpr auto dim = Traits::StaticInfo::dim;
 
  536    static constexpr auto numScvsPerElement = Traits::StaticInfo::numScvsPerElement;
 
  537    static constexpr auto numLateralScvfsPerScv = Traits::StaticInfo::numLateralScvfsPerScv;
 
  538    static constexpr auto numLateralScvfsPerElement = Traits::StaticInfo::numLateralScvfsPerElement;
 
  539    static constexpr auto minNumScvfsPerElement = Traits::StaticInfo::minNumScvfsPerElement;
 
  540    static constexpr auto maxNumScvfsPerElement = Traits::StaticInfo::maxNumScvfsPerElement;
 
  544    using DiscretizationMethod = DiscretizationMethods::FCStaggered;
 
  545    static constexpr DiscretizationMethod discMethod{};
 
  547    static constexpr bool cachingEnabled = 
false;
 
  552    using LocalView = 
typename Traits::template LocalView<ThisType, false>;
 
  554    using SubControlVolume = 
typename Traits::SubControlVolume;
 
  556    using SubControlVolumeFace = 
typename Traits::SubControlVolumeFace;
 
  560    using GeometryHelper = 
typename Traits::GeometryHelper;
 
  562    using LocalIntersectionMapper = 
typename Traits::LocalIntersectionMapper;
 
  564    using StaticInformation = 
typename Traits::StaticInfo;
 
  568    using SupportsPeriodicity = 
typename PeriodicGridTraits<typename GV::Grid>::SupportsPeriodicity;
 
  571    FaceCenteredStaggeredFVGridGeometry(std::shared_ptr<BasicGridGeometry> gg, 
const std::string& paramGroup = 
"")
 
  572    : ParentType(std::move(gg))
 
  573    , intersectionMapper_(this->gridView())
 
  574    , periodicGridTraits_(this->gridView().grid())
 
  578            DUNE_THROW(Dune::InvalidStateException, 
"The staggered discretization method needs at least an overlap of 1 for parallel computations. " 
  579                                                     << 
" Set the parameter \"Grid.Overlap\" in the input file.");
 
  585    FaceCenteredStaggeredFVGridGeometry(
const GridView& gridView, 
const std::string& paramGroup = 
"")
 
  586    : FaceCenteredStaggeredFVGridGeometry(std::make_shared<BasicGridGeometry>(gridView), paramGroup)
 
  590    std::size_t numScv()
 const 
  594    std::size_t numScvf()
 const 
  598    std::size_t numBoundaryScv()
 const 
  599    { 
return numBoundaryScv_; }
 
  602    std::size_t numBoundaryScvf()
 const 
  603    { 
return numBoundaryScvf_; }
 
  606    std::size_t numIntersections()
 const 
  607    { 
return intersectionMapper_.numIntersections(); }
 
  610    std::size_t numDofs()
 const 
  611    { 
return this->gridView().size(1); }
 
  617    const ConnectivityMap& connectivityMap()
 const 
  618    { 
return connectivityMap_; }
 
  621    bool hasBoundaryScvf(GridIndexType eIdx)
 const 
  622    { 
return hasBoundaryScvf_[eIdx]; }
 
  625    const IntersectionMapper& intersectionMapper()
 const 
  626    { 
return intersectionMapper_; }
 
  629    const std::vector<GridIndexType>& scvfIndicesOfElement(GridIndexType eIdx)
 const 
  630    { 
return scvfIndicesOfElement_[eIdx]; }
 
  633    GridIndexType outsideVolVarIndex(GridIndexType scvfIdx)
 const 
  634    { 
return outsideVolVarIndices_.at(scvfIdx); }
 
  637    void update(
const GridView& gridView)
 
  639        ParentType::update(gridView);
 
  644    void update(GridView&& gridView)
 
  646        ParentType::update(std::move(gridView));
 
  651    bool dofOnPeriodicBoundary(GridIndexType dofIdx)
 const 
  652    { 
return periodicFaceMap_.count(dofIdx); }
 
  655    GridIndexType periodicallyMappedDof(GridIndexType dofIdx)
 const 
  656    { 
return periodicFaceMap_.at(dofIdx); }
 
  659    const std::unordered_map<GridIndexType, GridIndexType>& periodicDofMap()
 const 
  660    { 
return periodicFaceMap_; }
 
  666        intersectionMapper_.update(this->gridView());
 
  671        numBoundaryScvf_ = 0;
 
  672        hasBoundaryScvf_.clear();
 
  673        scvfIndicesOfElement_.clear();
 
  674        outsideVolVarIndices_.clear();
 
  677        const auto numElements = this->gridView().size(0);
 
  678        scvfIndicesOfElement_.resize(numElements);
 
  679        hasBoundaryScvf_.resize(numElements, 
false);
 
  680        numScvs_ = numElements*numScvsPerElement;
 
  682        GeometryHelper geometryHelper(this->gridView());
 
  685        GridIndexType scvfIdx = 0;
 
  687        GridIndexType neighborVolVarIdx = numScvs_;
 
  689        for (
const auto& element : elements(this->gridView()))
 
  691            const auto eIdx = this->elementMapper().index(element);
 
  692            assert(numScvsPerElement == 
element.subEntities(1));
 
  695            auto& globalScvfIndices = scvfIndicesOfElement_[eIdx];
 
  696            globalScvfIndices.reserve(maxNumScvfsPerElement);
 
  697            globalScvfIndices.resize(minNumScvfsPerElement);
 
  700            std::size_t numFrontalBoundaryScvfs = 0;
 
  703            LocalIntersectionIndexMapper localIsMapper;
 
  704            localIsMapper.update(this->gridView(), element);
 
  706            for (
const auto& intersection : intersections(this->gridView(), element))
 
  708                const auto localScvIdx = localIsMapper.realToRefIdx(intersection.indexInInside());
 
  709                auto localScvfIdx = localScvIdx*(1 + numLateralScvfsPerScv);
 
  711                assert(localIsMapper.refToRealIdx(localScvIdx) == intersection.indexInInside());
 
  713                globalScvfIndices[localScvfIdx] = scvfIdx++;
 
  716                if constexpr(dim > 1)
 
  719                    for (
const auto lateralFacetIndex : Dune::transformedRangeView(geometryHelper.localLaterFaceIndices(localScvIdx),
 
  720                                                                                   [&](
auto idx) { return localIsMapper.refToRealIdx(idx) ;})
 
  723                        if (onDomainBoundary_(geometryHelper.intersection(lateralFacetIndex, element)))
 
  725                            outsideVolVarIndices_[scvfIdx] = neighborVolVarIdx++;
 
  727                            hasBoundaryScvf_[eIdx] = 
true;
 
  730                        globalScvfIndices[localScvfIdx] = scvfIdx++;
 
  736                if (onDomainBoundary_(intersection))
 
  739                    numBoundaryScv_ += numLateralScvfsPerScv; 
 
  740                    ++numFrontalBoundaryScvfs;
 
  742                    hasBoundaryScvf_[eIdx] = 
true;
 
  746                if (onPeriodicBoundary_(intersection))
 
  750                    const auto& otherElement = intersection.outside();
 
  752                    SmallLocalIndexType otherIntersectionLocalIdx = 0;
 
  753                    bool periodicFaceFound = 
false;
 
  755                    for (
const auto& otherIntersection : intersections(this->gridView(), otherElement))
 
  757                        if (periodicFaceFound)
 
  760                        if (Dune::FloatCmp::eq(intersection.centerUnitOuterNormal()*otherIntersection.centerUnitOuterNormal(), -1.0, 1e-7))
 
  762                            const auto periodicDofIdx = intersectionMapper().globalIntersectionIndex(otherElement, otherIntersectionLocalIdx);
 
  763                            const auto dofIndex = intersectionMapper().globalIntersectionIndex(element, localScvIdx);
 
  764                            periodicFaceMap_[dofIndex] = periodicDofIdx;
 
  765                            periodicFaceFound = 
true;
 
  768                        ++otherIntersectionLocalIdx;
 
  774            for (std::size_t i = 0; i < numFrontalBoundaryScvfs; ++i)
 
  775                globalScvfIndices.push_back(scvfIdx++);
 
  781        connectivityMap_.update(*
this);
 
  784    bool onDomainBoundary_(
const typename GridView::Intersection& intersection)
 const 
  786        return !intersection.neighbor() && intersection.boundary();
 
  789    bool onProcessorBoundary_(
const typename GridView::Intersection& intersection)
 const 
  791        return !intersection.neighbor() && !intersection.boundary();
 
  794    bool onPeriodicBoundary_(
const typename GridView::Intersection& intersection)
 const 
  796        return periodicGridTraits_.isPeriodic(intersection);
 
  800    ConnectivityMap connectivityMap_;
 
  801    IntersectionMapper intersectionMapper_;
 
  804    std::size_t numScvs_;
 
  805    std::size_t numScvf_;
 
  806    std::size_t numBoundaryScv_;
 
  807    std::size_t numBoundaryScvf_;
 
  808    std::vector<bool> hasBoundaryScvf_;
 
  810    std::vector<std::vector<GridIndexType>> scvfIndicesOfElement_;
 
  813    std::unordered_map<GridIndexType, GridIndexType> periodicFaceMap_;
 
  814    std::unordered_map<GridIndexType, GridIndexType> outsideVolVarIndices_;
 
  816    PeriodicGridTraits<typename GridView::Grid> periodicGridTraits_;
 
Base class for grid geometries.
Check the overlap size for different discretization methods.
Base class for all grid geometries.
Definition basegridgeometry.hh:52
An implementation of a grid geometry with some basic features.
Definition basicgridgeometry.hh:37
Traits extracting the public Extrusion type from T Defaults to NoExtrusion if no such type is found.
Definition extrusion.hh:155
Stores the dof indices corresponding to the neighboring scvs that contribute to the derivative calcul...
Definition facecentered/staggered/connectivitymap.hh:30
Definition discretization/facecentered/staggered/fvelementgeometry.hh:124
Base class for the finite volume geometry vector for face-centered staggered models This builds up th...
Definition discretization/facecentered/staggered/fvgridgeometry.hh:86
Face centered staggered geometry helper.
Definition discretization/facecentered/staggered/geometryhelper.hh:28
Face centered staggered sub control volume face.
Definition discretization/facecentered/staggered/subcontrolvolumeface.hh:54
Face centered staggered sub control volume.
Definition discretization/facecentered/staggered/subcontrolvolume.hh:52
defines an intersection mapper for mapping of global DOFs assigned to faces which also works for adap...
Definition intersectionmapper.hh:200
Definition periodicgridtraits.hh:121
Defines the default element and vertex mapper types.
Geometry helper for face-centered staggered scheme.
Face centered staggered sub control volume.
Face centered staggered sub control volume face.
Helper classes to compute the integration elements.
Stores the dof indices corresponding to the neighboring scvs that contribute to the derivative calcul...
Dune::Std::detected_or_t< Dumux::BasicGridGeometry< GV, typename T::ElementMapper, typename T::VertexMapper >, Detail::SpecifiesBaseGridGeometry, T > BasicGridGeometry_t
Type of the basic grid geometry implementation used as backend.
Definition basegridgeometry.hh:38
Detail::FaceCenteredStaggeredLocalIntersectionIndexMapper< GridView, ConsistentlyOrientedGrid< typename GridView::Grid >{}> FaceCenteredStaggeredLocalIntersectionIndexMapper
Provides a mapping of local intersection indices (indexInInside) such that the local indices always f...
Definition localintersectionindexmapper.hh:116
static std::size_t normalAxis(const Vector &v)
Returns the normal axis index of a unit vector (0 = x, 1 = y, 2 = z)
Definition normalaxis.hh:26
defines intersection mappers.
Provides a mapping of local intersection indices (indexInInside) such that the local indices always f...
Define some often used mathematical functions.
The available discretization methods in Dumux.
typename Extrusion< T >::type Extrusion_t
Convenience alias for obtaining the extrusion type.
Definition extrusion.hh:166
Base class for the finite volume geometry vector for face-centered staggered models This builds up th...
Grid properties related to periodicity.
static bool isValid(const GridView &gridView) noexcept
Definition checkoverlapsize.hh:30
Definition defaultmappertraits.hh:23
Definition discretization/facecentered/staggered/fvgridgeometry.hh:64
static constexpr auto numLateralScvfsPerElement
Definition discretization/facecentered/staggered/fvgridgeometry.hh:69
static constexpr auto maxNumScvfsPerElement
Definition discretization/facecentered/staggered/fvgridgeometry.hh:72
static constexpr auto numScvsPerElement
Definition discretization/facecentered/staggered/fvgridgeometry.hh:67
static constexpr auto numFacesPerElement
Definition discretization/facecentered/staggered/fvgridgeometry.hh:66
static constexpr auto dim
Definition discretization/facecentered/staggered/fvgridgeometry.hh:65
static constexpr auto numLateralScvfsPerScv
Definition discretization/facecentered/staggered/fvgridgeometry.hh:68
static constexpr auto minNumScvfsPerElement
Definition discretization/facecentered/staggered/fvgridgeometry.hh:70
The default traits for the face-center staggered finite volume grid geometry Defines the scv and scvf...
Definition discretization/facecentered/staggered/fvgridgeometry.hh:50
ConformingGridIntersectionMapper< GridView > IntersectionMapper
Definition discretization/facecentered/staggered/fvgridgeometry.hh:53
FaceCenteredStaggeredGeometryHelper< GridView > GeometryHelper
Definition discretization/facecentered/staggered/fvgridgeometry.hh:55
FaceCenteredStaggeredFVElementGeometry< GridGeometry, enableCache > LocalView
Definition discretization/facecentered/staggered/fvgridgeometry.hh:61
FaceCenteredStaggeredSubControlVolumeFace< GridView > SubControlVolumeFace
Definition discretization/facecentered/staggered/fvgridgeometry.hh:52
FaceCenteredStaggeredConnectivityMap< GridGeometry > ConnectivityMap
Definition discretization/facecentered/staggered/fvgridgeometry.hh:58
FaceCenteredStaggeredSubControlVolume< GridView > SubControlVolume
Definition discretization/facecentered/staggered/fvgridgeometry.hh:51
FaceCenteredStaggeredLocalIntersectionIndexMapper< GridView > LocalIntersectionMapper
Definition discretization/facecentered/staggered/fvgridgeometry.hh:54
typename GridView::IndexSet::IndexType GridIndex
Definition indextraits.hh:27
std::uint_least8_t SmallLocalIndex
Definition indextraits.hh:29
unsigned int LocalIndex
Definition indextraits.hh:28
Definition periodicgridtraits.hh:34