scsgmapper.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// $Id$
 
#ifndef DUNE_SCSGMAPPER_HH
#define DUNE_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> >
  {
  public:
 
    using Mapper< typename GV::Grid, SingleCodimSingleGeomTypeMapper >::map;
    using Mapper< typename GV::Grid, SingleCodimSingleGeomTypeMapper >::contains;
 
    SingleCodimSingleGeomTypeMapper (const GV& gridView);
 
    template<class EntityType>
    int map (const EntityType& e) const;
 
    int map (const typename GV::template Codim<0>::Entity& e,
             int i, unsigned int codim) const;
 
    int size () const;
 
    template<class EntityType>
    bool contains (const EntityType& e, int& result) const;
 
    bool contains (const typename GV::template Codim<0>::Entity& e, int i, int cc, int& result) const;
 
    void update ()
    {     // nothing to do here
    }
 
  private:
    const typename GV::IndexSet& is;
  };
 
  template <typename GV, int c>
  SingleCodimSingleGeomTypeMapper<GV,c>::SingleCodimSingleGeomTypeMapper (const GV& gridView)
    : is(gridView.indexSet())
  {
    // check that grid has only a single geometry type
    if (is.geomTypes(c).size() != 1)
      DUNE_THROW(GridError, "mapper treats only a single codim and a single geometry type");
  }
 
  template <typename GV, int c>
  template<class EntityType>
  inline int SingleCodimSingleGeomTypeMapper<GV,c>::map (const EntityType& e) const
  {
    enum { cc = EntityType::codimension };
    dune_static_assert(cc == c, "Entity of wrong codim passed to SingleCodimSingleGeomTypeMapper");
    return is.index(e);
  }
 
  template <typename GV, int c>
  inline int SingleCodimSingleGeomTypeMapper<GV,c>::map (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 is.subIndex(e,i,codim);
  }
 
  template <typename GV, int c>
  inline int SingleCodimSingleGeomTypeMapper<GV,c>::size () const
  {
    return is.size(c);
  }
 
  template <typename GV, int c>
  template<class EntityType>
  inline bool SingleCodimSingleGeomTypeMapper<GV,c>::contains (const EntityType& e, int& result) const
  {
    result = map(e);
    return true;
  }
 
  template <typename GV, int c>
  inline bool SingleCodimSingleGeomTypeMapper<GV,c>::contains (const typename GV::template Codim<0>::Entity& e, int i, int cc, int& result) const
  {
    result = this->map(e,i,cc);
    return true;
  }
 
  template <typename G, int c>
  class LeafSingleCodimSingleGeomTypeMapper : public SingleCodimSingleGeomTypeMapper<typename G::LeafGridView,c> {
  public:
    /* @brief The constructor
       @param grid A reference to a grid.
     */
    LeafSingleCodimSingleGeomTypeMapper (const G& grid)
      : SingleCodimSingleGeomTypeMapper<typename G::LeafGridView,c>(grid.leafView())
    {}
  };
 
  template <typename G, int c>
  class LevelSingleCodimSingleGeomTypeMapper : public 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)
      : SingleCodimSingleGeomTypeMapper<typename G::LevelGridView,c>(grid.levelGridView(level))
    {}
  };
 
}
#endif