discretization/cvfe/hybrid/fluxvariablescache.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_HYBRID_CVFE_FLUXVARIABLES_CACHE_HH
#define DUMUX_DISCRETIZATION_HYBRID_CVFE_FLUXVARIABLES_CACHE_HH
 
#include <vector>
 
#include <dune/common/fvector.hh>
#include <dumux/common/typetraits/localdofs_.hh>
#include <dumux/common/concepts/ipdata_.hh>
#include <dumux/discretization/cvfe/localdof.hh>
 
namespace Dumux {

template< class Scalar, class GridGeometry >
class HybridCVFEFluxVariablesCache
{
    using GridView = typename GridGeometry::GridView;
    using Element = typename GridView::template Codim<0>::Entity;
    using GlobalPosition = typename Element::Geometry::GlobalCoordinate;
    using LocalPosition = typename Element::Geometry::LocalCoordinate;
 
    using FVElementGeometry = typename GridGeometry::LocalView;
 
    static const int dim = GridView::dimension;
    static const int dimWorld = GridView::dimensionworld;
 
    using CoordScalar = typename GridView::ctype;
    using FeLocalBasis = typename GridGeometry::FeCache::FiniteElementType::Traits::LocalBasisType;
    using ShapeJacobian = typename FeLocalBasis::Traits::JacobianType;
    using ShapeValue = typename Dune::FieldVector<Scalar, 1>;
    using JacobianInverseTransposed = typename Element::Geometry::JacobianInverseTransposed;
 
public:
    static bool constexpr isSolDependent = false;

    template< class Problem, class ElementVolumeVariables >
    void update(const Problem& problem,
                const Element& element,
                const FVElementGeometry& fvGeometry,
                const ElementVolumeVariables& elemVolVars,
                const GlobalPosition& globalPos)
    {
        update_(fvGeometry, fvGeometry.elementGeometry().local(globalPos), globalPos);
    }

    template< class Problem, class ElementVolumeVariables, Concept::IpData IpData >
    void update(const Problem& problem,
                const Element& element,
                const FVElementGeometry& fvGeometry,
                const ElementVolumeVariables& elemVolVars,
                const IpData& ipData)
    {
        update_(fvGeometry, ipData.local(), ipData.global());
    }

    const GlobalPosition& ipGlobal() const { return ipGlobal_; }
    const LocalPosition& ipLocal() const { return ipLocal_; }
    const std::vector<ShapeJacobian>& shapeJacobian() const { return shapeJacobian_; }
    const std::vector<ShapeValue>& shapeValues() const { return shapeValues_; }
    const JacobianInverseTransposed& jacInvT() const { return jacInvT_; }
    const GlobalPosition& gradN(unsigned int scvIdxInElement) const { return gradN_[scvIdxInElement]; }
 
private:
    void update_(const FVElementGeometry& fvGeometry,
                 const LocalPosition& localPos,
                 const GlobalPosition& globalPos)
    {
        const auto& geometry = fvGeometry.elementGeometry();
        const auto& localBasis = fvGeometry.feLocalBasis();
 
        // evaluate shape functions and gradients at the interpolation point
        ipGlobal_ = globalPos;
        ipLocal_ = localPos;
        jacInvT_ = geometry.jacobianInverseTransposed(ipLocal_);
        localBasis.evaluateJacobian(ipLocal_, shapeJacobian_);
        localBasis.evaluateFunction(ipLocal_, shapeValues_); // shape values for rho
 
        // compute the gradN at for every scv/dof
        gradN_.resize(Detail::LocalDofs::numLocalDofs(fvGeometry));
        for (const auto& localDof: localDofs(fvGeometry))
            jacInvT_.mv(shapeJacobian_[localDof.index()][0], gradN_[localDof.index()]);
    }
 
    std::vector<GlobalPosition> gradN_;
    std::vector<ShapeJacobian> shapeJacobian_;
    std::vector<ShapeValue> shapeValues_;
    JacobianInverseTransposed jacInvT_;
    GlobalPosition ipGlobal_;
    LocalPosition ipLocal_;
};
 
} // end namespace Dumux
 
#endif