doxygen/master/discretization_2box_2fvgridgeometry_8hh_source.html

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-

// vi: set et ts=4 sw=4 sts=4:

//

// SPDX-FileCopyrightText: Copyright © DuMux Project contributors, see AUTHORS.md in root folder

// SPDX-License-Identifier: GPL-3.0-or-later

//

#ifndef DUMUX_DISCRETIZATION_BOX_GRID_FVGEOMETRY_HH

#define DUMUX_DISCRETIZATION_BOX_GRID_FVGEOMETRY_HH


#include <utility>

#include <unordered_map>

#include <array>

#include <vector>


#include <dune/localfunctions/lagrange/lagrangelfecache.hh>


#include <dumux/discretization/method.hh>

#include <dumux/common/indextraits.hh>

#include <dumux/common/defaultmappertraits.hh>

#include <dumux/discretization/basegridgeometry.hh>

#include <dumux/discretization/box/boxgeometryhelper.hh>

#include <dumux/discretization/box/fvelementgeometry.hh>

#include <dumux/discretization/box/subcontrolvolume.hh>

#include <dumux/discretization/box/subcontrolvolumeface.hh>

#include <dumux/discretization/extrusion.hh>


#include <dumux/io/grid/periodicgridtraits.hh>


namespace Dumux {


namespace Detail {

template<class GV, class T>

using BoxGeometryHelper_t = Dune::Std::detected_or_t<

    Dumux::BoxGeometryHelper<GV, GV::dimension, typename T::SubControlVolume, typename T::SubControlVolumeFace>,

    SpecifiesGeometryHelper,

    T

>;

} // end namespace Detail


template<class GridView, class MapperTraits = DefaultMapperTraits<GridView>>

struct BoxDefaultGridGeometryTraits

: public MapperTraits

{

    using SubControlVolume = BoxSubControlVolume<GridView>;

    using SubControlVolumeFace = BoxSubControlVolumeFace<GridView>;


    template<class GridGeometry, bool enableCache>

    using LocalView = BoxFVElementGeometry<GridGeometry, enableCache>;

};


template<class Scalar,

         class GridView,

         bool enableGridGeometryCache = false,

