dualgridindexset.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_DISCRETIZATION_MPFA_DUALGRID_INDEX_SET_HH
#define DUMUX_DISCRETIZATION_MPFA_DUALGRID_INDEX_SET_HH
 
#include <cassert>
#include <vector>
#include <algorithm>
 
#include <dune/common/reservedvector.hh>
#include <dumux/common/indextraits.hh>
 
namespace Dumux {
 
template<class GV>
struct NodalIndexSetDefaultTraits
{
    using GridView = GV;
    using GridIndexType = typename IndexTraits<GV>::GridIndex;
    using LocalIndexType = typename IndexTraits<GV>::LocalIndex;
 
    template< class T > using NodalScvDataStorage = std::vector< T >;
    template< class T > using NodalScvfDataStorage = std::vector< T >;
 
    template< class T >
    using ScvfNeighborDataStorage = typename std::conditional_t< (int(GV::dimension)<int(GV::dimensionworld)),
                                                                 std::vector< T >,
                                                                 Dune::ReservedVector< T, 2 > >;
};
 
template< class T >
class CCMpfaDualGridNodalIndexSet
{
    using LI = typename T::LocalIndexType;
    using GI = typename T::GridIndexType;
 
    using DimIndexVector = Dune::ReservedVector<LI, T::GridView::dimension>;
    using ScvfIndicesInScvStorage = typename T::template NodalScvDataStorage< DimIndexVector >;
 
public:
    using Traits = T;
 
    using LocalIndexType = LI;
    using GridIndexType = GI;
 
    using NodalGridStencilType = typename T::template NodalScvDataStorage< GI >;
    using NodalLocalStencilType = typename T::template NodalScvDataStorage< LI >;
    using NodalGridScvfStencilType = typename T::template NodalScvfDataStorage< GI >;
 
    using ScvfNeighborLocalIndexSet = typename T::template ScvfNeighborDataStorage< LI >;
 
    CCMpfaDualGridNodalIndexSet() : numBoundaryScvfs_(0) {}
 
    template<typename SubControlVolumeFace>
    void insert(const SubControlVolumeFace& scvf)
    {
        insert(scvf.index(), scvf.insideScvIdx(), scvf.boundary());
    }
 
    void insert(const GridIndexType scvfIdx,
                const GridIndexType insideScvIdx,
                const bool boundary)
    {
        // this should always be called only once per scvf
        assert(std::count(scvfIndices_.begin(), scvfIndices_.end(), scvfIdx ) == 0 && "scvf already inserted!");
 
        // the local index of the scvf data about to be inserted
        const LocalIndexType curScvfLocalIdx = scvfIndices_.size();
 
        // if scvf is on boundary, increase counter
        if (boundary) numBoundaryScvfs_++;
 
        // insert data on the new scv
        scvfIndices_.push_back(scvfIdx);
        scvfIsOnBoundary_.push_back(boundary);
 
        // if entry for the inside scv exists append data, create otherwise
        auto it = std::find( scvIndices_.begin(), scvIndices_.end(), insideScvIdx );
        if (it != scvIndices_.end())
        {
            const auto scvIdxLocal = std::distance(scvIndices_.begin(), it);
            scvfInsideScvIndices_.push_back(scvIdxLocal);
            localScvfIndicesInScv_[scvIdxLocal].push_back(curScvfLocalIdx);
        }
        else
        {
            scvfInsideScvIndices_.push_back(scvIndices_.size());
            localScvfIndicesInScv_.push_back({curScvfLocalIdx});
            scvIndices_.push_back(insideScvIdx);
        }
    }
 
    std::size_t numScvs() const
    { return scvIndices_.size(); }
 
    std::size_t numScvfs() const
    { return scvfIndices_.size(); }
 
    std::size_t numBoundaryScvfs() const
    { return numBoundaryScvfs_; }
 
    const NodalGridStencilType& gridScvIndices() const
    { return scvIndices_; }
 
    const NodalGridScvfStencilType& gridScvfIndices() const
    { return scvfIndices_; }
 
    bool scvfIsOnBoundary(unsigned int i) const
    {
        assert(i < numScvfs());
        return scvfIsOnBoundary_[i];
    }
 
    GridIndexType gridScvIndex(unsigned int i) const
    {
        assert(i < numScvs());
        return scvIndices_[i];
    }
 
    GridIndexType gridScvfIndex(unsigned int i) const
    {
        assert(i < numScvfs());
        return scvfIndices_[i];
    }
 
    GridIndexType gridScvfIndex(unsigned int i, unsigned int j) const
    {
        assert(i < numScvs());
        assert(j < localScvfIndicesInScv_[i].size());
        return scvfIndices_[ localScvfIndicesInScv_[i][j] ];
    }
 
    LocalIndexType localScvfIndex(unsigned int i, unsigned int j) const
    {
        assert(i < numScvs());
        assert(j < localScvfIndicesInScv_[i].size());
        return localScvfIndicesInScv_[i][j];
    }
 
    LocalIndexType insideScvLocalIndex(unsigned int i) const
    {
        assert(i < numScvfs());
        return scvfInsideScvIndices_[i];
    }
 
private:
    NodalGridStencilType scvIndices_;               
    ScvfIndicesInScvStorage localScvfIndicesInScv_; 
 
    std::size_t numBoundaryScvfs_;                                         
    NodalGridScvfStencilType scvfIndices_;                                 
    typename T::template NodalScvfDataStorage< bool > scvfIsOnBoundary_;   
    typename T::template NodalScvfDataStorage< LI > scvfInsideScvIndices_; 
};
 
template< class NI >
class CCMpfaDualGridIndexSet
{
public:
    using NodalIndexSet = NI;
    using GridIndexType = typename NodalIndexSet::GridIndexType;
 
    CCMpfaDualGridIndexSet() = delete;
 
    template< class GridView >
    CCMpfaDualGridIndexSet(const GridView& gridView)
    : nodalIndexSets_(gridView.size(GridView::dimension))
    {}
 
    template< class SubControlVolumeFace >
    const NodalIndexSet& operator[] (const SubControlVolumeFace& scvf) const
    { return nodalIndexSets_[scvf.vertexIndex()]; }
 
    template< class SubControlVolumeFace >
    NodalIndexSet& operator[] (const SubControlVolumeFace& scvf)
    { return nodalIndexSets_[scvf.vertexIndex()]; }
 
    const NodalIndexSet& operator[] (GridIndexType i) const
    { return nodalIndexSets_[i]; }
 
    NodalIndexSet& operator[] (GridIndexType i)
    { return nodalIndexSets_[i]; }
 
private:
    std::vector<NodalIndexSet> nodalIndexSets_;
};
 
} // end namespace Dumux
 
#endif