experimental/discretization/fvgridvariables.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_EXPERIMENTAL_FV_GRID_VARIABLES_HH
#define DUMUX_EXPERIMENTAL_FV_GRID_VARIABLES_HH
 
#include <utility>
#include <memory>
 
#include <dumux/common/typetraits/problem.hh>
#include <dumux/discretization/localview.hh>
#include <dumux/experimental/common/variables.hh>
 
namespace Dumux::Experimental {
 
template<class GV>
class FVGridVariablesLocalView
{
    using GridGeometry = typename GV::GridGeometry;
    using FVElementGeometry = typename GridGeometry::LocalView;
 
    using GridView = typename GridGeometry::GridView;
    using Element = typename GridView::template Codim<0>::Entity;
 
    using ElementVolumeVariables = typename GV::GridVolumeVariables::LocalView;
    using ElementFluxVariablesCache = typename GV::GridFluxVariablesCache::LocalView;
 
public:
    using GridVariables = GV;
 
    FVGridVariablesLocalView(const GridVariables& gridVariables)
    : gridVariables_(&gridVariables)
    , elemVolVars_(gridVariables.gridVolVars())
    , elemFluxVarsCache_(gridVariables.gridFluxVarsCache())
    {}
 
    void bind(const Element& element,
              const FVElementGeometry& fvGeometry)
    {
        const auto& x = gridVariables().dofs();
        elemVolVars_.bind(element, fvGeometry, x);
        elemFluxVarsCache_.bind(element, fvGeometry, elemVolVars_);
    }
 
    void bindElemVolVars(const Element& element,
                         const FVElementGeometry& fvGeometry)
    {
        elemVolVars_.bind(element, fvGeometry, gridVariables().dofs());
 
        // unbind flux variables cache
        elemFluxVarsCache_ = localView(gridVariables().gridFluxVarsCache());
    }
 
    const ElementVolumeVariables& elemVolVars() const { return elemVolVars_; }
    ElementVolumeVariables& elemVolVars() { return elemVolVars_; }
 
    const ElementFluxVariablesCache& elemFluxVarsCache() const { return elemFluxVarsCache_; }
    ElementFluxVariablesCache& elemFluxVarsCache() { return elemFluxVarsCache_; }
 
    const GridVariables& gridVariables() const
    { return *gridVariables_; }
 
private:
    const GridVariables* gridVariables_;
    ElementVolumeVariables elemVolVars_;
    ElementFluxVariablesCache elemFluxVarsCache_;
};
 
template<class GVV, class GFVC, class X>
class FVGridVariables
: public Variables<X>
{
    using Problem = typename GVV::Problem;
    using GG = typename ProblemTraits<Problem>::GridGeometry;
 
    using ParentType = Variables<X>;
    using ThisType = FVGridVariables<GVV, GFVC, X>;
 
public:
    using typename ParentType::SolutionVector;
 
    using GridGeometry = GG;
 
    using GridVolumeVariables = GVV;
 
    using VolumeVariables = typename GridVolumeVariables::VolumeVariables;
 
    using PrimaryVariables = typename VolumeVariables::PrimaryVariables;
 
    using GridFluxVariablesCache = GFVC;
 
    using LocalView = FVGridVariablesLocalView<ThisType>;
 
    FVGridVariables(std::shared_ptr<Problem> problem,
                    std::shared_ptr<const GridGeometry> gridGeometry)
    : ParentType([problem] (auto& x) { problem->applyInitialSolution(x); })
    , gridGeometry_(gridGeometry)
    , gridVolVars_(*problem)
    , gridFluxVarsCache_(*problem)
    {}
 
    template<class SolOrInitializer>
    FVGridVariables(std::shared_ptr<Problem> problem,
                    std::shared_ptr<const GridGeometry> gridGeometry,
                    SolOrInitializer&& solOrInitializer,
                    const typename ParentType::TimeLevel& timeLevel = typename ParentType::TimeLevel{0.0})
    : ParentType(std::forward<SolOrInitializer>(solOrInitializer), timeLevel)
    , gridGeometry_(gridGeometry)
    , gridVolVars_(*problem)
    , gridFluxVarsCache_(*problem)
    {
        gridVolVars_.update(this->gridGeometry(), this->dofs());
        gridFluxVarsCache_.update(this->gridGeometry(), gridVolVars_, this->dofs(), true);
    }
 
    void update(const SolutionVector& curSol)
    {
        ParentType::update(curSol);
 
        // resize and update the volVars with the initial solution
        gridVolVars_.update(this->gridGeometry(), curSol);
 
        // update the flux variables caches
        gridFluxVarsCache_.update(this->gridGeometry(), gridVolVars_, curSol);
    }
 
    void forceUpdateAll(const SolutionVector& curSol)
    {
        ParentType::update(curSol);
 
        // resize and update the volVars with the initial solution
        gridVolVars_.update(this->gridGeometry(), curSol);
 
        // update the flux variables caches
        gridFluxVarsCache_.update(this->gridGeometry(), gridVolVars_, curSol, true);
    }
 
    const GridFluxVariablesCache& gridFluxVarsCache() const
    { return gridFluxVarsCache_; }
 
    GridFluxVariablesCache& gridFluxVarsCache()
    { return gridFluxVarsCache_; }
 
    const GridVolumeVariables& gridVolVars() const
    { return gridVolVars_; }
 
    GridVolumeVariables& gridVolVars()
    { return gridVolVars_; }
 
    const GridGeometry& gridGeometry() const
    { return *gridGeometry_; }
 
private:
    std::shared_ptr<const GridGeometry> gridGeometry_;
    GridVolumeVariables gridVolVars_;          
    GridFluxVariablesCache gridFluxVarsCache_; 
};
 
} // end namespace Dumux::Experimental
 
#endif