         class Traits = BoxDefaultGridGeometryTraits<GridView> >

class BoxFVGridGeometry;


template<class Scalar, class GV, class Traits>

class BoxFVGridGeometry<Scalar, GV, true, Traits>

: public BaseGridGeometry<GV, Traits>

{

    using ThisType = BoxFVGridGeometry<Scalar, GV, true, Traits>;

    using ParentType = BaseGridGeometry<GV, Traits>;

    using GridIndexType = typename IndexTraits<GV>::GridIndex;

    using LocalIndexType = typename IndexTraits<GV>::LocalIndex;


    using Element = typename GV::template Codim<0>::Entity;

    using CoordScalar = typename GV::ctype;

    static const int dim = GV::dimension;

    static const int dimWorld = GV::dimensionworld;


public:

    using DiscretizationMethod = DiscretizationMethods::Box;

    static constexpr DiscretizationMethod discMethod{};


    using BasicGridGeometry = BasicGridGeometry_t<GV, Traits>;

    using LocalView = typename Traits::template LocalView<ThisType, true>;

    using SubControlVolume = typename Traits::SubControlVolume;

    using SubControlVolumeFace = typename Traits::SubControlVolumeFace;

    using Extrusion = Extrusion_t<Traits>;

    using DofMapper = typename Traits::VertexMapper;

    using FeCache = Dune::LagrangeLocalFiniteElementCache<CoordScalar, Scalar, dim, 1>;

    using GridView = GV;

    using SupportsPeriodicity = typename PeriodicGridTraits<typename GV::Grid>::SupportsPeriodicity;


    BoxFVGridGeometry(std::shared_ptr<BasicGridGeometry> gg)

    : ParentType(std::move(gg))

    , cache_(*this)

    , periodicGridTraits_(this->gridView().grid())

    {

        update_();

    }


    BoxFVGridGeometry(const GridView& gridView)

    : BoxFVGridGeometry(std::make_shared<BasicGridGeometry>(gridView))

    {}


    const DofMapper& dofMapper() const

    { return this->vertexMapper(); }


    std::size_t numScv() const

    {  return numScv_; }


    std::size_t numScvf() const

    { return numScvf_; }


    std::size_t numBoundaryScvf() const

    { return numBoundaryScvf_; }


    std::size_t numDofs() const

    { return this->vertexMapper().size(); }


    void update(const GridView& gridView)

    {

        ParentType::update(gridView);

        update_();

    }


    void update(GridView&& gridView)

    {

        ParentType::update(std::move(gridView));

        update_();

    }


    const FeCache& feCache() const

    { return feCache_; }


    bool dofOnBoundary(GridIndexType dofIdx) const

    { return boundaryDofIndices_[dofIdx]; }


    bool dofOnPeriodicBoundary(GridIndexType dofIdx) const

    { return periodicDofMap_.count(dofIdx); }


    GridIndexType periodicallyMappedDof(GridIndexType dofIdx) const

    { return periodicDofMap_.at(dofIdx); }


    const std::unordered_map<GridIndexType, GridIndexType>& periodicDofMap() const

    { return periodicDofMap_; }


    friend inline LocalView localView(const BoxFVGridGeometry& gg)

    { return { gg.cache_ }; }


private:


    class BoxGridGeometryCache

    {

        friend class BoxFVGridGeometry;

    public:

        using GeometryHelper = Detail::BoxGeometryHelper_t<GV, Traits>;


        explicit BoxGridGeometryCache(const BoxFVGridGeometry& gg)

        : gridGeometry_(&gg)

        {}


        const BoxFVGridGeometry& gridGeometry() const

        { return *gridGeometry_; }


        const std::vector<SubControlVolume>& scvs(GridIndexType eIdx) const

        { return scvs_[eIdx]; }


        const std::vector<SubControlVolumeFace>& scvfs(GridIndexType eIdx) const

        { return scvfs_[eIdx]; }


        bool hasBoundaryScvf(GridIndexType eIdx) const

        { return hasBoundaryScvf_[eIdx]; }


        const std::vector<std::array<LocalIndexType, 2>>& scvfBoundaryGeometryKeys(GridIndexType eIdx) const

        { return scvfBoundaryGeometryKeys_.at(eIdx); }


    private:

        void clear_()

        {

            scvs_.clear();

            scvfs_.clear();

            hasBoundaryScvf_.clear();

            scvfBoundaryGeometryKeys_.clear();

        }


        std::vector<std::vector<SubControlVolume>> scvs_;

        std::vector<std::vector<SubControlVolumeFace>> scvfs_;

        std::vector<bool> hasBoundaryScvf_;

        std::unordered_map<GridIndexType, std::vector<std::array<LocalIndexType, 2>>> scvfBoundaryGeometryKeys_;


        const BoxFVGridGeometry* gridGeometry_;

    };


public:

    using Cache = BoxGridGeometryCache;


private:

    using GeometryHelper = typename Cache::GeometryHelper;


    void update_()

    {

        cache_.clear_();


        const auto numElements = this->gridView().size(0);

        cache_.scvs_.resize(numElements);

        cache_.scvfs_.resize(numElements);

        cache_.hasBoundaryScvf_.resize(numElements, false);


        boundaryDofIndices_.assign(numDofs(), false);


        numScv_ = 0;

        numScvf_ = 0;

        numBoundaryScvf_ = 0;

        // Build the SCV and SCV faces

        for (const auto& element : elements(this->gridView()))

        {

            // fill the element map with seeds

            const auto eIdx = this->elementMapper().index(element);


            // count

            numScv_ += element.subEntities(dim);

            numScvf_ += element.subEntities(dim-1);


            // get the element geometry

            auto elementGeometry = element.geometry();

            const auto refElement = referenceElement(elementGeometry);


            // instantiate the geometry helper

            GeometryHelper geometryHelper(elementGeometry);


            // construct the sub control volumes

            cache_.scvs_[eIdx].resize(elementGeometry.corners());

            for (LocalIndexType scvLocalIdx = 0; scvLocalIdx < elementGeometry.corners(); ++scvLocalIdx)

            {

                const auto dofIdxGlobal = this->vertexMapper().subIndex(element, scvLocalIdx, dim);


                cache_.scvs_[eIdx][scvLocalIdx] = SubControlVolume(

                    geometryHelper.getScvCorners(scvLocalIdx),

                    scvLocalIdx,

                    eIdx,

                    dofIdxGlobal

                );

            }


            // construct the sub control volume faces

            LocalIndexType scvfLocalIdx = 0;

            cache_.scvfs_[eIdx].resize(element.subEntities(dim-1));

            for (; scvfLocalIdx < element.subEntities(dim-1); ++scvfLocalIdx)

            {

                // find the global and local scv indices this scvf is belonging to

                std::vector<LocalIndexType> localScvIndices({static_cast<LocalIndexType>(refElement.subEntity(scvfLocalIdx, dim-1, 0, dim)),

                                                             static_cast<LocalIndexType>(refElement.subEntity(scvfLocalIdx, dim-1, 1, dim))});


                const auto& corners = geometryHelper.getScvfCorners(scvfLocalIdx);

                cache_.scvfs_[eIdx][scvfLocalIdx] = SubControlVolumeFace(

                    corners,

                    geometryHelper.normal(corners, localScvIndices),

                    element,

                    elementGeometry,

                    scvfLocalIdx,

                    std::move(localScvIndices),

                    false

                );

            }


            // construct the sub control volume faces on the domain boundary

            for (const auto& intersection : intersections(this->gridView(), element))

            {

                if (intersection.boundary() && !intersection.neighbor())

                {

                    const auto isGeometry = intersection.geometry();

                    cache_.hasBoundaryScvf_[eIdx] = true;


                    // count

                    numScvf_ += isGeometry.corners();

                    numBoundaryScvf_ += isGeometry.corners();


                    for (unsigned int isScvfLocalIdx = 0; isScvfLocalIdx < isGeometry.corners(); ++isScvfLocalIdx)

                    {

                        // find the scvs this scvf is belonging to

                        const LocalIndexType insideScvIdx = static_cast<LocalIndexType>(refElement.subEntity(intersection.indexInInside(), 1, isScvfLocalIdx, dim));

                        std::vector<LocalIndexType> localScvIndices = {insideScvIdx, insideScvIdx};


                        cache_.scvfs_[eIdx].emplace_back(

                            geometryHelper.getBoundaryScvfCorners(intersection.indexInInside(), isScvfLocalIdx),

                            intersection.centerUnitOuterNormal(),

                            intersection,

                            isGeometry,

                            isScvfLocalIdx,

                            scvfLocalIdx,

                            std::move(localScvIndices),

                            true

                        );


                        cache_.scvfBoundaryGeometryKeys_[eIdx].emplace_back(std::array<LocalIndexType, 2>{{

                            static_cast<LocalIndexType>(intersection.indexInInside()),

                            static_cast<LocalIndexType>(isScvfLocalIdx)

                        }});


                        // increment local counter

                        scvfLocalIdx++;

                    }


                    // add all vertices on the intersection to the set of

                    // boundary vertices

                    const auto fIdx = intersection.indexInInside();

                    const auto numFaceVerts = refElement.size(fIdx, 1, dim);

                    for (int localVIdx = 0; localVIdx < numFaceVerts; ++localVIdx)

                    {

                        const auto vIdx = refElement.subEntity(fIdx, 1, localVIdx, dim);

                        const auto vIdxGlobal = this->vertexMapper().subIndex(element, vIdx, dim);

                        boundaryDofIndices_[vIdxGlobal] = true;

                    }

                }


                // inform the grid geometry if we have periodic boundaries

                else if (periodicGridTraits_.isPeriodic(intersection))

                {

                    this->setPeriodic();


                    // find the mapped periodic vertex of all vertices on periodic boundaries

                    const auto fIdx = intersection.indexInInside();

                    const auto numFaceVerts = refElement.size(fIdx, 1, dim);

                    const auto eps = 1e-7*(elementGeometry.corner(1) - elementGeometry.corner(0)).two_norm();

                    for (int localVIdx = 0; localVIdx < numFaceVerts; ++localVIdx)

                    {

                        const auto vIdx = refElement.subEntity(fIdx, 1, localVIdx, dim);

                        const auto vIdxGlobal = this->vertexMapper().subIndex(element, vIdx, dim);

                        const auto vPos = elementGeometry.corner(vIdx);


                        const auto& outside = intersection.outside();

                        const auto outsideGeometry = outside.geometry();

                        for (const auto& isOutside : intersections(this->gridView(), outside))

                        {

                            // only check periodic vertices of the periodic neighbor

                            if (periodicGridTraits_.isPeriodic(isOutside))

                            {

                                const auto fIdxOutside = isOutside.indexInInside();

                                const auto numFaceVertsOutside = refElement.size(fIdxOutside, 1, dim);

                                for (int localVIdxOutside = 0; localVIdxOutside < numFaceVertsOutside; ++localVIdxOutside)

                                {

                                    const auto vIdxOutside = refElement.subEntity(fIdxOutside, 1, localVIdxOutside, dim);

                                    const auto vPosOutside = outsideGeometry.corner(vIdxOutside);

                                    const auto shift = std::abs((this->bBoxMax()-this->bBoxMin())*intersection.centerUnitOuterNormal());

                                    if (std::abs((vPosOutside-vPos).two_norm() - shift) < eps)

                                        periodicDofMap_[vIdxGlobal] = this->vertexMapper().subIndex(outside, vIdxOutside, dim);

                                }

                            }

                        }

                    }

                }

            }

        }


        // error check: periodic boundaries currently don't work for box in parallel

        if (this->isPeriodic() && this->gridView().comm().size() > 1)

            DUNE_THROW(Dune::NotImplemented, "Periodic boundaries for box method for parallel simulations!");

    }


    const FeCache feCache_;


    std::size_t numScv_;

    std::size_t numScvf_;

    std::size_t numBoundaryScvf_;


    // vertices on the boundary

    std::vector<bool> boundaryDofIndices_;


    // a map for periodic boundary vertices

    std::unordered_map<GridIndexType, GridIndexType> periodicDofMap_;


    Cache cache_;


    PeriodicGridTraits<typename GridView::Grid> periodicGridTraits_;

};


template<class Scalar, class GV, class Traits>

class BoxFVGridGeometry<Scalar, GV, false, Traits>

: public BaseGridGeometry<GV, Traits>

{

    using ThisType = BoxFVGridGeometry<Scalar, GV, false, Traits>;

    using ParentType = BaseGridGeometry<GV, Traits>;

    using GridIndexType = typename IndexTraits<GV>::GridIndex;


    static const int dim = GV::dimension;

    static const int dimWorld = GV::dimensionworld;


    using Element = typename GV::template Codim<0>::Entity;

    using CoordScalar = typename GV::ctype;


public:

    using DiscretizationMethod = DiscretizationMethods::Box;

    static constexpr DiscretizationMethod discMethod{};


    using BasicGridGeometry = BasicGridGeometry_t<GV, Traits>;

    using LocalView = typename Traits::template LocalView<ThisType, false>;

    using SubControlVolume = typename Traits::SubControlVolume;

    using SubControlVolumeFace = typename Traits::SubControlVolumeFace;

    using Extrusion = Extrusion_t<Traits>;

    using DofMapper = typename Traits::VertexMapper;

    using FeCache = Dune::LagrangeLocalFiniteElementCache<CoordScalar, Scalar, dim, 1>;

    using GridView = GV;

    using SupportsPeriodicity = typename PeriodicGridTraits<typename GV::Grid>::SupportsPeriodicity;


    BoxFVGridGeometry(std::shared_ptr<BasicGridGeometry> gg)

    : ParentType(std::move(gg))

    , cache_(*this)

    , periodicGridTraits_(this->gridView().grid())

    {

        update_();

    }


    BoxFVGridGeometry(const GridView& gridView)

    : BoxFVGridGeometry(std::make_shared<BasicGridGeometry>(gridView))

    {}


    const DofMapper& dofMapper() const

    { return this->vertexMapper(); }


    std::size_t numScv() const

    {  return numScv_; }


    std::size_t numScvf() const

    { return numScvf_; }


    std::size_t numBoundaryScvf() const

    { return numBoundaryScvf_; }


    std::size_t numDofs() const

    { return this->vertexMapper().size(); }


    void update(const GridView& gridView)

    {

        ParentType::update(gridView);

        update_();

    }


    void update(GridView&& gridView)

    {

        ParentType::update(std::move(gridView));

        update_();

    }


    const FeCache& feCache() const

    { return feCache_; }


    bool dofOnBoundary(GridIndexType dofIdx) const

    { return boundaryDofIndices_[dofIdx]; }


    bool dofOnPeriodicBoundary(GridIndexType dofIdx) const

    { return periodicDofMap_.count(dofIdx); }


    GridIndexType periodicallyMappedDof(GridIndexType dofIdx) const

    { return periodicDofMap_.at(dofIdx); }


    const std::unordered_map<GridIndexType, GridIndexType>& periodicDofMap() const

    { return periodicDofMap_; }


    friend inline LocalView localView(const BoxFVGridGeometry& gg)

    { return { gg.cache_ }; }


private:


    class BoxGridGeometryCache

    {

        friend class BoxFVGridGeometry;

    public:

        using GeometryHelper = Detail::BoxGeometryHelper_t<GV, Traits>;


        explicit BoxGridGeometryCache(const BoxFVGridGeometry& gg)

        : gridGeometry_(&gg)

        {}


        const BoxFVGridGeometry& gridGeometry() const

        { return *gridGeometry_; }


    private:

        const BoxFVGridGeometry* gridGeometry_;

    };


public:

    using Cache = BoxGridGeometryCache;


private:


    void update_()

    {

        boundaryDofIndices_.assign(numDofs(), false);


        // save global data on the grid's scvs and scvfs

        // TODO do we need those information?

        numScv_ = 0;

        numScvf_ = 0;

        numBoundaryScvf_ = 0;

        for (const auto& element : elements(this->gridView()))

        {

            numScv_ += element.subEntities(dim);

            numScvf_ += element.subEntities(dim-1);


            const auto elementGeometry = element.geometry();

            const auto refElement = referenceElement(elementGeometry);


            // store the sub control volume face indices on the domain boundary

            for (const auto& intersection : intersections(this->gridView(), element))

            {

                if (intersection.boundary() && !intersection.neighbor())

                {

                    const auto isGeometry = intersection.geometry();

                    numScvf_ += isGeometry.corners();

                    numBoundaryScvf_ += isGeometry.corners();


                    // add all vertices on the intersection to the set of

                    // boundary vertices

                    const auto fIdx = intersection.indexInInside();

                    const auto numFaceVerts = refElement.size(fIdx, 1, dim);

                    for (int localVIdx = 0; localVIdx < numFaceVerts; ++localVIdx)

                    {

                        const auto vIdx = refElement.subEntity(fIdx, 1, localVIdx, dim);

                        const auto vIdxGlobal = this->vertexMapper().subIndex(element, vIdx, dim);

                        boundaryDofIndices_[vIdxGlobal] = true;

                    }

                }


                // inform the grid geometry if we have periodic boundaries

                else if (periodicGridTraits_.isPeriodic(intersection))

                {

                    this->setPeriodic();


                    // find the mapped periodic vertex of all vertices on periodic boundaries

                    const auto fIdx = intersection.indexInInside();

                    const auto numFaceVerts = refElement.size(fIdx, 1, dim);

                    const auto eps = 1e-7*(elementGeometry.corner(1) - elementGeometry.corner(0)).two_norm();

                    for (int localVIdx = 0; localVIdx < numFaceVerts; ++localVIdx)

                    {

                        const auto vIdx = refElement.subEntity(fIdx, 1, localVIdx, dim);

                        const auto vIdxGlobal = this->vertexMapper().subIndex(element, vIdx, dim);

                        const auto vPos = elementGeometry.corner(vIdx);


                        const auto& outside = intersection.outside();

                        const auto outsideGeometry = outside.geometry();

                        for (const auto& isOutside : intersections(this->gridView(), outside))

                        {

                            // only check periodic vertices of the periodic neighbor

                            if (periodicGridTraits_.isPeriodic(isOutside))

                            {

                                const auto fIdxOutside = isOutside.indexInInside();

                                const auto numFaceVertsOutside = refElement.size(fIdxOutside, 1, dim);

                                for (int localVIdxOutside = 0; localVIdxOutside < numFaceVertsOutside; ++localVIdxOutside)

                                {

                                    const auto vIdxOutside = refElement.subEntity(fIdxOutside, 1, localVIdxOutside, dim);

                                    const auto vPosOutside = outsideGeometry.corner(vIdxOutside);

                                    const auto shift = std::abs((this->bBoxMax()-this->bBoxMin())*intersection.centerUnitOuterNormal());

                                    if (std::abs((vPosOutside-vPos).two_norm() - shift) < eps)

                                        periodicDofMap_[vIdxGlobal] = this->vertexMapper().subIndex(outside, vIdxOutside, dim);

                                }

                            }

                        }

                    }

                }

            }

        }


        // error check: periodic boundaries currently don't work for box in parallel

        if (this->isPeriodic() && this->gridView().comm().size() > 1)

            DUNE_THROW(Dune::NotImplemented, "Periodic boundaries for box method for parallel simulations!");

    }


    const FeCache feCache_;


    // Information on the global number of geometries

    // TODO do we need those information?

    std::size_t numScv_;

    std::size_t numScvf_;

    std::size_t numBoundaryScvf_;


    // vertices on the boundary

    std::vector<bool> boundaryDofIndices_;


    // a map for periodic boundary vertices

    std::unordered_map<GridIndexType, GridIndexType> periodicDofMap_;


    Cache cache_;


    PeriodicGridTraits<typename GridView::Grid> periodicGridTraits_;

};


} // end namespace Dumux


