discretization/gridvariables.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_GRID_VARIABLES_HH
#define DUMUX_GRID_VARIABLES_HH
 
#include <memory>
 
namespace Dumux::Experimental {

template<class GG, class GVC>
class GridVariables
{
public:
    using GridDiscretization = GG;

    using GridVariablesCache = GVC;

    using Variables = typename GridVariablesCache::Variables;

    using PrimaryVariables = typename Variables::PrimaryVariables;

    using Scalar = typename PrimaryVariables::value_type;
 
    template<class Problem>
    GridVariables(std::shared_ptr<Problem> problem,
                  std::shared_ptr<const GridDiscretization> gridDiscretization)
    : gridDiscretization_(gridDiscretization)
    , curGridVars_(*problem)
    , prevGridVars_(*problem)
    {}

    template<class SolutionVector>
    void init(const SolutionVector& curSol)
    {
        // initialize and update the current grid variables with a given solution
        curGridVars_.init(*gridDiscretization_, curSol);
 
        // set the variables 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 is outweighed by the advantage of having a single grid variables object for
        // stationary and instationary problems
        prevGridVars_ = curGridVars_;
    }

    template<class SolutionVector>
    void update(const SolutionVector& curSol)
    {
        // update the current grid variables for the given solution
        curGridVars_.update(*gridDiscretization_, curSol);
    }

    template<class SolutionVector>
    void updateAfterGridAdaption(const SolutionVector& curSol)
    {
        // update (always force data cache update as the grid changed)
        curGridVars_.init(*gridDiscretization_, curSol);
 
        // for instationary problems also update the variables
        // for the previous time step to the new grid
        prevGridVars_ = curGridVars_;
    }

    void advanceTimeStep()
    {
        prevGridVars_ = curGridVars_;
    }

    template<class SolutionVector>
    void resetTimeStep(const SolutionVector& solution)
    {
        // set the new time step variables to old variables
        curGridVars_ = prevGridVars_;
    }

    const GridVariablesCache& curGridVars() const
    { return curGridVars_; }

    GridVariablesCache& curGridVars()
    { return curGridVars_; }

    const GridVariablesCache& prevGridVars() const
    { return prevGridVars_; }

    GridVariablesCache& prevGridVars()
    { return prevGridVars_; }

    const GridDiscretization& gridDiscretization() const
    { return *gridDiscretization_; }
 
protected:
    std::shared_ptr<const GridDiscretization> gridDiscretization_; 
 
private:
    GridVariablesCache curGridVars_; 
    GridVariablesCache prevGridVars_; 
};
 
} // end namespace Dumux::Experimental
 
#endif