discretization/staggered/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-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_STAGGERED_GRID_VARIABLES_HH
#define DUMUX_STAGGERED_GRID_VARIABLES_HH
 
#include <dumux/discretization/fvgridvariables.hh>
 
namespace Dumux {
 
template<class ActualGridVariables>
class StaggeredGridVariablesView
{
public:
    using GridVolumeVariables = typename ActualGridVariables::GridVolumeVariables;
    using GridFaceVariables = typename ActualGridVariables::GridFaceVariables;
    using GridFluxVariablesCache = typename ActualGridVariables::GridFluxVariablesCache;
 
    using VolumeVariables = typename GridVolumeVariables::VolumeVariables;
 
    using PrimaryVariables = typename VolumeVariables::PrimaryVariables;
    using GridGeometry = typename ActualGridVariables::GridGeometry;
 
    explicit StaggeredGridVariablesView(ActualGridVariables* gridVariables)
    : gridVariables_(gridVariables) {}
 
    const GridFluxVariablesCache& gridFluxVarsCache() const
    { return gridVariables_->gridFluxVarsCache(); }
 
    GridFluxVariablesCache& gridFluxVarsCache()
    { return gridVariables_->gridFluxVarsCache(); }
 
    const GridVolumeVariables& curGridVolVars() const
    { return gridVariables_->curGridVolVars(); }
 
    GridVolumeVariables& curGridVolVars()
    { return gridVariables_->curGridVolVars(); }
 
    const GridVolumeVariables& prevGridVolVars() const
    { return gridVariables_->prevGridVolVars(); }
 
    GridVolumeVariables& prevGridVolVars()
    { return gridVariables_->prevGridVolVars(); }
 
    const GridFaceVariables& curGridFaceVars() const
    { return gridVariables_->curGridFaceVars(); }
 
    const GridFaceVariables& prevGridFaceVars() const
    { return gridVariables_->prevGridFaceVars(); }
 
    GridFaceVariables& curGridFaceVars()
    { return gridVariables_->curGridFaceVars(); }
 
    GridFaceVariables& prevGridFaceVars()
    { return gridVariables_->prevGridFaceVars(); }
 
    const GridGeometry& gridGeometry() const
    { return (*gridVariables_->gridGeometry_);    }
 
    // return the actual grid variables
    const ActualGridVariables& gridVariables() const
    { return *gridVariables_; }
 
    // return the actual grid variables
    ActualGridVariables& gridVariables()
    { return *gridVariables_; }
 
protected:
    ActualGridVariables* gridVariables_;
};
 
template<class ActualGridVariables>
class CellCenterGridVariablesView : public StaggeredGridVariablesView<ActualGridVariables>
{
    using ParentType = StaggeredGridVariablesView<ActualGridVariables>;
public:
    using ParentType::ParentType;
 
    template<class SolVector>
    void init(const SolVector& curSol)
    {
        this->curGridVolVars().update(this->gridGeometry(), curSol);
        this->gridFluxVarsCache().update(this->gridGeometry(), this->curGridVolVars(), curSol, true);
        this->prevGridVolVars().update(this->gridGeometry(), curSol);
    }
 
    template<class SolVector>
    void update(const SolVector& curSol)
    {
        this->curGridVolVars().update(this->gridGeometry(), curSol);
        this->gridFluxVarsCache().update(this->gridGeometry(), this->curGridVolVars(), curSol);
    }
 
    template<class SolVector>
    void resetTimeStep(const SolVector& sol)
    {
        this->curGridVolVars() = this->prevGridVolVars();
        this->gridFluxVarsCache().update(this->gridGeometry(), this->curGridVolVars(), sol);
    }
};
 
template<class ActualGridVariables>
class FaceGridVariablesView : public StaggeredGridVariablesView<ActualGridVariables>
{
    using ParentType = StaggeredGridVariablesView<ActualGridVariables>;
public:
    using ParentType::ParentType;
 
