feelementdiscretization.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_FE_ELEMENT_DISCRETIZATION_HH
#define DUMUX_DISCRETIZATION_FE_ELEMENT_DISCRETIZATION_HH
 
#include <optional>
#include <ranges>
#include <utility>
 
#include <dune/common/rangeutilities.hh>
#include <dune/geometry/type.hh>
 
#include <dumux/common/indextraits.hh>
#include <dumux/discretization/cvfe/localdof.hh>
#include <dumux/discretization/cvfe/interpolationpointdata.hh>
#include <dumux/discretization/cvfe/quadraturerules.hh>
 
namespace Dumux::Experimental {

template<class GG, bool enableGridDiscretizationCache>
class FEElementDiscretization
{
    using GridView = typename GG::GridView;
    using GridIndexType = typename IndexTraits<GridView>::GridIndex;
    using LocalIndexType = typename IndexTraits<GridView>::LocalIndex;
    using FeLocalBasis = typename GG::FeCache::FiniteElementType::Traits::LocalBasisType;
    using GGCache = typename GG::Cache;
    using DofHelper = typename GGCache::DofHelper;
 
public:
    using Element = typename GridView::template Codim<0>::Entity;
    using GridDiscretization = GG;
    using GridGeometry [[deprecated("Use GridDiscretization instead")]] = GG;
    using ElementQuadratureRule = typename GG::ElementQuadratureRule;
    using IntersectionQuadratureRule = typename GG::IntersectionQuadratureRule;
    using BoundaryFaceQuadratureRule = typename GG::BoundaryFaceQuadratureRule;
    using BoundaryFace = typename GG::BoundaryFace;
    static constexpr std::size_t maxNumElementDofs = GridDiscretization::maxNumElementDofs;

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

    friend inline auto localDofs(const FEElementDiscretization& elemDisc)
    { return DofHelper::localDofs(elemDisc); }

    friend inline auto nonCVLocalDofs(const FEElementDiscretization& elemDisc)
    { return localDofs(elemDisc); }

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

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

    const FeLocalBasis& feLocalBasis() const
    { return gridDiscretization().feCache().get(element_->type()).localBasis(); }

    const auto& feLocalCoefficients() const
    { return gridDiscretization().feCache().get(element_->type()).localCoefficients(); }

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

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

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

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

    void bindElement(const Element& element) &
    {
        element_ = element;
        eIdx_ = gridDiscretization().elementMapper().index(element);
        elementGeometry_.emplace(element.geometry());
    }

    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 GridDiscretization& gridGeometry() const
    { return ggCache_->gridDiscretization(); }

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

    bool hasBoundaryFaces() const
    { return !ggCache_->boundaryFaces(eIdx_).empty(); }

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

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

    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 };
    }

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

    friend inline auto ipData(const FEElementDiscretization& elemDisc,
                              const typename Element::Geometry::GlobalCoordinate& globalPos)
    {
        return CVFE::InterpolationPointDataLocalMapping{
            [&] (const typename Element::Geometry::GlobalCoordinate& pos) {
                return elemDisc.elementGeometry().local(pos); },
            globalPos
        };
    }
 
private:
    const GGCache* ggCache_;
    GridIndexType eIdx_;
 
    std::optional<Element> element_;
    std::optional<typename Element::Geometry> elementGeometry_;
};
 
} // end namespace Dumux::Experimental
 
#endif