#endif

basegridgeometry.hh
Base class for grid geometries.

boxgeometryhelper.hh
Helper class constructing the dual grid finite volume geometries for the box discretizazion method.

Dumux::BaseGridGeometry
Base class for all grid geometries.
Definition: basegridgeometry.hh:52

Dumux::BaseGridGeometry::GridView
typename BaseImplementation::GridView GridView
export the grid view type
Definition: basegridgeometry.hh:60

Dumux::BoxFVElementGeometry
Base class for the finite volume geometry vector for box models This builds up the sub control volume...
Definition: discretization/box/fvelementgeometry.hh:41

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >
Base class for the finite volume geometry vector for box schemes This builds up the sub control volum...
Definition: discretization/box/fvgridgeometry.hh:439

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::numBoundaryScvf
std::size_t numBoundaryScvf() const
Definition: discretization/box/fvgridgeometry.hh:503

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::localView
friend LocalView localView(const BoxFVGridGeometry &gg)
local view of this object (constructed with the internal cache)
Definition: discretization/box/fvgridgeometry.hh:546

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::dofOnPeriodicBoundary
bool dofOnPeriodicBoundary(GridIndexType dofIdx) const
If a vertex / d.o.f. is on a periodic boundary.
Definition: discretization/box/fvgridgeometry.hh:534

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::LocalView
typename Traits::template LocalView< ThisType, false > LocalView
export the type of the fv element geometry (the local view type)
Definition: discretization/box/fvgridgeometry.hh:458

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::SubControlVolumeFace
typename Traits::SubControlVolumeFace SubControlVolumeFace
export the type of sub control volume
Definition: discretization/box/fvgridgeometry.hh:462

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::BoxFVGridGeometry
BoxFVGridGeometry(const GridView &gridView)
Constructor.
Definition: discretization/box/fvgridgeometry.hh:484

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::SubControlVolume
typename Traits::SubControlVolume SubControlVolume
export the type of sub control volume
Definition: discretization/box/fvgridgeometry.hh:460

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::periodicallyMappedDof
GridIndexType periodicallyMappedDof(GridIndexType dofIdx) const
The index of the vertex / d.o.f. on the other side of the periodic boundary.
Definition: discretization/box/fvgridgeometry.hh:538

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::feCache
const FeCache & feCache() const
The finite element cache for creating local FE bases.
Definition: discretization/box/fvgridgeometry.hh:526

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::Cache
BoxGridGeometryCache Cache
Definition: discretization/box/fvgridgeometry.hh:572

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::numScvf
std::size_t numScvf() const
The total number of sun control volume faces.
Definition: discretization/box/fvgridgeometry.hh:498

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::DofMapper
typename Traits::VertexMapper DofMapper
export dof mapper type
Definition: discretization/box/fvgridgeometry.hh:466

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::BasicGridGeometry
BasicGridGeometry_t< GV, Traits > BasicGridGeometry
export basic grid geometry type for the alternative constructor
Definition: discretization/box/fvgridgeometry.hh:456

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::dofOnBoundary
bool dofOnBoundary(GridIndexType dofIdx) const
If a vertex / d.o.f. is on the boundary.
Definition: discretization/box/fvgridgeometry.hh:530

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::dofMapper
const DofMapper & dofMapper() const
Definition: discretization/box/fvgridgeometry.hh:490

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::SupportsPeriodicity
typename PeriodicGridTraits< typename GV::Grid >::SupportsPeriodicity SupportsPeriodicity
export whether the grid(geometry) supports periodicity
Definition: discretization/box/fvgridgeometry.hh:472

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::update
void update(GridView &&gridView)
update all fvElementGeometries (call this after grid adaption)
Definition: discretization/box/fvgridgeometry.hh:519

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::Extrusion
Extrusion_t< Traits > Extrusion
export the type of extrusion
Definition: discretization/box/fvgridgeometry.hh:464

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::numDofs
std::size_t numDofs() const
The total number of degrees of freedom.
Definition: discretization/box/fvgridgeometry.hh:507

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::BoxFVGridGeometry
BoxFVGridGeometry(std::shared_ptr< BasicGridGeometry > gg)
Constructor with basic grid geometry used to share state with another grid geometry on the same grid ...
Definition: discretization/box/fvgridgeometry.hh:475

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::numScv
std::size_t numScv() const
The total number of sub control volumes.
Definition: discretization/box/fvgridgeometry.hh:494

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::update
void update(const GridView &gridView)
update all fvElementGeometries (call this after grid adaption)
Definition: discretization/box/fvgridgeometry.hh:512

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::FeCache
Dune::LagrangeLocalFiniteElementCache< CoordScalar, Scalar, dim, 1 > FeCache
export the finite element cache type
Definition: discretization/box/fvgridgeometry.hh:468

