facecentered/staggered/elementsolution.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-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_DISCRETIZATION_FACECENTERED_STAGGERED_ELEMENT_SOLUTION_HH
#define DUMUX_DISCRETIZATION_FACECENTERED_STAGGERED_ELEMENT_SOLUTION_HH
 
#include <type_traits>
#include <array>
#include <utility>
 
#include <dumux/common/indextraits.hh>
#include <dumux/discretization/method.hh>
 
namespace Dumux {
 
template<class FVElementGeometry, class PV>
class FaceCenteredStaggeredElementSolution
{
    using GridGeometry = typename FVElementGeometry::GridGeometry;
    using GridView = typename GridGeometry::GridView;
    using Element = typename GridView::template Codim<0>::Entity;
    using SmallLocalIndexType = typename IndexTraits<GridView>::SmallLocalIndex;
 
    static constexpr auto numScvsPerElement = GridView::Grid::dimension * 2;
 
public:
    using PrimaryVariables = PV;
 
    FaceCenteredStaggeredElementSolution() = default;
 
    template<class SolutionVector>
    FaceCenteredStaggeredElementSolution(const Element& element,
                                         const SolutionVector& sol,
                                         const GridGeometry& gridGeometry)
    {
        const auto fvGeometry = localView(gridGeometry).bindElement(element);
 
        for (const auto& scv : scvs(fvGeometry))
            priVars_[scv.indexInElement()] = sol[scv.dofIndex()];
    }
 
    template<class ElementVolumeVariables>
    FaceCenteredStaggeredElementSolution(const Element& element,
                                         const ElementVolumeVariables& elemVolVars,
                                         const FVElementGeometry& fvGeometry)
    {
        for (const auto& scv : scvs(fvGeometry))
            priVars_ = elemVolVars[scv].priVars();
    }
 
    FaceCenteredStaggeredElementSolution(PrimaryVariables&& priVars)
    {
        priVars_[0] = std::move(priVars);
        for (int i = 1; i < priVars_.size(); ++i)
           priVars_[i] = priVars_[0];
    }
 
    FaceCenteredStaggeredElementSolution(const PrimaryVariables& priVars)
    {
        priVars_[0] = priVars;
        for (int i = 1; i < priVars_.size(); ++i)
           priVars_[i] = priVars_[0];
    }
 
    template<class SolutionVector>
    void update(const Element& element, const SolutionVector& sol,
                const GridGeometry& gridGeometry)
    {
        const auto fvGeometry = localView(gridGeometry).bindElement(element);
 
        for (const auto& scv : scvs(fvGeometry))
            priVars_[scv.indexInElement()] = sol[scv.dofIndex()];
    }
 
    const PrimaryVariables& operator [](SmallLocalIndexType localScvIdx) const
    {
        return priVars_[localScvIdx];
    }
 
    PrimaryVariables& operator [](SmallLocalIndexType localScvIdx)
    {
         return priVars_[localScvIdx];
    }
 
    static constexpr std::size_t size()
    { return numScvsPerElement; }
 
private:
    std::array<PrimaryVariables, numScvsPerElement> priVars_;
};
 
template<class Element, class SolutionVector, class GridGeometry>
auto elementSolution(const Element& element, const SolutionVector& sol, const GridGeometry& gg)
-> std::enable_if_t<
    GridGeometry::discMethod == DiscretizationMethods::fcstaggered,
    FaceCenteredStaggeredElementSolution<
        typename GridGeometry::LocalView,
        std::decay_t<decltype(std::declval<SolutionVector>()[0])>
    >
>
{ return { element, sol, gg }; }
 
template<class Element, class ElementVolumeVariables, class FVElementGeometry>
auto elementSolution(const Element& element, const ElementVolumeVariables& elemVolVars, const FVElementGeometry& gg)
-> std::enable_if_t<
    FVElementGeometry::GridGeometry::discMethod == DiscretizationMethods::fcstaggered,
    FaceCenteredStaggeredElementSolution<
        FVElementGeometry,
        typename ElementVolumeVariables::VolumeVariables::PrimaryVariables
    >
>
{ return { element, elemVolVars, gg }; }
 
template<class FVElementGeometry, class PrimaryVariables>
auto elementSolution(PrimaryVariables&& priVars)
-> std::enable_if_t<
    FVElementGeometry::GridGeometry::discMethod == DiscretizationMethods::fcstaggered,
    FaceCenteredStaggeredElementSolution<
        FVElementGeometry,
        std::decay_t<PrimaryVariables>
    >
>
{ return { std::forward<PrimaryVariables>(priVars) }; }
 
} // end namespace Dumux
 
#endif