releases/3.9/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-FileCopyrightInfo: 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>


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;


    BoxFVGridGeometry(std::shared_ptr<BasicGridGeometry> gg)

    : ParentType(std::move(gg))

    , cache_(*this)

    {

        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 periodicVertexMap_.count(dofIdx); }


    GridIndexType periodicallyMappedDof(GridIndexType dofIdx) const

    { return periodicVertexMap_.at(dofIdx); }


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

    { return periodicVertexMap_; }


    [[deprecated("Will be removed after release 3.9. Use periodicDofMap() instead.")]]

    const std::unordered_map<GridIndexType, GridIndexType>& periodicVertexMap() 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 (intersection.boundary() && intersection.neighbor())

                {

                    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 (isOutside.boundary() && isOutside.neighbor())

                            {

                                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)

                                        periodicVertexMap_[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> periodicVertexMap_;


    Cache cache_;

};


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;


    BoxFVGridGeometry(std::shared_ptr<BasicGridGeometry> gg)

    : ParentType(std::move(gg))

    , cache_(*this)

    {

        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 periodicVertexMap_.count(dofIdx); }


    GridIndexType periodicallyMappedDof(GridIndexType dofIdx) const

    { return periodicVertexMap_.at(dofIdx); }


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

    { return periodicVertexMap_; }


    [[deprecated("Will be removed after release 3.9. Use periodicDofMap() instead.")]]

    const std::unordered_map<GridIndexType, GridIndexType>& periodicVertexMap() 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 (intersection.boundary() && intersection.neighbor())

                {

                    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 (isOutside.boundary() && isOutside.neighbor())

                            {

                                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)

                                        periodicVertexMap_[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> periodicVertexMap_;


    Cache cache_;

};


} // 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:437

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

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:529

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:456

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

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

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

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:533

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:521

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:493

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

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:454

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:525

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

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

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

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

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

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:471

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

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:507

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:466

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:537

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:83

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 >::periodicVertexMap
const std::unordered_map< GridIndexType, GridIndexType > & periodicVertexMap() const
Returns the map between dofs across periodic boundaries.
Definition: discretization/box/fvgridgeometry.hh:188

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:153

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:179

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

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

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:100

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:167

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

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:112

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

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

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:183

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

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:117

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

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:102

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:171

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:139

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:175

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

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

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

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:72

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

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

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:54

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