scsgmapper.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_COMMON_SCSGMAPPER_HH
#define DUNE_GRID_COMMON_SCSGMAPPER_HH
 
#include <iostream>
#include "mapper.hh"
 
#include <dune/grid/common/grid.hh>
 
namespace Dune
{
  template <typename GV, int c>
  class SingleCodimSingleGeomTypeMapper :
    public Mapper<typename GV::Grid,SingleCodimSingleGeomTypeMapper<GV,c>, typename GV::IndexSet::IndexType >
  {
  public:
 
    typedef typename GV::IndexSet::IndexType Index;
 
    using size_type = decltype(std::declval<typename GV::IndexSet>().size(0));
 
    SingleCodimSingleGeomTypeMapper (const GV& gridView)
    : gridView_(gridView)
    , indexSet_(&gridView_.indexSet())
    {
      // check that grid has only a single geometry type
      if (indexSet_->types(c).size() != 1)
        DUNE_THROW(GridError, "mapper treats only a single codim and a single geometry type");
    }
 
    template<class EntityType>
    Index index (const EntityType& e) const
    {
      static_assert(EntityType::codimension == c, "Entity of wrong codim passed to SingleCodimSingleGeomTypeMapper");
      return indexSet_->index(e);
    }
 
    Index subIndex (const typename GV::template Codim<0>::Entity& e,
               int i, unsigned int codim) const
    {
      if (codim != c)
        DUNE_THROW(GridError, "Id of wrong codim requested from SingleCodimSingleGeomTypeMapper");
      return indexSet_->subIndex(e,i,codim);
    }
 
    size_type size () const
    {
      return indexSet_->size(c);
    }
 
    template<class EntityType>
    bool contains (const EntityType& e, Index& result) const
    {
      result = index(e);
      return true;
    }
 
    bool contains (const typename GV::template Codim<0>::Entity& e, int i, int cc, Index& result) const
    {
      result = subIndex(e,i,cc);
      return true;
    }
 
    void update (const GV& gridView)
    {
      gridView_ = gridView;
      indexSet_ = &gridView_.indexSet();
    }
 
    void update (GV&& gridView)
    {
      gridView_ = std::move(gridView);
      indexSet_ = &gridView_.indexSet();
    }
 
    [[deprecated("Use update(gridView) instead! Will be removed after release 2.8.")]]
    void update ()
    {     // nothing to do here
    }
 
  private:
    GV gridView_;
    const typename GV::IndexSet* indexSet_;
  };
 
  template <typename G, int c>
  class [[deprecated("Use SingleCodimSingleGeomTypeMapper instead! Will be removed after release 2.8.")]]
  LeafSingleCodimSingleGeomTypeMapper : public SingleCodimSingleGeomTypeMapper<typename G::LeafGridView,c> {
    using Base = SingleCodimSingleGeomTypeMapper<typename G::LeafGridView,c>;
  public:
    LeafSingleCodimSingleGeomTypeMapper (const G& grid)
      : Base(grid.leafGridView())
      , gridPtr_(&grid)
    {}
 
    void update ()
    {
      Base::update(gridPtr_->leafGridView());
    }
 
  private:
    const G* gridPtr_;
  };
 
  template <typename G, int c>
  class [[deprecated("Use SingleCodimSingleGeomTypeMapper instead! Will be removed after release 2.8.")]]
  LevelSingleCodimSingleGeomTypeMapper : public SingleCodimSingleGeomTypeMapper<typename G::LevelGridView,c> {
    using Base = SingleCodimSingleGeomTypeMapper<typename G::LevelGridView,c>;
  public:
    /* @brief The constructor
       @param grid A reference to a grid.
       @param level A valid level of the grid.
     */
    LevelSingleCodimSingleGeomTypeMapper (const G& grid, int level)
      : Base(grid.levelGridView(level))
      , gridPtr_(&grid)
      , level_(level)
    {}
 
    void update ()
    {
      Base::update(gridPtr_->levelGridView(level_));
    }
 
  private:
    const G* gridPtr_;
    int level_;
  };
 
}
#endif