discretization/pq1bubble/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:
//
// SPDX-FileCopyrightText: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_DISCRETIZATION_PQ1BUBBLE_FV_ELEMENT_GEOMETRY_HH
#define DUMUX_DISCRETIZATION_PQ1BUBBLE_FV_ELEMENT_GEOMETRY_HH
 
#include <optional>
#include <span>
#include <utility>
#include <dune/common/exceptions.hh>
#include <dune/common/reservedvector.hh>
#include <dune/geometry/type.hh>
#include <dune/localfunctions/lagrange/pqkfactory.hh>
 
#include <dumux/common/indextraits.hh>
#include <dumux/discretization/scvandscvfiterators.hh>
#include <dumux/discretization/cvfe/localdof.hh>
#include <dumux/discretization/cvfe/interpolationpointdata.hh>
#include <dumux/discretization/cvfe/quadraturerules.hh>
 
#include <dumux/discretization/pq1bubble/geometryhelper.hh>
 
namespace Dumux {

template<class GG, bool enableGridGeometryCache>
class PQ1BubbleFVElementGeometry;

template<class GG>
class PQ1BubbleFVElementGeometry<GG, true>
{
    using GridView = typename GG::GridView;
    static constexpr int dim = GridView::dimension;
    static constexpr int dimWorld = GridView::dimensionworld;
    using GridIndexType = typename IndexTraits<GridView>::GridIndex;
    using LocalIndexType = typename IndexTraits<GridView>::LocalIndex;
    using CoordScalar = typename GridView::ctype;
    using FiniteElement = typename GG::FeCache::FiniteElementType;
    using FeLocalBasis = typename FiniteElement::Traits::LocalBasisType;
    using GGCache = typename GG::Cache;
    using GeometryHelper = typename GGCache::GeometryHelper;
    using DofHelper = typename GGCache::DofHelper;
 
    using BaseIpData = CVFE::InterpolationPointData<
                        typename GridView::template Codim<0>::Entity::Geometry::LocalCoordinate,
                        typename GridView::template Codim<0>::Entity::Geometry::GlobalCoordinate
                        >;
 
public:
    using Element = typename GridView::template Codim<0>::Entity;
    using SubControlVolume = typename GG::SubControlVolume;
    using SubControlVolumeFace = typename GG::SubControlVolumeFace;
    using GridGeometry = GG;
    using BoundaryFace = typename GG::BoundaryFace;
    using ScvQuadratureRule = typename GG::ScvQuadratureRule;
    using ScvfQuadratureRule = typename GG::ScvfQuadratureRule;
    using ElementQuadratureRule = typename GG::ElementQuadratureRule;
    using IntersectionQuadratureRule = typename GG::IntersectionQuadratureRule;
    using BoundaryFaceQuadratureRule = typename GG::BoundaryFaceQuadratureRule;
    static constexpr std::size_t maxNumElementDofs = GridGeometry::maxNumElementDofs;

    PQ1BubbleFVElementGeometry(const GGCache& ggCache)
    : ggCache_(&ggCache)
    {}

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

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

