facet/couplingmapper.hh

Go to the documentation of this file.

/*****************************************************************************
 *   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_FACETCOUPLING_MAPPER_HH
#define DUMUX_FACETCOUPLING_MAPPER_HH
 
#include <memory>
 
#include <dune/common/indices.hh>
#include <dumux/discretization/method.hh>
 
namespace Dumux {
 
template< class BulkFVG,
          class LowDimFVG,
          std::size_t bulkId = 0,
          std::size_t lowDimId = 1,
          class DiscretizationMethod = typename BulkFVG::DiscretizationMethod >
class FacetCouplingMapper;
 
template< class BulkFVG, class FacetFVG, class EdgeFVG,
          std::size_t bulkId = 0,
          std::size_t facetId = 1,
          std::size_t edgeId = 2 >
class FacetCouplingThreeDomainMapper
: public FacetCouplingMapper<BulkFVG, FacetFVG, bulkId, facetId>
, public FacetCouplingMapper<FacetFVG, EdgeFVG, facetId, edgeId>
{
    using BulkFacetMapper = FacetCouplingMapper<BulkFVG, FacetFVG, bulkId, facetId>;
    using FacetEdgeMapper = FacetCouplingMapper<FacetFVG, EdgeFVG, facetId, edgeId>;
 
    // grid dimensions
    static constexpr int bulkDim = BulkFVG::GridView::dimension;
    static constexpr int facetDim = FacetFVG::GridView::dimension;
    static constexpr int edgeDim = EdgeFVG::GridView::dimension;
 
    template<std::size_t id>
    using GridIdType = Dune::index_constant<id>;
 
public:
    static constexpr auto bulkGridId = Dune::index_constant< bulkId >();
    static constexpr auto facetGridId = Dune::index_constant< facetId >();
    static constexpr auto edgeGridId = Dune::index_constant< edgeId >();
 
    template<std::size_t i>
    using Stencil = typename std::conditional< (i == edgeId),
                                               typename FacetEdgeMapper::template Stencil<i>,
                                               typename BulkFacetMapper::template Stencil<i> >::type;
 
    template<std::size_t i, std::size_t j>
    using CouplingMap = typename std::conditional< (i != edgeId && j != edgeId),
                                                   typename BulkFacetMapper::template CouplingMap<i,j>,
                                                   typename FacetEdgeMapper::template CouplingMap<i,j> >::type;
 
    template<int dim>
    static constexpr GridIdType< ( dim == bulkDim ? bulkId : (dim == facetDim ? facetId : edgeId) ) > gridId()
    { return GridIdType< ( dim == bulkDim ? bulkId : (dim == facetDim ? facetId : edgeId) ) >(); }
 
    template< class Embeddings >
    void update(const BulkFVG& bulkFvGridGeometry,
                const FacetFVG& facetFvGridGeometry,
                const EdgeFVG& edgeFvGridGeometry,
                std::shared_ptr<const Embeddings> embeddings)
    {
        BulkFacetMapper::update(bulkFvGridGeometry, facetFvGridGeometry, embeddings);
        FacetEdgeMapper::update(facetFvGridGeometry, edgeFvGridGeometry, embeddings);
    }
 
    using BulkFacetMapper::update;
    using FacetEdgeMapper::update;
 
    using BulkFacetMapper::couplingMap;
    using FacetEdgeMapper::couplingMap;
};
 
} // end namespace Dumux
 
// Here, we have to include all available implementations
#include <dumux/multidomain/facet/box/couplingmapper.hh>
#include <dumux/multidomain/facet/cellcentered/tpfa/couplingmapper.hh>
#include <dumux/multidomain/facet/cellcentered/mpfa/couplingmapper.hh>
 
#endif