Dumux::BoxFVGridGeometry< Scalar, GV, false, Traits >::periodicDofMap
const std::unordered_map< GridIndexType, GridIndexType > & periodicDofMap() const
Returns the map between dofs across periodic boundaries.
Definition: discretization/box/fvgridgeometry.hh:542

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >
Base class for the finite volume geometry vector for box schemes This builds up the sub control volum...
Definition: discretization/box/fvgridgeometry.hh:85

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::localView
friend LocalView localView(const BoxFVGridGeometry &gg)
local view of this object (constructed with the internal cache)
Definition: discretization/box/fvgridgeometry.hh:192

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::Cache
BoxGridGeometryCache Cache
Definition: discretization/box/fvgridgeometry.hh:247

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::update
void update(const GridView &gridView)
update all fvElementGeometries (call this after grid adaption)
Definition: discretization/box/fvgridgeometry.hh:158

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::periodicallyMappedDof
GridIndexType periodicallyMappedDof(GridIndexType dofIdx) const
The index of the vertex / d.o.f. on the other side of the periodic boundary.
Definition: discretization/box/fvgridgeometry.hh:184

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::numDofs
std::size_t numDofs() const
The total number of degrees of freedom.
Definition: discretization/box/fvgridgeometry.hh:153

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::numScv
std::size_t numScv() const
The total number of sub control volumes.
Definition: discretization/box/fvgridgeometry.hh:140

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::BasicGridGeometry
BasicGridGeometry_t< GV, Traits > BasicGridGeometry
export basic grid geometry type for the alternative constructor
Definition: discretization/box/fvgridgeometry.hh:102

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::feCache
const FeCache & feCache() const
The finite element cache for creating local FE bases.
Definition: discretization/box/fvgridgeometry.hh:172

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::numBoundaryScvf
std::size_t numBoundaryScvf() const
Definition: discretization/box/fvgridgeometry.hh:149

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::FeCache
Dune::LagrangeLocalFiniteElementCache< CoordScalar, Scalar, dim, 1 > FeCache
export the finite element cache type
Definition: discretization/box/fvgridgeometry.hh:114

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::SubControlVolumeFace
typename Traits::SubControlVolumeFace SubControlVolumeFace
export the type of sub control volume
Definition: discretization/box/fvgridgeometry.hh:108

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::dofMapper
const DofMapper & dofMapper() const
Definition: discretization/box/fvgridgeometry.hh:136

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::periodicDofMap
const std::unordered_map< GridIndexType, GridIndexType > & periodicDofMap() const
Returns the map between dofs across periodic boundaries.
Definition: discretization/box/fvgridgeometry.hh:188

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::BoxFVGridGeometry
BoxFVGridGeometry(const GridView &gridView)
Constructor.
Definition: discretization/box/fvgridgeometry.hh:130

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::BoxFVGridGeometry
BoxFVGridGeometry(std::shared_ptr< BasicGridGeometry > gg)
Constructor with basic grid geometry used to share state with another grid geometry on the same grid ...
Definition: discretization/box/fvgridgeometry.hh:121

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::Extrusion
Extrusion_t< Traits > Extrusion
export the type of extrusion
Definition: discretization/box/fvgridgeometry.hh:110

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::SupportsPeriodicity
typename PeriodicGridTraits< typename GV::Grid >::SupportsPeriodicity SupportsPeriodicity
export whether the grid(geometry) supports periodicity
Definition: discretization/box/fvgridgeometry.hh:118

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::LocalView
typename Traits::template LocalView< ThisType, true > LocalView
export the type of the fv element geometry (the local view type)
Definition: discretization/box/fvgridgeometry.hh:104

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::dofOnBoundary
bool dofOnBoundary(GridIndexType dofIdx) const
If a vertex / d.o.f. is on the boundary.
Definition: discretization/box/fvgridgeometry.hh:176

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::numScvf
std::size_t numScvf() const
The total number of sun control volume faces.
Definition: discretization/box/fvgridgeometry.hh:144

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::dofOnPeriodicBoundary
bool dofOnPeriodicBoundary(GridIndexType dofIdx) const
If a vertex / d.o.f. is on a periodic boundary.
Definition: discretization/box/fvgridgeometry.hh:180

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::update
void update(GridView &&gridView)
update all fvElementGeometries (call this after grid adaption)
Definition: discretization/box/fvgridgeometry.hh:165

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::SubControlVolume
typename Traits::SubControlVolume SubControlVolume
export the type of sub control volume
Definition: discretization/box/fvgridgeometry.hh:106

