elementmapper.hh

#ifndef DUNE_PDELAB_COMMON_ELEMENTMAPPER_HH
#define DUNE_PDELAB_COMMON_ELEMENTMAPPER_HH
 
#include <vector>
#include <algorithm>
#include <numeric>
 
#include <dune/geometry/type.hh>
#include <dune/geometry/typeindex.hh>
#include <dune/grid/common/capabilities.hh>
 
namespace Dune {
 
  namespace PDELab {
 
#ifndef DOXYGEN
 
    // implementation for mixed grids
    template<typename GV, bool has_single_cell_type>
    class ElementMapperBase
    {
 
    protected:
 
      typedef typename GV::template Codim<0>::Entity Element;
      typedef std::size_t size_type;
 
    private:
 
      static const size_type dim = GV::dimension;
      typedef typename GV::IndexSet IndexSet;
 
    protected:
 
      void update()
      {
        // clear old values
        std::fill(_gt_offsets.begin(),_gt_offsets.end(),0);
 
        // extract per-GeometryType sizes in codim 0
        for (auto gt : _index_set.types(0))
          {
            _gt_offsets[LocalGeometryTypeIndex::index(gt) + 1] = _index_set.size(gt);
          }
 
        // convert to offsets
        std::partial_sum(_gt_offsets.begin(),_gt_offsets.end(),_gt_offsets.begin());
      }
 
      size_type map(const Element& e) const
      {
        return _gt_offsets[LocalGeometryTypeIndex::index(e.type())] + _index_set.index(e);
      }
 
      ElementMapperBase(const GV& gv)
        : _gt_offsets(LocalGeometryTypeIndex::size(dim) + 1)
        , _index_set(gv.indexSet())
      {
        update();
      }
 
    private:
 
      std::vector<size_type> _gt_offsets;
      const IndexSet& _index_set;
 
    };
 
    // implementation for grids with a single codim 0 geometry type
    template<typename GV>
    class ElementMapperBase<GV,true>
    {
 
    protected:
 
      typedef typename GV::template Codim<0>::Entity Element;
      typedef typename GV::IndexSet IndexSet;
      typedef std::size_t size_type;
 
      void update()
      {}
 
      size_type map(const Element& e) const
      {
        return _index_set.index(e);
      }
 
      ElementMapperBase(const GV& gv)
        : _index_set(gv.indexSet())
      {}
 
    private:
 
      const IndexSet& _index_set;
 
    };
 
#endif // DOXYGEN
 
 
 
    template<typename GV>
    class ElementMapper
      : public ElementMapperBase<GV,
                                 Dune::Capabilities::hasSingleGeometryType<
                                   typename GV::Grid
                                   >::v
                                 >
    {
 
      typedef ElementMapperBase<
        GV,
        Dune::Capabilities::hasSingleGeometryType<
          typename GV::Grid
          >::v
        > BaseT;
 
    public:
 
      typedef typename BaseT::size_type size_type;
 
      typedef typename BaseT::Element Element;
 
 
      ElementMapper(const GV& gv)
        : BaseT(gv)
      {}
 
 
      size_type map(const Element& e) const
      {
        return BaseT::map(e);
      }
 
    };
 
  } // namespace PDELab
 
} // namespace Dune
 
#endif // DUNE_PDELAB_COMMON_ELEMENTMAPPER_HH