discretization/facecentered/diamond/fvelementgeometry.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
 *   See the file COPYING for full copying permissions.                      *
 *                                                                           *
 *   This program is free software: you can redistribute it and/or modify    *
 *   it under the terms of the GNU General Public License as published by    *
 *   the Free Software Foundation, either version 3 of the License, or       *
 *   (at your option) any later version.                                     *
 *                                                                           *
 *   This program is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU General Public License for more details.                            *
 *                                                                           *
 *   You should have received a copy of the GNU General Public License       *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
 *****************************************************************************/
#ifndef DUMUX_DISCRETIZATION_FACECENTERED_DIAMOND_FV_ELEMENT_GEOMETRY_HH
#define DUMUX_DISCRETIZATION_FACECENTERED_DIAMOND_FV_ELEMENT_GEOMETRY_HH
 
#include <type_traits>
#include <optional>
 
#include <dune/common/reservedvector.hh>
#include <dune/common/iteratorrange.hh>
 
#include <dumux/common/indextraits.hh>
#include <dumux/discretization/scvandscvfiterators.hh>
#include <dumux/discretization/facecentered/diamond/geometryhelper.hh>
 
namespace Dumux {

template<class GG, bool cachingEnabled>
class FaceCenteredDiamondFVElementGeometry;

template<class GG>
class FaceCenteredDiamondFVElementGeometry<GG, /*cachingEnabled*/true>
{
    using ThisType = FaceCenteredDiamondFVElementGeometry<GG, /*cachingEnabled*/true>;
    using GridView = typename GG::GridView;
    using GridIndexType = typename IndexTraits<GridView>::GridIndex;
    using LocalIndexType = typename IndexTraits<GridView>::SmallLocalIndex;
    using FeLocalBasis = typename GG::FeCache::FiniteElementType::Traits::LocalBasisType;
    using GGCache = typename GG::Cache;
    using GeometryHelper = DiamondGeometryHelper<GridView, typename GG::SubControlVolume, typename GG::SubControlVolumeFace>;
 
public:
    using SubControlVolume = typename GG::SubControlVolume;
    using SubControlVolumeFace = typename GG::SubControlVolumeFace;
    using Element = typename GridView::template Codim<0>::Entity;
    using GridGeometry = GG;

    static constexpr std::size_t maxNumElementScvs = 2*GridView::dimension;
 
    FaceCenteredDiamondFVElementGeometry(const GGCache& ggCache)
    : ggCache_(&ggCache)
    {}

    const SubControlVolume& scv(LocalIndexType scvIdx) const
    { return ggCache_->scvs(eIdx_)[scvIdx]; }

    const SubControlVolumeFace& scvf(LocalIndexType scvfIdx) const
    { return ggCache_->scvf(eIdx_)[scvfIdx]; }

    friend inline auto
    scvs(const FaceCenteredDiamondFVElementGeometry& fvGeometry)
    {
        using Iter = typename std::vector<SubControlVolume>::const_iterator;
        const auto& s = fvGeometry.ggCache_->scvs(fvGeometry.eIdx_);
        return Dune::IteratorRange<Iter>(s.begin(), s.end());
    }

    friend inline auto
    scvfs(const FaceCenteredDiamondFVElementGeometry& fvGeometry)
    {
        using Iter = typename std::vector<SubControlVolumeFace>::const_iterator;
        const auto& s = fvGeometry.ggCache_->scvfs(fvGeometry.eIdx_);
        return Dune::IteratorRange<Iter>(s.begin(), s.end());
    }

    const FeLocalBasis& feLocalBasis() const
    {
        return gridGeometry().feCache().get(element().type()).localBasis();
    }

    std::size_t numScv() const
    {
        return ggCache_->scvs(eIdx_).size();
    }

    std::size_t numScvf() const
    {
        return ggCache_->scvfs(eIdx_).size();
    }

    bool hasBoundaryScvf() const
    { return ggCache_->hasBoundaryScvf(eIdx_); }

    FaceCenteredDiamondFVElementGeometry bind(const Element& element) &&
    {
        this->bindElement(element);
        return std::move(*this);
    }
 
    void bind(const Element& element) &
    {
        this->bindElement(element);
    }

    FaceCenteredDiamondFVElementGeometry bindElement(const Element& element) &&
    {
        this->bindElement(element);
        return std::move(*this);
    }

    void bindElement(const Element& element) &
    {
        element_ = element;
        eIdx_ = gridGeometry().elementMapper().index(element);
    }

    bool isBound() const
    { return static_cast<bool>(element_); }

    const Element& element() const
    { return *element_; }

    const GridGeometry& gridGeometry() const
    { return ggCache_->gridGeometry(); }

    std::size_t elementIndex() const
    { return eIdx_; }

    typename SubControlVolume::Traits::Geometry geometry(const SubControlVolume& scv) const
    {
        assert(isBound());
        const auto geo = element().geometry();
        return {
            SubControlVolume::Traits::geometryType(geo.type()),
            GeometryHelper(geo).getScvCorners(scv.indexInElement())
        };
    }

    typename SubControlVolumeFace::Traits::Geometry geometry(const SubControlVolumeFace& scvf) const
    {
        assert(isBound());
        const auto geo = element().geometry();
        if (scvf.boundary())
        {
            // use the information that each boundary scvf corresponds to one scv constructed around the same facet
            const auto localFacetIndex = scvf.insideScvIdx();
            return {
                referenceElement(geo).type(localFacetIndex, 1),
                GeometryHelper(geo).getBoundaryScvfCorners(localFacetIndex)
            };
        }
        else
        {
            return {
                SubControlVolumeFace::Traits::interiorGeometryType(geo.type()),
                GeometryHelper(geo).getScvfCorners(scvf.index())
            };
        }
    }
 
private:
    std::optional<Element> element_;
    GridIndexType eIdx_;
    const GGCache* ggCache_;
};
 
} // end namespace Dumux
 
#endif