Dumux::BoxFVGridGeometry< Scalar, GV, true, Traits >::DofMapper
typename Traits::VertexMapper DofMapper
export dof mapper type
Definition: discretization/box/fvgridgeometry.hh:112

Dumux::BoxFVGridGeometry
Base class for the finite volume geometry vector for box schemes This builds up the sub control volum...
Definition: discretization/box/fvgridgeometry.hh:74

Dumux::BoxGeometryHelper
Create sub control volumes and sub control volume face geometries.
Definition: boxgeometryhelper.hh:257

Dumux::BoxSubControlVolumeFace
Class for a sub control volume face in the box method, i.e a part of the boundary of a sub control vo...
Definition: discretization/box/subcontrolvolumeface.hh:62

Dumux::BoxSubControlVolume
the sub control volume for the box scheme
Definition: discretization/box/subcontrolvolume.hh:60

defaultmappertraits.hh
Defines the default element and vertex mapper types.

fvelementgeometry.hh
Base class for the local finite volume geometry for box models This builds up the sub control volumes...

subcontrolvolume.hh
the sub control volume for the box scheme

subcontrolvolumeface.hh
Base class for a sub control volume face.

extrusion.hh
Helper classes to compute the integration elements.

Dumux::BasicGridGeometry_t
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:42