    friend inline Dune::IteratorRange<typename std::vector<SubControlVolume>::const_iterator>
    scvs(const PQ1BubbleFVElementGeometry& 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 cvLocalDofs(const PQ1BubbleFVElementGeometry& fvGeometry)
    {
        return Dune::transformedRangeView(
            Dune::range(fvGeometry.numLocalDofs()-GeometryHelper::numNonCVLocalDofs(fvGeometry.element().type())),
            [&](const auto i) { return CVFE::LocalDof
            {
                static_cast<LocalIndexType>(i),
                fvGeometry.dofIndices_[i],
                static_cast<GridIndexType>(fvGeometry.elementIndex())
            }; }
        );
    }

    template<bool enable = GridGeometry::enableHybridCVFE, std::enable_if_t<enable, int> = 0>
    friend inline auto nonCVLocalDofs(const PQ1BubbleFVElementGeometry& fvGeometry)
    {
        return Dune::transformedRangeView(
            Dune::range(fvGeometry.numLocalDofs()-GeometryHelper::numNonCVLocalDofs(fvGeometry.element().type()), fvGeometry.numLocalDofs()),
            [&](const auto i) { return CVFE::LocalDof
            {
                static_cast<LocalIndexType>(i),
                fvGeometry.dofIndices_[i],
                static_cast<GridIndexType>(fvGeometry.elementIndex())
            }; }
        );
    }

    friend inline auto localDofs(const PQ1BubbleFVElementGeometry& fvGeometry)
    {
        return Dune::transformedRangeView(
            Dune::range(fvGeometry.numLocalDofs()),
            [&](const auto i) { return CVFE::LocalDof
            {
                static_cast<LocalIndexType>(i),
                fvGeometry.dofIndices_[i],
                static_cast<GridIndexType>(fvGeometry.elementIndex())
            }; }
        );
    }

    friend inline auto localDofs(const PQ1BubbleFVElementGeometry& fvGeometry, const BoundaryFace& boundaryFace)
    { return DofHelper::localDofsOnBoundaryFace(fvGeometry, boundaryFace); }

    friend inline Dune::IteratorRange<typename std::vector<SubControlVolumeFace>::const_iterator>
    scvfs(const PQ1BubbleFVElementGeometry& 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());
    }

    friend inline Dune::IteratorRange<typename std::vector<SubControlVolumeFace>::const_iterator>
    scvfs(const PQ1BubbleFVElementGeometry& fvGeometry, const BoundaryFace& boundaryFace)
    {
        using Iter = typename std::vector<SubControlVolumeFace>::const_iterator;
        const auto& s = fvGeometry.ggCache_->scvfs(fvGeometry.eIdx_);
        const auto& range = fvGeometry.ggCache_->boundaryFaceScvfRanges(fvGeometry.eIdx_)[boundaryFace.index()];
        return Dune::IteratorRange<Iter>(s.begin() + range[0], s.begin() + range[0] + range[1]);
    }

    friend inline std::ranges::view auto
    boundaryFaces(const PQ1BubbleFVElementGeometry& fvGeometry)
    {
        const auto& v = fvGeometry.ggCache_->boundaryFaces(fvGeometry.eIdx_);
        return std::ranges::views::all(v);
    }

    const FeLocalBasis& feLocalBasis() const
    {
        return fe_->localBasis();
    }

    const auto& feLocalCoefficients() const
    {
        return fe_->localCoefficients();
    }

    std::size_t numLocalDofs() const
    {
        return dofIndices_.size();
    }

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

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

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

    void bind(const Element& element) &
    { this->bindElement(element); }

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

    void bindElement(const Element& element) &
    {
        element_ = element;
        // cache element index
        eIdx_ = gridDiscretization().elementMapper().index(element);
        elementGeometry_.emplace(element.geometry());
 
        // the local dofs are iterated many times per bind (every quadrature point of every face,
        // every perturbation of a numerical derivative); look up the finite element and the dof
        // indices once here instead of on every iteration
        fe_ = &gridDiscretization().feCache().get(element.type());
        const auto& localCoefficients = fe_->localCoefficients();
        dofIndices_.clear();
        for (std::size_t i = 0; i < DofHelper::numElementDofs(element.type()); ++i)
            dofIndices_.push_back(static_cast<GridIndexType>(
                DofHelper::dofIndex(gridDiscretization().dofMapper(), element, localCoefficients.localKey(i))
            ));
    }

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

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

    const typename Element::Geometry& elementGeometry() const
    { return *elementGeometry_; }

    [[deprecated("Use gridDiscretization() instead")]]
    const GridGeometry& gridGeometry() const
    { return ggCache_->gridGeometry(); }

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

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

    bool hasBoundaryFaces() const
    { return hasBoundaryScvf(); }

    const BoundaryFace& boundaryFace(LocalIndexType bfIdx) const
    { return ggCache_->boundaryFaces(eIdx_)[bfIdx]; }

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

    std::size_t intersectionIndex(const SubControlVolumeFace& scvf) const
    {
        const auto localScvfIdx = scvf.index() - GeometryHelper::numInteriorScvf(element().type());
        return ggCache_->scvfBoundaryGeometryKeys(eIdx_)[localScvfIdx][0];
    }

