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:
/*****************************************************************************
 *   See the file COPYING for full copying permissions.                      *
 *                                                                           *
 *   This program is free software: you can redistribute it and/or modify    *
 *   it under the terms of the GNU General Public License as published by    *
 *   the Free Software Foundation, either version 3 of the License, or       *
 *   (at your option) any later version.                                     *
 *                                                                           *
 *   This program is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU General Public License for more details.                            *
 *                                                                           *
 *   You should have received a copy of the GNU General Public License       *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
 *****************************************************************************/
#ifndef DUMUX_FV_GRID_VARIABLES_HH
#define DUMUX_FV_GRID_VARIABLES_HH
 
#include <type_traits>
#include <memory>
 
namespace Dumux {
 
template<class GG, class GVV, class GFVC>
class FVGridVariables
{
public:
    using GridGeometry = GG;
 
    using GridVolumeVariables = GVV;
 
    using VolumeVariables = typename GridVolumeVariables::VolumeVariables;
 
    using PrimaryVariables = typename VolumeVariables::PrimaryVariables;
 
    using Scalar = std::decay_t<decltype(std::declval<PrimaryVariables>()[0])>;
 
    using GridFluxVariablesCache = GFVC;
 
    template<class Problem>
    FVGridVariables(std::shared_ptr<Problem> problem,
                    std::shared_ptr<const GridGeometry> gridGeometry)
    : gridGeometry_(gridGeometry)
    , curGridVolVars_(*problem)
    , prevGridVolVars_(*problem)
    , gridFluxVarsCache_(*problem)
    {}
 
    template<class SolutionVector>
    void init(const SolutionVector& curSol)
    {
        // resize and update the volVars with the initial solution
        curGridVolVars_.update(*gridGeometry_, curSol);
 
        // update the flux variables caches (always force flux cache update on initialization)
        gridFluxVarsCache_.update(*gridGeometry_, curGridVolVars_, curSol, true);
 
        // set the volvars of the previous time step in case we have an instationary problem
        // note that this means some memory overhead in the case of enabled caching, however
        // this it outweighted by the advantage of having a single grid variables object for
        // stationary and instationary problems
        prevGridVolVars_ = curGridVolVars_;
    }
 
    template<class SolutionVector>
    void update(const SolutionVector& curSol, bool forceFluxCacheUpdate = false)
    {
        // resize and update the volVars with the initial solution
        curGridVolVars_.update(*gridGeometry_, curSol);
 
        // update the flux variables caches
        gridFluxVarsCache_.update(*gridGeometry_, curGridVolVars_, curSol, forceFluxCacheUpdate);
    }
 
    template<class SolutionVector>
    void updateAfterGridAdaption(const SolutionVector& curSol)
    {
        // update (always force flux cache update as the grid changed)
        update(curSol, true);
 
        // for instationary problems also update the variables
        // for the previous time step to the new grid
        prevGridVolVars_ = curGridVolVars_;
    }
 
    void advanceTimeStep()
    {
        prevGridVolVars_ = curGridVolVars_;
    }
 
    template<class SolutionVector>
    void resetTimeStep(const SolutionVector& solution)
    {
        // set the new time step vol vars to old vol vars
        curGridVolVars_ = prevGridVolVars_;
 
        // update the flux variables caches
        gridFluxVarsCache_.update(*gridGeometry_, curGridVolVars_, solution);
    }
 
    const GridFluxVariablesCache& gridFluxVarsCache() const
    { return gridFluxVarsCache_; }
 
    GridFluxVariablesCache& gridFluxVarsCache()
    { return gridFluxVarsCache_; }
 
    const GridVolumeVariables& curGridVolVars() const
    { return curGridVolVars_; }
 
    GridVolumeVariables& curGridVolVars()
    { return curGridVolVars_; }
 
    const GridVolumeVariables& prevGridVolVars() const
    { return prevGridVolVars_; }
 
    GridVolumeVariables& prevGridVolVars()
    { return prevGridVolVars_; }
 
    const GridGeometry& gridGeometry() const
    { return *gridGeometry_; }
 
protected:
 
    std::shared_ptr<const GridGeometry> gridGeometry_; 
 
private:
    GridVolumeVariables curGridVolVars_; 
    GridVolumeVariables prevGridVolVars_; 
 
    GridFluxVariablesCache gridFluxVarsCache_; 
};
 
} // end namespace Dumux
 
// Experimental implementation of new grid variables layout //
 
#include <dumux/common/typetraits/problem.hh>
#include <dumux/discretization/localview.hh>
#include <dumux/discretization/gridvariables.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 GridVariables<typename ProblemTraits<typename GVV::Problem>::GridGeometry, X>
{
    using Problem = typename GVV::Problem;
    using GG = typename ProblemTraits<Problem>::GridGeometry;
 
    using ParentType = GridVariables<GG, 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(gridGeometry, [problem] (auto& x) { problem->applyInitialSolution(x); })
    , gridVolVars_(*problem)
    , gridFluxVarsCache_(*problem)
    {}
 
    template<class SolOrInitializer>
    FVGridVariables(std::shared_ptr<Problem> problem,
                    std::shared_ptr<const GridGeometry> gridGeometry,
                    SolOrInitializer&& solOrInitializer)
    : ParentType(gridGeometry, std::forward<SolOrInitializer>(solOrInitializer))
    , 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_; }
 
private:
    GridVolumeVariables gridVolVars_;          
    GridFluxVariablesCache gridFluxVarsCache_; 
};
 
} // end namespace Dumux::Experimental
 
#endif