indextraits.hh
Defines the index types used for grid and local indices.

method.hh
The available discretization methods in Dumux.

Dumux::Detail::BoxGeometryHelper_t
Dune::Std::detected_or_t< Dumux::BoxGeometryHelper< GV, GV::dimension, typename T::SubControlVolume, typename T::SubControlVolumeFace >, SpecifiesGeometryHelper, T > BoxGeometryHelper_t
Definition: discretization/box/fvgridgeometry.hh:44

Dumux::Detail::SpecifiesGeometryHelper
typename T::GeometryHelper SpecifiesGeometryHelper
Definition: basegridgeometry.hh:30

Dumux::DiscretizationMethods::Box
CVFE< CVFEMethods::PQ1 > Box
Definition: method.hh:94

Dumux
Definition: adapt.hh:17

Dumux::Extrusion_t
typename Extrusion< T >::type Extrusion_t
Convenience alias for obtaining the extrusion type.
Definition: extrusion.hh:166

periodicgridtraits.hh
Grid properties related to periodicity.

Dumux::BoxDefaultGridGeometryTraits
The default traits for the box finite volume grid geometry Defines the scv and scvf types and the map...
Definition: discretization/box/fvgridgeometry.hh:56

Dumux::DiscretizationMethods::CVFE
Definition: method.hh:46

Dumux::IndexTraits
Structure to define the index types used for grid and local indices.
Definition: indextraits.hh:26

Dumux::PeriodicGridTraits::SupportsPeriodicity
Definition: periodicgridtraits.hh:24

Dumux::PeriodicGridTraits< typename GridView::Grid >