    template<class SolVector>
    void init(const SolVector& curSol)
    {
        this->curGridFaceVars().update(this->gridGeometry(), curSol);
        this->prevGridFaceVars().update(this->gridGeometry(), curSol);
    }
 
    template<class SolVector>
    void update(const SolVector& curSol)
    {
        this->curGridFaceVars().update(this->gridGeometry(), curSol);
    }
 
    template<class SolVector>
    void resetTimeStep(const SolVector& sol)
    {
        this->curGridFaceVars() = this->prevGridFaceVars();
    }
};
 
 
 
template<class GG, class GVV, class GFVC, class GFV>
class StaggeredGridVariables : public FVGridVariables<GG, GVV, GFVC>
{
    using ParentType = FVGridVariables<GG, GVV, GFVC>;
    using ThisType = StaggeredGridVariables<GG, GVV, GFVC, GFV>;
    friend class StaggeredGridVariablesView<ThisType>;
 
    static constexpr auto cellCenterIdx = GG::cellCenterIdx();
    static constexpr auto faceIdx = GG::faceIdx();
 
public:
    using CellCenterGridVariablesType = CellCenterGridVariablesView<ThisType>;
    using FaceGridVariablesType = FaceGridVariablesView<ThisType>;
 
    using GridVolumeVariables = GVV;
    using GridFluxVariablesCache = GFVC;
    using GridFaceVariables = GFV;
    using GridGeometry = GG;
 
    template<class Problem>
    StaggeredGridVariables(std::shared_ptr<Problem> problem,
                           std::shared_ptr<GridGeometry> gridGeometry)
    : ParentType(problem, gridGeometry)
    , curGridFaceVariables_(*problem)
    , prevGridFaceVariables_(*problem)
    {}
 
    template<class SolutionVector>
    void update(const SolutionVector& curSol)
    {
        ParentType::update(curSol[cellCenterIdx]);
        curGridFaceVariables_.update(*this->gridGeometry_, curSol[faceIdx]);
    }
 
    template<class SolutionVector>
    void init(const SolutionVector& curSol)
    {
        ParentType::init(curSol[cellCenterIdx]);
        curGridFaceVariables_.update(*this->gridGeometry_, curSol[faceIdx]);
        prevGridFaceVariables_.update(*this->gridGeometry_, curSol[faceIdx]);
    }
 
    void advanceTimeStep()
    {
        ParentType::advanceTimeStep();
        prevGridFaceVariables_ = curGridFaceVariables_;
    }
 
    template<class SolutionVector>
    void resetTimeStep(const SolutionVector& solution)
    {
        ParentType::resetTimeStep(solution);
        curGridFaceVariables_ = prevGridFaceVariables_;
    }
 
    const GridFaceVariables& curGridFaceVars() const
    { return curGridFaceVariables_; }
 
    const GridFaceVariables& prevGridFaceVars() const
    { return prevGridFaceVariables_; }
 
    GridFaceVariables& curGridFaceVars()
    { return curGridFaceVariables_; }
 
    GridFaceVariables& prevGridFaceVars()
    { return prevGridFaceVariables_; }
 
    std::unique_ptr<CellCenterGridVariablesView<ThisType>> cellCenterGridVariablesPtr()
    {
        return std::make_unique<CellCenterGridVariablesView<ThisType>>(this);
    }
 
    std::unique_ptr<FaceGridVariablesView<ThisType>> faceGridVariablesPtr()
    {
        return std::make_unique<FaceGridVariablesView<ThisType>>(this);
    }
 
    CellCenterGridVariablesView<ThisType> cellCenterGridVariables() const
    {
        return CellCenterGridVariablesView<ThisType>(this);
    }
 
    FaceGridVariablesView<ThisType> faceGridVariables() const
    {
        return FaceGridVariablesView<ThisType>(this);
    }
 
 
private:
    GridFaceVariables curGridFaceVariables_;
    GridFaceVariables prevGridFaceVariables_;
};
 
} // end namespace Dumux
 
#endif