dune-grid 3.0-git
albertagrid/indexsets.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#ifndef DUNE_ALBERTAGRIDINDEXSETS_HH
4#define DUNE_ALBERTAGRIDINDEXSETS_HH
5
6#include <array>
7
8#include <dune/common/stdstreams.hh>
9
12
19
20#if HAVE_ALBERTA
21
22namespace Dune
23{
24
25 namespace Alberta
26 {
28
30 }
31
32
33
34 // AlbertaGridHierarchicIndexSet
35 // -----------------------------
36
37 template< int dim, int dimworld >
39 : public IndexSet< AlbertaGridFamily< dim, dimworld >, AlbertaGridHierarchicIndexSet< dim,dimworld >, int, std::array< GeometryType, 1 > >
40 {
43
44 friend class AlbertaGrid< dim, dimworld >;
45
46 public:
49
50 typedef typename Base::IndexType IndexType;
51
52 typedef typename Base::Types Types;
53
54 static const int dimension = GridFamily::dimension;
55
58
59 private:
60 typedef typename GridFamily::Traits Traits;
61
63
64 class InitEntityNumber;
65
66 template< int codim >
67 struct CreateEntityNumbers;
68
69 template< int codim >
70 struct RefineNumbering;
71
72 template< int codim >
73 struct CoarsenNumbering;
74
75 explicit AlbertaGridHierarchicIndexSet ( const DofNumbering &dofNumbering );
76
77 public:
79
81 template< class Entity >
82 bool contains ( const Entity & ) const
83 {
84 return true;
85 }
86
87 using Base::index;
88 using Base::subIndex;
89
91 template< int cc >
92 IndexType index ( const typename Traits::template Codim< cc >::Entity &entity ) const
93 {
95 const EntityImp &entityImp = Grid::getRealImplementation( entity );
96 return subIndex( entityImp.elementInfo(), entityImp.subEntity(), cc );
97 }
98
100 template< int cc >
101 IndexType subIndex ( const typename Traits::template Codim< cc >::Entity &entity, int i, unsigned int codim ) const
102 {
104 const EntityImp &entityImp = Grid::getRealImplementation( entity );
105
106 int k = i;
107 if( cc > 0 )
108 {
109 const ReferenceElement< Alberta::Real, dimension > &refElement
110 = ReferenceElements< Alberta::Real, dimension >::simplex();
111 k = refElement.subEntity( entityImp.subEntity(), cc, i, codim );
112 }
113
114 const int j = entityImp.grid().generic2alberta( codim, k );
115 return subIndex( entityImp.elementInfo(), j, codim );
116 }
117
119 IndexType size ( const GeometryType &type ) const
120 {
121 return (type.isSimplex() ? size( dimension - type.dim() ) : 0);
122 }
123
125 IndexType size ( int codim ) const
126 {
127 assert( (codim >= 0) && (codim <= dimension) );
128 return indexStack_[ codim ].size();
129 }
130
131 Types types ( int codim ) const
132 {
133 assert( (codim >= 0) && (codim <= dimension) );
134 std::array< GeometryType, 1 > types;
135 types[ 0 ] = GeometryType( GeometryType::simplex, dimension - codim );
136 return types;
137 }
138
140 const std::vector< GeometryType > &geomTypes( int codim ) const
141 {
142 assert( (codim >= 0) && (codim <= dimension) );
143 return geomTypes_[ codim ];
144 }
145
146 IndexType subIndex ( const ElementInfo &elementInfo, int i, unsigned int codim ) const
147 {
148 assert( !elementInfo == false );
149 return subIndex( elementInfo.element(), i, codim );
150 }
151
158 IndexType subIndex ( const Alberta::Element *element, int i, unsigned int codim ) const
159 {
160 IndexType *array = (IndexType *)entityNumbers_[ codim ];
161 const IndexType subIndex = array[ dofNumbering_( element, codim, i ) ];
162 assert( (subIndex >= 0) && (subIndex < size( codim )) );
163 return subIndex;
164 }
165
166 void preAdapt ()
167 {
168 // set global pointer to index stack
170 {
171 assert( Alberta::currentIndexStack == 0 );
172 Alberta::currentIndexStack = indexStack_;
173 }
174 }
175
176 void postAdapt ()
177 {
178 // remove global pointer to index stack
181 }
182
183 void create ();
184 void read ( const std::string &filename );
185 bool write ( const std::string &filename ) const;
186
187 void release ()
188 {
189 for( int i = 0; i <= dimension; ++i )
190 entityNumbers_[ i ].release();
191 }
192
193 private:
194 template< int codim >
195 static IndexStack &getIndexStack ( const IndexVectorPointer &dofVector )
196 {
197 IndexStack *indexStack;
199 indexStack = dofVector.template getAdaptationData< IndexStack >();
200 else
201 indexStack = &Alberta::currentIndexStack[ codim ];
202 assert( indexStack != 0 );
203 return *indexStack;
204 }
205
206 // access to the dof vectors
207 const DofNumbering &dofNumbering_;
208
209 // index stacks providing new numbers during adaptation
210 IndexStack indexStack_[ dimension+1 ];
211
212 // dof vectors storing the (persistent) numbering
213 IndexVectorPointer entityNumbers_[ dimension+1 ];
214
215 // all geometry types contained in the grid
216 std::vector< GeometryType > geomTypes_[ dimension+1 ];
217 };
218
219
220
221 // AlbertaGridHierarchicIndexSet::InitEntityNumber
222 // -----------------------------------------------
223
224 template< int dim, int dimworld >
226 {
227 IndexStack &indexStack_;
228
229 public:
231 : indexStack_( indexStack )
232 {}
233
234 void operator() ( int &dof )
235 {
236 dof = indexStack_.getIndex();
237 }
238 };
239
240
241
242 // AlbertaGridHierarchicIndexSet::CreateEntityNumbers
243 // --------------------------------------------------
244
245 template< int dim, int dimworld >
246 template< int codim >
247 struct AlbertaGridHierarchicIndexSet< dim, dimworld >::CreateEntityNumbers
248 {
249 static void setup ( AlbertaGridHierarchicIndexSet< dim, dimworld > &indexSet );
250
251 static void apply ( const Alberta::HierarchyDofNumbering< dimension > &dofNumbering,
253
254 static void apply ( const std::string &filename,
257 };
258
259
260
261 // AlbertaGridHierarchicIndexSet::RefineNumbering
262 // ----------------------------------------------
263
264 template< int dim, int dimworld >
265 template< int codim >
266 struct AlbertaGridHierarchicIndexSet< dim, dimworld >::RefineNumbering
267 {
268 static const int dimension = dim;
269 static const int codimension = codim;
270
271 private:
272 typedef Alberta::DofAccess< dimension, codimension > DofAccess;
273
274 explicit RefineNumbering ( const IndexVectorPointer &dofVector )
275 : indexStack_( getIndexStack< codimension >( dofVector ) ),
276 dofVector_( dofVector ),
277 dofAccess_( dofVector.dofSpace() )
278 {}
279
280 public:
281 void operator() ( const Alberta::Element *child, int subEntity );
282
283 typedef Alberta::Patch< dimension > Patch;
284 static void interpolateVector ( const IndexVectorPointer &dofVector,
285 const Patch &patch );
286
287 private:
288 IndexStack &indexStack_;
289 IndexVectorPointer dofVector_;
290 DofAccess dofAccess_;
291 };
292
293
294
295 // AlbertaGridHierarchicIndexSet::CoarsenNumbering
296 // -----------------------------------------------
297
298 template< int dim, int dimworld >
299 template< int codim >
300 struct AlbertaGridHierarchicIndexSet< dim, dimworld >::CoarsenNumbering
301 {
302 static const int dimension = dim;
303 static const int codimension = codim;
304
305 private:
306 typedef Alberta::DofAccess< dimension, codimension > DofAccess;
307
308 explicit CoarsenNumbering ( const IndexVectorPointer &dofVector )
309 : indexStack_( getIndexStack< codimension >( dofVector ) ),
310 dofVector_( dofVector ),
311 dofAccess_( dofVector.dofSpace() )
312 {}
313
314 public:
315 void operator() ( const Alberta::Element *child, int subEntity );
316
317 typedef Alberta::Patch< dimension > Patch;
318 static void restrictVector ( const IndexVectorPointer &dofVector,
319 const Patch &patch );
320 private:
321 IndexStack &indexStack_;
322 IndexVectorPointer dofVector_;
323 DofAccess dofAccess_;
324 };
325
326
327
328 // AlbertaGridIndexSet
329 // -------------------
330
331 template< int dim, int dimworld >
333 : public IndexSet< AlbertaGrid< dim, dimworld >, AlbertaGridIndexSet< dim, dimworld >, int, std::array< GeometryType, 1 > >
334 {
336 typedef IndexSet< AlbertaGrid< dim, dimworld >, AlbertaGridIndexSet< dim, dimworld >, int, std::array< GeometryType, 1 > > Base;
337
338 public:
340
341 typedef typename Base::IndexType IndexType;
342
343 typedef typename Base::Types Types;
344
345 static const int dimension = Grid::dimension;
346
349
350 private:
351 typedef typename Grid::Traits Traits;
352
353 template< int codim >
354 struct Insert;
355
356 public:
357 explicit AlbertaGridIndexSet ( const DofNumbering &dofNumbering )
358 : dofNumbering_( dofNumbering )
359 {
360 for( int codim = 0; codim <= dimension; ++codim )
361 {
362 indices_[ codim ] = 0;
363
364 const GeometryType type( GeometryType::simplex, dimension - codim );
365 geomTypes_[ codim ].push_back( type );
366 }
367 }
368
370 {
371 for( int codim = 0; codim <= dimension; ++codim )
372 delete[] indices_[ codim ];
373 }
374
375 template< class Entity >
376 bool contains ( const Entity &entity ) const
377 {
378 const int codim = Entity::codimension;
379
381 = Grid::getRealImplementation( entity );
382 const Alberta::Element *element = entityImp.elementInfo().el();
383
384 const IndexType *const array = indices_[ codim ];
385 const IndexType subIndex = array[ dofNumbering_( element, codim, entityImp.subEntity() ) ];
386
387 return (subIndex >= 0);
388 }
389
390 using Base::index;
391 using Base::subIndex;
392
394 template< int cc >
395 IndexType index ( const typename Traits::template Codim< cc >::Entity &entity ) const
396 {
398 const EntityImp &entityImp = Grid::getRealImplementation( entity );
399 return subIndex( entityImp.elementInfo(), entityImp.subEntity(), cc );
400 }
401
403 template< int cc >
404 IndexType subIndex ( const typename Traits::template Codim< cc >::Entity &entity, int i, unsigned int codim ) const
405 {
407 const EntityImp &entityImp = Grid::getRealImplementation( entity );
408
409 int k = i;
410 if( cc > 0 )
411 {
412 const ReferenceElement< Alberta::Real, dimension > &refElement
413 = ReferenceElements< Alberta::Real, dimension >::simplex();
414 k = refElement.subEntity( entityImp.subEntity(), cc, i, codim );
415 }
416
417 const int j = entityImp.grid().generic2alberta( codim, k );
418 return subIndex( entityImp.elementInfo(), j, codim );
419 }
420
421 IndexType size ( const GeometryType &type ) const
422 {
423 return (type.isSimplex() ? size( dimension - type.dim() ) : 0);
424 }
425
426 IndexType size ( int codim ) const
427 {
428 assert( (codim >= 0) && (codim <= dimension) );
429 return size_[ codim ];
430 }
431
432 Types types ( int codim ) const
433 {
434 assert( (codim >= 0) && (codim <= dimension) );
435 std::array< GeometryType, 1 > types;
436 types[ 0 ] = GeometryType( GeometryType::simplex, dimension - codim );
437 return types;
438 }
439
440 const std::vector< GeometryType > &geomTypes( int codim ) const
441 {
442 assert( (codim >= 0) && (codim <= dimension) );
443 return geomTypes_[ codim ];
444 }
445
446 template< class Iterator >
447 void update ( const Iterator &begin, const Iterator &end )
448 {
449 for( int codim = 0; codim <= dimension; ++codim )
450 {
451 delete[] indices_[ codim ];
452
453 const unsigned int dofSize = dofNumbering_.size( codim );
454 indices_[ codim ] = new IndexType[ dofSize ];
455 for( unsigned int i = 0; i < dofSize; ++i )
456 indices_[ codim ][ i ] = -1;
457
458 size_[ codim ] = 0;
459 }
460
461 for( Iterator it = begin; it != end; ++it )
462 {
465 const Alberta::Element *element = entityImp.elementInfo().el();
466 ForLoop< Insert, 0, dimension >::apply( element, *this );
467 }
468 }
469
470 private:
471 IndexType subIndex ( const ElementInfo &elementInfo, int i, unsigned int codim ) const
472 {
473 assert( !elementInfo == false );
474 return subIndex( elementInfo.element(), i, codim );
475 }
476
483 IndexType subIndex ( const Alberta::Element *element, int i, unsigned int codim ) const
484 {
485 const IndexType *const array = indices_[ codim ];
486 const IndexType subIndex = array[ dofNumbering_( element, codim, i ) ];
487 assert( (subIndex >= 0) && (subIndex < size( codim )) );
488 return subIndex;
489 }
490
491 // access to the dof vectors
492 const DofNumbering &dofNumbering_;
493
494 // an array of indices for each codimension
495 IndexType *indices_[ dimension+1 ];
496
497 // the size of each codimension
498 IndexType size_[ dimension+1 ];
499
500 // all geometry types contained in the grid
501 std::vector< GeometryType > geomTypes_[ dimension+1 ];
502 };
503
504
505
506 // AlbertaGridIndexSet::Insert
507 // ---------------------------
508
509 template< int dim, int dimworld >
510 template< int codim >
511 struct AlbertaGridIndexSet< dim, dimworld >::Insert
512 {
513 static void apply ( const Alberta::Element *const element,
514 AlbertaGridIndexSet< dim, dimworld > &indexSet )
515 {
516 int *const array = indexSet.indices_[ codim ];
517 IndexType &size = indexSet.size_[ codim ];
518
519 for( int i = 0; i < Alberta::NumSubEntities< dim, codim >::value; ++i )
520 {
521 int &index = array[ indexSet.dofNumbering_( element, codim, i ) ];
522 if( index < 0 )
523 index = size++;
524 }
525 }
526 };
527
528
529
530 // AlbertaGridIdSet
531 // ----------------
532
534 template< int dim, int dimworld >
536 : public IdSet< AlbertaGrid< dim, dimworld >, AlbertaGridIdSet< dim, dimworld >, unsigned int >
537 {
540
541 friend class AlbertaGrid< dim, dimworld >;
542
543 public:
545 typedef typename Base::IdType IdType;
546
547 private:
549
550 static const int dimension = Grid::dimension;
551
552 typedef typename Grid::HierarchicIndexSet HierarchicIndexSet;
553
554 // create id set, only allowed for AlbertaGrid
555 AlbertaGridIdSet ( const HierarchicIndexSet &hIndexSet )
556 : hIndexSet_( hIndexSet )
557 {}
558
559 public:
561 template< class Entity >
562 IdType id ( const Entity &e ) const
563 {
564 const int codim = Entity::codimension;
565 return id< codim >( e );
566 }
567
569 template< int codim >
570 IdType id ( const typename Grid::template Codim< codim >::Entity &e ) const
571 {
572 assert( (codim >= 0) && (codim <= dimension) );
573 const IdType index = hIndexSet_.index( e );
574 return (index << 2) | IdType( codim );
575 }
576
578 IdType subId ( const typename Grid::template Codim< 0 >::Entity &e, int i, unsigned int subcodim ) const
579 {
580 assert( int( subcodim ) <= dimension );
581 const IdType index = hIndexSet_.subIndex( e, i, subcodim );
582 return (index << 2) | IdType( subcodim );
583 }
584
585 template< int codim >
586 IdType subId ( const typename Grid::template Codim< codim >::Entity &e, int i, unsigned int subcodim ) const
587 {
588 assert( (codim >= 0) && (codim <= dimension) && (int( codim + subcodim ) <= dimension) );
589 const IdType index = hIndexSet_.subIndex( e, i, subcodim );
590 return (index << 2) | IdType( codim + subcodim );
591 }
592
593 template< class Entity >
594 IdType subId ( const Entity &e, int i, unsigned int subcodim ) const
595 {
596 return subId< Entity::codimension >( e, i, subcodim );
597 }
598
599 private:
600 // prohibit copying
601 AlbertaGridIdSet ( const This & );
602
603 const HierarchicIndexSet &hIndexSet_;
604 };
605
606} // namespace Dune
607
608#endif // #if HAVE_ALBERTA
609
610#endif // #ifndef DUNE_ALBERTAGRIDINDEXSETS_HH
Provides base classes for index and id sets.
provides a wrapper for ALBERTA's el_info structure
Provides an index stack that supplies indices for element numbering for a grid (i....
Include standard header files.
Definition agrid.hh:60
Dune::IndexStack< int, 100000 > IndexStack
Definition albertagrid/indexsets.hh:27
ALBERTA EL Element
Definition misc.hh:51
IndexStack * currentIndexStack
Definition indexsets.cc:17
[ provides Dune::Grid ]
Definition agrid.hh:140
static const int dimension
Definition agrid.hh:177
int size(int codim) const
Definition dofadmin.hh:157
static const bool supportsAdaptationData
Definition dofvector.hh:185
Element * el() const
Definition elementinfo.hh:735
const Element * element() const
Definition elementinfo.hh:719
Definition albertagrid/entity.hh:47
const ElementInfo & elementInfo() const
Definition albertagrid/entity.hh:108
int subEntity() const
obtain number of the subentity within the element (in ALBERTA numbering)
Definition albertagrid/entity.hh:126
Definition albertagrid/indexsets.hh:40
IndexType subIndex(const typename Traits::template Codim< cc >::Entity &entity, int i, unsigned int codim) const
return subIndex of given enitiy's sub entity
Definition albertagrid/indexsets.hh:101
Base::IndexType IndexType
Definition albertagrid/indexsets.hh:50
void read(const std::string &filename)
Definition indexsets.cc:153
IndexType size(int codim) const
return size of set
Definition albertagrid/indexsets.hh:125
void release()
Definition albertagrid/indexsets.hh:187
const std::vector< GeometryType > & geomTypes(int codim) const
return geometry types this set has indices for
Definition albertagrid/indexsets.hh:140
Alberta::IndexStack IndexStack
Definition albertagrid/indexsets.hh:78
AlbertaGrid< dim, dimworld > Grid
Definition albertagrid/indexsets.hh:47
IndexType index(const typename Traits::template Codim< cc >::Entity &entity) const
return hierarchic index of given entity
Definition albertagrid/indexsets.hh:92
bool contains(const Entity &) const
return true if entity is contained in set
Definition albertagrid/indexsets.hh:82
IndexType subIndex(const Alberta::Element *element, int i, unsigned int codim) const
obtain hierarchic subindex
Definition albertagrid/indexsets.hh:158
void create()
Definition indexsets.cc:146
Base::Types Types
Definition albertagrid/indexsets.hh:52
bool write(const std::string &filename) const
Definition indexsets.cc:160
Alberta::ElementInfo< dimension > ElementInfo
Definition albertagrid/indexsets.hh:56
void postAdapt()
Definition albertagrid/indexsets.hh:176
IndexType subIndex(const ElementInfo &elementInfo, int i, unsigned int codim) const
Definition albertagrid/indexsets.hh:146
Alberta::HierarchyDofNumbering< dimension > DofNumbering
Definition albertagrid/indexsets.hh:57
Types types(int codim) const
Definition albertagrid/indexsets.hh:131
AlbertaGridFamily< dim, dimworld > GridFamily
Definition albertagrid/indexsets.hh:48
IndexType size(const GeometryType &type) const
return size of set for given GeometryType
Definition albertagrid/indexsets.hh:119
static const int dimension
Definition albertagrid/indexsets.hh:54
void preAdapt()
Definition albertagrid/indexsets.hh:166
hierarchic index set of AlbertaGrid
Definition albertagrid/indexsets.hh:537
IdType id(const typename Grid::template Codim< codim >::Entity &e) const
Get id of an entity of codim cc. Unhandy because template parameter must be supplied explicitely.
Definition albertagrid/indexsets.hh:570
IdType id(const Entity &e) const
Definition albertagrid/indexsets.hh:562
Base::IdType IdType
export type of id
Definition albertagrid/indexsets.hh:545
IdType subId(const typename Grid::template Codim< 0 >::Entity &e, int i, unsigned int subcodim) const
Get id of subentity i of co-dimension codim of a co-dimension 0 entity.
Definition albertagrid/indexsets.hh:578
IdType subId(const typename Grid::template Codim< codim >::Entity &e, int i, unsigned int subcodim) const
Definition albertagrid/indexsets.hh:586
IdType subId(const Entity &e, int i, unsigned int subcodim) const
Definition albertagrid/indexsets.hh:594
Definition albertagrid/indexsets.hh:334
Base::Types Types
Definition albertagrid/indexsets.hh:343
Alberta::ElementInfo< dimension > ElementInfo
Definition albertagrid/indexsets.hh:347
IndexType size(const GeometryType &type) const
Definition albertagrid/indexsets.hh:421
IndexType index(const typename Traits::template Codim< cc >::Entity &entity) const
return hierarchic index of given entity
Definition albertagrid/indexsets.hh:395
AlbertaGridIndexSet(const DofNumbering &dofNumbering)
Definition albertagrid/indexsets.hh:357
Alberta::HierarchyDofNumbering< dimension > DofNumbering
Definition albertagrid/indexsets.hh:348
bool contains(const Entity &entity) const
Definition albertagrid/indexsets.hh:376
const std::vector< GeometryType > & geomTypes(int codim) const
Definition albertagrid/indexsets.hh:440
IndexType subIndex(const typename Traits::template Codim< cc >::Entity &entity, int i, unsigned int codim) const
return subIndex of given enitiy's sub entity
Definition albertagrid/indexsets.hh:404
Base::IndexType IndexType
Definition albertagrid/indexsets.hh:341
Types types(int codim) const
Definition albertagrid/indexsets.hh:432
IndexType size(int codim) const
Definition albertagrid/indexsets.hh:426
~AlbertaGridIndexSet()
Definition albertagrid/indexsets.hh:369
void update(const Iterator &begin, const Iterator &end)
Definition albertagrid/indexsets.hh:447
static const int dimension
Definition albertagrid/indexsets.hh:345
AlbertaGrid< dim, dimworld > Grid
Definition albertagrid/indexsets.hh:339
Definition albertagrid/gridfamily.hh:82
static const int dimension
Definition albertagrid/gridfamily.hh:87
Definition albertagrid/gridfamily.hh:97
Definition albertagrid/indexsets.hh:226
InitEntityNumber(IndexStack &indexStack)
Definition albertagrid/indexsets.hh:230
Definition indexstack.hh:24
int size() const
return maxIndex which is also the
Definition indexstack.hh:77
Wrapper class for entities.
Definition common/entity.hh:62
@ codimension
Know your own codimension.
Definition common/entity.hh:104
static std::conditional< std::is_reference< InterfaceType >::value, typenamestd::add_lvalue_reference< typenameReturnImplementationType< typenamestd::remove_reference< InterfaceType >::type >::ImplementationType >::type, typenamestd::remove_const< typenameReturnImplementationType< typenamestd::remove_reference< InterfaceType >::type >::ImplementationType >::type >::type getRealImplementation(InterfaceType &&i)
return real implementation of interface class
Definition common/grid.hh:1119
Index Set Interface base class.
Definition indexidset.hh:76
IndexType subIndex(const typename Traits::template Codim< cc >::Entity &e, int i, unsigned int codim) const
Map a subentity to an index.
Definition indexidset.hh:149
std::array< GeometryType, 1 > Types
iterator range for geometry types in domain
Definition indexidset.hh:93
IndexType index(const typename Traits::template Codim< cc >::Entity &e) const
Map entity to index. The result of calling this method with an entity that is not in the index set is...
Definition indexidset.hh:111
Id Set Interface.
Definition indexidset.hh:397
IdTypeImp IdType
Type used to represent an id.
Definition indexidset.hh:400
provides the GridFamily for AlbertaGrid
Different resources needed by all grid implementations.