dune-grid  2.6-git
mcmgmapper.hh
Go to the documentation of this file.
1 // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 // vi: set et ts=4 sw=2 sts=2:
3 
4 #ifndef DUNE_GRID_COMMON_MCMGMAPPER_HH
5 #define DUNE_GRID_COMMON_MCMGMAPPER_HH
6 
7 #include <functional>
8 #include <iostream>
9 
10 #include <dune/common/deprecated.hh>
11 #include <dune/common/exceptions.hh>
12 #include <dune/common/rangeutilities.hh>
13 #include <dune/geometry/dimension.hh>
14 #include <dune/geometry/referenceelements.hh>
15 #include <dune/geometry/type.hh>
16 #include <dune/geometry/typeindex.hh>
17 
18 #include "mapper.hh"
19 
26 namespace Dune
27 {
34  //
36  // Common Layout templates
37  //
38 
40 
49  template<int dimgrid> struct DUNE_DEPRECATED_MSG("The MCMG layout classes have been deprecated. Pass `mcmgElementLayout()` to the constructor instead")
53  bool contains (Dune::GeometryType gt) const { return gt.dim()==dimgrid; }
54  };
55 
57 
66  template<int dim> struct DUNE_DEPRECATED_MSG("The MCMG layout classes have been deprecated. Pass `mcmgVertexLayout()` to the constructor instead")
70  bool contains (Dune::GeometryType gt) const { return gt.dim()==0; }
71  };
72 
73  namespace Impl {
74 
75  /*
76  * Dummy layout to be used as the default for
77  * `MultipleCodimMultipleGeomTypeMapper`. It should never be used, but
78  * we need a default.
79  *
80  * This class can be removed once the `LayoutClass` template parameter
81  * of `MultipleCodimMultipleGeomTypeMapper` is removed.
82  */
83  template<int dimgrid>
84  struct MCMGFailLayout {
85  MCMGFailLayout()
86  { DUNE_THROW(Exception, "The default layout class cannot be used"); }
87  bool contains(GeometryType gt) const
88  { DUNE_THROW(Exception, "The default layout class cannot be used"); }
89  };
90 
91  } /* namespace Impl */
92 
117  using MCMGLayout = std::function<size_t(GeometryType, int)>;
118 
124  template<int codim>
125  MCMGLayout mcmgLayout(Codim<codim>)
126  {
127  return [](GeometryType gt, int dimgrid) {
128  return dimgrid - gt.dim() == codim;
129  };
130  }
131 
137  template<int dim>
139  {
140  return [](GeometryType gt, int) {
141  return gt.dim() == dim;
142  };
143  }
144 
151  {
152  return mcmgLayout(Codim<0>());
153  }
154 
161  {
162  return mcmgLayout(Dim<0>());
163  }
164 
166  //
167  // MultipleCodimMultipleGeomTypeMapper
168  //
169 
197  template <typename GV, template<int> class LayoutClass = Impl::MCMGFailLayout>
199  public Mapper<typename GV::Grid,MultipleCodimMultipleGeomTypeMapper<GV,LayoutClass>, typename GV::IndexSet::IndexType >
200  {
201  public:
202 
204  typedef GV GridView;
205 
207  typedef typename GV::IndexSet::IndexType Index;
208 
213  using size_type = decltype(std::declval<typename GV::IndexSet>().size(0));
214 
222  MultipleCodimMultipleGeomTypeMapper(const GV& gridView, const LayoutClass<GV::dimension> layout = {})
223  DUNE_DEPRECATED_MSG("Use the constructor taking a `MCMGLayout` functional instead")
224  : MultipleCodimMultipleGeomTypeMapper(gridView, wrapLayoutClass(layout))
225  {}
226 
238  MultipleCodimMultipleGeomTypeMapper(const GV& gridView, const MCMGLayout& layout)
239  : gridView_(gridView)
240  , is(gridView_.indexSet())
241  , layout_(layout)
242  {
243  update();
244  }
245 
253  template<class EntityType>
254  Index index (const EntityType& e) const
255  {
256  const GeometryType gt = e.type();
257  assert(offset(gt) != invalidOffset);
258  return is.index(e)*blockSize(gt) + offset(gt);
259  }
260 
268  Index subIndex (const typename GV::template Codim<0>::Entity& e, int i, unsigned int codim) const
269  {
270  const GeometryType eType = e.type();
271  GeometryType gt = eType.isNone() ?
272  GeometryTypes::none( GV::dimension - codim ) :
273  ReferenceElements<double,GV::dimension>::general(eType).type(i,codim) ;
274  //GeometryType gt=ReferenceElements<double,GV::dimension>::general(e.type()).type(i,codim);
275  assert(offset(gt) != invalidOffset);
276  return is.subIndex(e, i, codim)*blockSize(gt) + offset(gt);
277  }
278 
287  size_type size () const
288  {
289  return n;
290  }
291 
294  {
295  return blockSize(gt);
296  }
297 
299  const std::vector< GeometryType >& types ( int codim ) const
300  {
301  return myTypes_[ codim ];
302  }
303 
313  template<class EntityType>
314  IntegralRange<Index> indices (const EntityType& e) const
315  {
316  if(!is.contains(e) || offset(e.type()) == invalidOffset)
317  return {0,0};
318  Index start = index(e);
319  return {start, start+blockSize(e.type())};
320  }
321 
333  IntegralRange<Index> indices (const typename GV::template Codim<0>::Entity& e, int i, int cc) const
334  {
335  const GeometryType eType = e.type();
336  const GeometryType gt = eType.isNone() ?
337  GeometryTypes::none(GV::dimension - cc) :
338  ReferenceElements<double,GV::dimension>::general(eType).type(i,cc) ;
339  if (offset(gt) == invalidOffset)
340  return {0,0};
341  else
342  {
343  Index start = subIndex(e,i,cc);
344  return {start, start+blockSize(gt)};
345  }
346  }
347 
354  template<class EntityType>
355  bool contains (const EntityType& e, Index& result) const
356  {
357  if(!is.contains(e) || offset(e.type()) == invalidOffset)
358  {
359  result = 0;
360  return false;
361  }
362  result = index(e);
363  return true;
364  }
365 
374  bool contains (const typename GV::template Codim<0>::Entity& e, int i, int cc, Index& result) const
375  {
376  const GeometryType eType = e.type();
377  const GeometryType gt = eType.isNone() ?
378  GeometryTypes::none( GV::dimension - cc ) :
379  ReferenceElements<double,GV::dimension>::general(eType).type(i,cc) ;
380  //GeometryType gt=ReferenceElements<double,GV::dimension>::general(e.type()).type(i,cc);
381  if (offset(gt) == invalidOffset)
382  return false;
383  result = is.subIndex(e, i, cc) + offset(gt);
384  return true;
385  }
386 
389  void update ()
390  {
391  n = 0;
392 
393  std::fill(offsets.begin(),offsets.end(),Index(0));
394  std::fill(blocks.begin(),blocks.end(),Index(0));
395 
396  for (unsigned int codim = 0; codim <= GV::dimension; ++codim)
397  {
398  // walk over all geometry types in the codimension
399  for (const GeometryType& gt : is.types(codim)) {
400  Index offset;
401  size_t block = layout()(gt, GV::Grid::dimension);
402 
403  // if the geometry type is contained in the layout, increment offset
404  // and store geometry type
405  if (block) {
406  offset = n;
407  n += is.size(gt) * block;
408  myTypes_[codim].push_back(gt);
409  }
410  else {
411  offset = invalidOffset;
412  }
413 
414  offsets[GlobalGeometryTypeIndex::index(gt)] = offset;
415  blocks[GlobalGeometryTypeIndex::index(gt)] = block;
416  }
417  }
418  }
419 
420  const MCMGLayout &layout () const { return layout_; }
421  const GridView &gridView () const { return gridView_; }
422 
423  private:
424  Index offset(GeometryType gt) const
425  { return offsets[GlobalGeometryTypeIndex::index(gt)]; }
426  Index blockSize(GeometryType gt) const
427  { return blocks[GlobalGeometryTypeIndex::index(gt)]; }
428 
429  static const Index invalidOffset = std::numeric_limits<Index>::max();
430 
431  // number of data elements required
432  unsigned int n;
433  // GridView is needed to keep the IndexSet valid
434  const GV gridView_;
435  const typename GV::IndexSet& is;
436  // provide an array for the offsets
437  std::array<Index, GlobalGeometryTypeIndex::size(GV::dimension)> offsets;
438  std::array<Index, GlobalGeometryTypeIndex::size(GV::dimension)> blocks;
439  const MCMGLayout layout_; // get layout object
440  std::vector<GeometryType> myTypes_[GV::dimension+1];
441 
442  protected:
446  static MCMGLayout wrapLayoutClass(const LayoutClass<GV::dimension>& layout)
447  {
448  /* `mutable` as the `contains()` method is not required to be const */
449  return [layout = layout](GeometryType gt, int) mutable {
450  return layout.contains(gt);
451  };
452  }
453  };
454 
456  //
457  // Leaf and level mapper
458  //
459 
470  template <typename G, template<int> class LayoutClass = Impl::MCMGFailLayout>
472  : public MultipleCodimMultipleGeomTypeMapper<typename G::LeafGridView,LayoutClass>
473  {
474  typedef MultipleCodimMultipleGeomTypeMapper<typename G::LeafGridView,
475  LayoutClass> Base;
476  public:
484  LeafMultipleCodimMultipleGeomTypeMapper (const G& grid, const LayoutClass<G::dimension> layout = {})
485  DUNE_DEPRECATED_MSG("Use the constructor taking a `MCMGLayout` functional instead")
486  : LeafMultipleCodimMultipleGeomTypeMapper(grid, Base::wrapLayoutClass(layout))
487  {}
488 
496  : Base(grid.leafGridView(), layout)
497  {}
498  };
499 
511  template <typename G, template<int> class LayoutClass = Impl::MCMGFailLayout>
513  : public MultipleCodimMultipleGeomTypeMapper<typename G::LevelGridView,LayoutClass> {
514  typedef MultipleCodimMultipleGeomTypeMapper<typename G::LevelGridView,
515  LayoutClass> Base;
516  public:
525  LevelMultipleCodimMultipleGeomTypeMapper (const G& grid, int level, const LayoutClass<G::dimension> layout = {})
526  DUNE_DEPRECATED_MSG("Use the constructor taking a `MCMGLayout` functional instead")
527  : LevelMultipleCodimMultipleGeomTypeMapper(grid, level, Base::wrapLayoutClass(layout))
528  {}
529 
537  LevelMultipleCodimMultipleGeomTypeMapper (const G& grid, int level, const MCMGLayout& layout)
538  : Base(grid.levelGridView(level),layout)
539  {}
540  };
541 
543 }
544 #endif
IntegralRange< Index > indices(const typename GV::template Codim< 0 >::Entity &e, int i, int cc) const
Returns a pair with the starting point in the dof vector and the number of degrees of freedom if the ...
Definition: mcmgmapper.hh:333
bool contains(Dune::GeometryType gt) const
Definition: mcmgmapper.hh:70
Index subIndex(const typename GV::template Codim< 0 >::Entity &e, int i, unsigned int codim) const
Map subentity of codim 0 entity to starting index in array for dof block.
Definition: mcmgmapper.hh:268
Layout template for vertices.
Definition: mcmgmapper.hh:66
MCMGLayout mcmgElementLayout()
layout for elements (codim-0 entities)
Definition: mcmgmapper.hh:150
LeafMultipleCodimMultipleGeomTypeMapper(const G &grid, const MCMGLayout &layout)
constructor
Definition: mcmgmapper.hh:495
GV::IndexSet::IndexType Index
Number type used for indices.
Definition: mcmgmapper.hh:207
Implementation class for a multiple codim and multiple geometry type mapper.
Definition: mcmgmapper.hh:198
LevelMultipleCodimMultipleGeomTypeMapper(const G &grid, int level, const LayoutClass< G::dimension > layout={})
The constructor.
Definition: mcmgmapper.hh:525
size_type size(GeometryType gt) const
return number of entries for a given geometry type
Definition: mcmgmapper.hh:293
GV GridView
Underlying GridView.
Definition: mcmgmapper.hh:204
Layout template for elements.
Definition: mcmgmapper.hh:49
const MCMGLayout & layout() const
Definition: mcmgmapper.hh:420
Grid< dim, dimworld, ct, GridFamily >::LevelGridView levelGridView(const Grid< dim, dimworld, ct, GridFamily > &grid, int level)
level grid view for the given grid and level.
Definition: common/grid.hh:792
Multiple codim and multiple geometry type mapper for entities of one level.
Definition: mcmgmapper.hh:512
void update()
Recalculates map after mesh adaptation.
Definition: mcmgmapper.hh:389
MCMGLayout mcmgVertexLayout()
layout for vertices (dim-0 entities)
Definition: mcmgmapper.hh:160
int max(const DofVectorPointer< int > &dofVector)
Definition: dofvector.hh:335
GeometryType
Type representing VTK&#39;s entity geometry types.
Definition: common.hh:178
const GridView & gridView() const
Definition: mcmgmapper.hh:421
MultipleCodimMultipleGeomTypeMapper(const GV &gridView, const MCMGLayout &layout)
construct mapper from grid and layout description
Definition: mcmgmapper.hh:238
static MCMGLayout wrapLayoutClass(const LayoutClass< GV::dimension > &layout)
wrap legacy layout classes
Definition: mcmgmapper.hh:446
MCMGLayout mcmgLayout(Codim< codim >)
layout for entities of codimension codim
Definition: mcmgmapper.hh:125
decltype(std::declval< typename G::LeafGridView ::IndexSet >().size(0)) size_type
Number type used for the overall size (the return value of the &#39;size&#39; method)
Definition: mcmgmapper.hh:213
Index index(const EntityType &e) const
Map entity to starting index in array for dof block.
Definition: mcmgmapper.hh:254
bool contains(Dune::GeometryType gt) const
Definition: mcmgmapper.hh:53
bool contains(const EntityType &e, Index &result) const
Returns true if the entity is contained in the index set.
Definition: mcmgmapper.hh:355
const std::vector< GeometryType > & types(int codim) const
return the geometry types with entries
Definition: mcmgmapper.hh:299
Mapper interface.
Definition: mapper.hh:107
std::function< size_t(GeometryType, int)> MCMGLayout
layout function for MultipleCodimMultipleGeomTypeMapper
Definition: mcmgmapper.hh:117
bool contains(const typename GV::template Codim< 0 >::Entity &e, int i, int cc, Index &result) const
Returns true if the entity is contained in the index set.
Definition: mcmgmapper.hh:374
MultipleCodimMultipleGeomTypeMapper(const GV &gridView, const LayoutClass< GV::dimension > layout={})
Construct mapper from grid and one of its index sets.
Definition: mcmgmapper.hh:222
Grid< dim, dimworld, ct, GridFamily >::LeafGridView leafGridView(const Grid< dim, dimworld, ct, GridFamily > &grid)
leaf grid view for the given grid
Definition: common/grid.hh:809
size_type size() const
Return total number of entities in the entity set managed by the mapper.
Definition: mcmgmapper.hh:287
Provides classes with basic mappers which are used to attach data to a grid.
LeafMultipleCodimMultipleGeomTypeMapper(const G &grid, const LayoutClass< G::dimension > layout={})
The constructor.
Definition: mcmgmapper.hh:484
Multiple codim and multiple geometry type mapper for leaf entities.
Definition: mcmgmapper.hh:471
LevelMultipleCodimMultipleGeomTypeMapper(const G &grid, int level, const MCMGLayout &layout)
constructor
Definition: mcmgmapper.hh:537
IntegralRange< Index > indices(const EntityType &e) const
Returns a pair with the starting point in the dof vector and the number of degrees of freedom if the ...
Definition: mcmgmapper.hh:314
Include standard header files.
Definition: agrid.hh:58