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-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#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
 
#endif