    typename SubControlVolume::Traits::Geometry geometry(const SubControlVolume& scv) const
    {
        if (scv.isOverlapping())
            DUNE_THROW(Dune::NotImplemented, "Geometry of overlapping scv");
 
        assert(isBound());
        const GeometryHelper helper(*elementGeometry_);
        return {
            helper.getScvGeometryType(scv.indexInElement()),
            helper.getScvCorners(scv.indexInElement())
        };
    }

    typename SubControlVolumeFace::Traits::Geometry geometry(const SubControlVolumeFace& scvf) const
    {
        assert(isBound());
        if (scvf.boundary())
        {
            GeometryHelper helper(*elementGeometry_);
            const auto localScvfIdx = scvf.index() - GeometryHelper::numInteriorScvf(element().type());
            const auto [localFacetIndex, isScvfLocalIdx]
                = ggCache_->scvfBoundaryGeometryKeys(eIdx_)[localScvfIdx];
            return {
                helper.getBoundaryScvfGeometryType(isScvfLocalIdx),
                helper.getBoundaryScvfCorners(localFacetIndex, isScvfLocalIdx)
            };
        }
        else
        {
            GeometryHelper helper(*elementGeometry_);
            return {
                helper.getInteriorScvfGeometryType(scvf.index()),
                helper.getScvfCorners(scvf.index())
            };
        }
    }

    typename BoundaryFace::Traits::Geometry geometry(const BoundaryFace& boundaryFace) const
    {
        assert(isBound());
        const auto& elemGeo = elementGeometry();
        const auto faceGeoInRef = referenceElement(elemGeo).template geometry<1>(boundaryFace.intersectionIndex());
        typename BoundaryFace::Traits::CornerStorage corners;
        for (int i = 0; i < faceGeoInRef.corners(); ++i)
            corners.push_back(elemGeo.global(faceGeoInRef.corner(i)));
        return { faceGeoInRef.type(), corners };
    }

    friend inline auto ipData(const PQ1BubbleFVElementGeometry& fvGeometry, const SubControlVolume& scv)
    {
        const auto type = fvGeometry.element().type();
        const auto& localKey = fvGeometry.feLocalCoefficients().localKey(scv.localDofIndex());
 
        return CVFE::LocalDofInterpolationPointData{ DofHelper::localDofPosition(type, localKey), scv.dofPosition(), scv.localDofIndex() };
    }

    template<class LocalDof>
    friend inline auto ipData(const PQ1BubbleFVElementGeometry& fvGeometry, const LocalDof& localDof)
    {
        const auto type = fvGeometry.element().type();
        const auto& localKey = fvGeometry.feLocalCoefficients().localKey(localDof.index());
        const auto& localPos = DofHelper::localDofPosition(type, localKey);
 
        return CVFE::LocalDofInterpolationPointData{ localPos, fvGeometry.elementGeometry().global(localPos), localDof.index() };
    }

    friend inline auto ipData(const PQ1BubbleFVElementGeometry& fvGeometry, const typename Element::Geometry::GlobalCoordinate& globalPos)
    {
        // Create ipData that does not automatically calculate the local position but only if it is called
        return CVFE::InterpolationPointDataLocalMapping{
            [&] (const typename Element::Geometry::GlobalCoordinate& pos) { return fvGeometry.elementGeometry().local(pos); },
            globalPos
        };
    }

    friend inline auto ipData(const PQ1BubbleFVElementGeometry& fvGeometry, const SubControlVolumeFace& scvf)
    {
        return CVFE::FaceInterpolationPointData<BaseIpData, LocalIndexType>
                    { scvf.unitOuterNormal(), scvf.index(), fvGeometry.elementGeometry().local(scvf.ipGlobal()), scvf.ipGlobal() };
    }
 
private:
    const GGCache* ggCache_;
    GridIndexType eIdx_;
 
    std::optional<Element> element_;
    std::optional<typename Element::Geometry> elementGeometry_;
    const FiniteElement* fe_ = nullptr;
    Dune::ReservedVector<GridIndexType, maxNumElementDofs> dofIndices_;
};
 
} // end namespace Dumux
 
#endif