dune-alugrid 2.8.0
Loading...
Searching...
No Matches
datahandle.hh
Go to the documentation of this file.
1#ifndef DUNE_ALU3DGRIDDATAHANDLE_HH
2#define DUNE_ALU3DGRIDDATAHANDLE_HH
3
4//- system includes
5#include <iostream>
6#include <type_traits>
7
8#include <dune/common/version.hh>
9
10#include <dune/grid/common/grid.hh>
11#include <dune/grid/common/adaptcallback.hh>
12
15
16//- local includes
17#include "alu3dinclude.hh"
18
19namespace ALUGrid
20{
21
22 namespace detail {
23
24 template <int dimension>
25 struct Contains
26 {
27 //This method is called in gitter_dune_pll_impl.cc with arguments 3,codimension
28 //So we have to adapt things to the user view, that writes it with
29 // 2,codimension
30 // return true if dim,codim combination is contained in data set
31
32 template <class DataCollector>
33 static bool contains(const DataCollector& dc, const int dim, const int cd)
34 {
35 //dimension is GridImp::dimension
36 if(dim == dimension)
37 {
38 //the original call
39 return dc.contains(dim,cd);
40 }
41 //adaptation for 2d
42 else if(dimension == 2)
43 {
44 //we do not want to transmit edge data
45 if(cd == 2)
46 return false;
47 else if (cd == 3)
48 return dc.contains(dimension, 2);
49 else
50 return dc.contains(dimension, cd);
51 }
52 //
53 else
54 {
55 std::cerr << "DataHandle.contains called with non-matching dim and codim" << std::endl;
56 return false;
57 }
58 }
59 };
60 } // end namespace detail
61
63 template< class GridType, class DataCollectorType, int codim >
65 : public GatherScatter
66 {
67 protected:
68 enum { dimension = GridType::dimension };
69 const GridType & grid_;
70 typedef typename GridType::template Codim<codim>::Entity EntityType;
71 typedef typename GridType::template Codim<codim>::EntityImp RealEntityType;
72
73 typedef typename GridType::MPICommunicatorType Comm;
74
76 typedef typename ImplTraits::template Codim< dimension, codim >::ImplementationType ImplElementType;
77 typedef typename ImplTraits::template Codim< dimension, codim >::InterfaceType HElementType;
78
81
82 DataCollectorType & dc_;
83
84 const bool variableSize_;
85
86 typedef typename GatherScatter :: ObjectStreamType ObjectStreamType;
87
88 typedef typename DataCollectorType:: DataType DataType;
89
90 using GatherScatter :: setData ;
91 using GatherScatter :: sendData ;
92 using GatherScatter :: recvData ;
93 using GatherScatter :: containsItem ;
94
95 public:
97 GatherScatterBaseImpl(const GridType & grid, EntityType & en,
98 RealEntityType & realEntity , DataCollectorType & dc)
99 : grid_(grid), entity_(en), realEntity_(realEntity) , dc_(dc)
100 , variableSize_( ! dc_.fixedSize(EntityType::dimension,codim) )
101 {
102 }
103
104 // return true if dim,codim combination is contained in data set
105 bool contains(int dim, int cd) const
106 {
107 return detail::Contains< dimension >::contains( dc_, dim, cd );
108 }
109
110 // returns true, if element is contained in set of comm interface
111 // this method must be overlaoded by the impl classes
112 virtual bool containsItem (const HElementType & elem) const = 0;
113
114 // set elem to realEntity
115 virtual void setElement(const HElementType & elem) = 0;
116
117 void setData ( ObjectStreamType & str , HElementType & elem )
118 {
119 // one of this should be either true
120 alugrid_assert ( this->containsItem( elem ) || elem.isGhost() );
121
122 // set element and then start
123 setElement(elem);
124
125 // make sure partition type is set correct
126 alugrid_assert ( elem.isGhost() == (entity_.partitionType() == Dune :: GhostEntity) );
127
128 size_t size = getSize(str, entity_);
129 // use normal scatter method
130 dc_.scatter(str,entity_, size );
131 }
132
134 void sendData ( ObjectStreamType & str , HElementType & elem )
135 {
136 // make sure element is contained in communication interface
137 //alugrid_assert ( this->containsItem( elem ) );
138 setElement(elem);
139
140 // if varaible size, also send size
141 if( variableSize_ )
142 {
143 size_t size = dc_.size( entity_ );
144 str.write( size );
145 }
146
147 dc_.gather(str, entity_ );
148 }
149
151 void recvData ( ObjectStreamType & str , HElementType & elem )
152 {
153 alugrid_assert ( this->containsItem( elem ) );
154 setElement( elem );
155
156 size_t size = getSize(str, entity_);
157 dc_.scatter(str,entity_, size );
158 }
159
160 protected:
162 {
163 if(variableSize_)
164 {
165 size_t size;
166 str.read(size);
167 return size;
168 }
169 else
170 return dc_.size(en);
171 }
172 };
173
174 //***********************************************************
175 //
176 // --specialisation for codim 0
177 //
178 //***********************************************************
179
181 template <class GridType, class DataCollectorType >
182 class GatherScatterBaseImpl<GridType,DataCollectorType,0> : public GatherScatter
183 {
184 protected:
185 enum { codim = 0 };
186 enum { dimension = GridType::dimension };
187 const GridType & grid_;
188 typedef typename GridType::template Codim<0>::Entity EntityType;
189 typedef typename GridType::template Codim<0>::EntityImp RealEntityType;
190
191 typedef typename GridType::MPICommunicatorType Comm;
192
194 typedef typename ImplTraits::template Codim< dimension, codim >::ImplementationType ImplElementType;
195 typedef typename ImplTraits::template Codim< dimension, codim >::InterfaceType HElementType;
196
197 typedef typename ImplTraits::template Codim< dimension, 1 >::InterfaceType HFaceType;
198
199 typedef typename ImplTraits::template Codim< dimension, codim >::GhostInterfaceType HGhostType;
200 typedef typename ImplTraits::template Codim< dimension, codim >::GhostImplementationType ImplGhostType;
201
202 typedef typename ImplTraits::PllElementType PllElementType;
203
206
207 // data handle
208 DataCollectorType & dc_;
209
210 const bool variableSize_;
211
212 // used MessageBuffer
213 typedef typename GatherScatter :: ObjectStreamType ObjectStreamType;
214
215 // use all other containsItem from the base class
216 using GatherScatter :: setData ;
217 using GatherScatter :: sendData ;
218 using GatherScatter :: recvData ;
219
220 public:
221 // use all other containsItem from the base class
222 using GatherScatter :: containsItem ;
223
225 GatherScatterBaseImpl(const GridType & grid, EntityType & en,
226 RealEntityType & realEntity , DataCollectorType & dc)
227 : grid_(grid), entity_(en), realEntity_(realEntity)
228 , dc_(dc) , variableSize_ ( ! dc_.fixedSize( EntityType :: dimension, codim ))
229 {}
230
231 // This method is called in gitter_dune_pll_impl.cc with arguments 3,codimension
232 // So we have to adapt things to the user view, that writes it with
233 // 2,codimension
234 // return true if dim,codim combination is contained in data set
235 bool contains(int dim, int cd) const
236 {
237 return detail::Contains< dimension >::contains( dc_, dim, cd );
238 }
239
240 // return true if item might from entity belonging to data set
241 virtual bool containsItem (const HElementType & elem) const
242 {
243 return elem.isLeafEntity();
244 }
245
246 // return true if item might from entity belonging to data set
247 virtual bool containsItem (const HGhostType & ghost) const = 0;
248
250 void sendData ( ObjectStreamType & str , const HElementType & elem )
251 {
252 alugrid_assert ( this->containsItem(elem) );
253 realEntity_.setElement( const_cast<HElementType &> (elem) );
254
255 // write size in case of variable size
256 writeSize( str, entity_);
257 // gather data
258 dc_.gather(str, entity_);
259 }
260
262 void sendData ( ObjectStreamType & str , const HGhostType& ghost)
263 {
264 alugrid_assert ( this->containsItem( ghost ) );
265
266 // set ghost as entity
267 realEntity_.setGhost( const_cast <HGhostType &> (ghost) );
268
269 // write size in case of variable size
270 writeSize( str, entity_);
271 // gather data
272 dc_.gather(str, entity_);
273 }
274
276 void recvData ( ObjectStreamType & str , HElementType & elem )
277 {
278 // alugrid_assert ( this->containsItem( elem ) );
279 realEntity_.setElement( elem );
280
281 size_t size = getSize(str, entity_);
282 dc_.scatter(str, entity_, size);
283 }
284
286 void recvData ( ObjectStreamType & str , HGhostType & ghost )
287 {
288 alugrid_assert ( this->containsItem( ghost ) );
289
290 // set ghost as entity
291 realEntity_.setGhost( ghost );
292
293 size_t size = getSize(str , entity_ );
294 dc_.scatter(str, entity_, size );
295 }
296
297 protected:
299 {
300 if(variableSize_)
301 {
302 size_t size;
303 str.read(size);
304 return size;
305 }
306 else
307 return dc_.size(en);
308 }
309
310 // write variable size to stream
312 {
313 if( variableSize_ )
314 {
315 size_t size = dc_.size( en );
316 str.write( size );
317 }
318 }
319 };
320
322 template< class GridType, class DataCollectorType, int codim >
324 : public GatherScatterBaseImpl< GridType, DataCollectorType, codim >
325 {
326 enum { dim = GridType :: dimension };
327
329 typedef typename GridType::template Codim<codim>::Entity EntityType;
330 typedef typename GridType::template Codim<codim>::EntityImp RealEntityType;
331
332 typedef typename GridType::MPICommunicatorType Comm;
333
335 typedef typename ImplTraits::template Codim< dim, codim >::ImplementationType IMPLElementType;
336 typedef typename ImplTraits::template Codim< dim, codim >::InterfaceType HElementType;
337
338 typedef typename ImplTraits::template Codim< dim, 1 >::InterfaceType HFaceType;
339
340 typedef typename ImplTraits::template Codim< dim, 0 >::GhostInterfaceType HGhostType;
341 typedef typename ImplTraits::template Codim< dim, 0 >::GhostImplementationType ImplGhostType;
342
343 typedef typename ImplTraits::PllElementType PllElementType;
344
345 using BaseType :: grid_;
346 public:
347 // use all other containsItem methods from the base class
349
351 GatherScatterLeafData(const GridType & grid, EntityType & en,
352 RealEntityType & realEntity , DataCollectorType & dc)
353 : BaseType(grid,en,realEntity,dc)
354 {
355 // if leaf vertices are communicated,
356 // make sure that vertex list is up2date
357 // but only do this, if vertex data contained,
358 // because the list update is expensive
359 if( (codim == dim) && dc.contains(dim,codim) )
360 {
361 // call of this method forces update of list,
362 // if list is not up to date
363 grid.getLeafVertexList();
364 }
365 }
366
367 // returns true, if element is contained in set of comm interface
368 bool containsItem (const HElementType & elem) const
369 {
370 return (dim == 2 ? elem.is2d() : true) && elem.isLeafEntity();
371 }
372
373 // returns true, if element is contained in set of comm interface
374 bool containsItem (const HGhostType & ghost) const
375 {
376 //in 2d ghosts are always 2d, as they are codim 0
377 //so we do not need to adapt the switch
378 return ghost.isLeafEntity();
379 }
380
381 // returns true, if interior element is contained in set of comm interface
382 bool containsInterior (const HFaceType & face, PllElementType & pll) const
383 {
384 return (dim == 2 ? face.is2d() : true) && face.isInteriorLeaf();
385 }
386
387 // returns true, if ghost is contianed in set of comm interface
388 bool containsGhost (const HFaceType & face , PllElementType & pll) const
389 {
390 return (dim == 2 ? face.is2d() : true) && pll.ghostLeaf();
391 }
392
393 // set elem to realEntity
394 void setElement(const HElementType & elem)
395 {
396 this->realEntity_.setElement(elem, grid_);
397 }
398 };
399
401 template <class GridType, class DataCollectorType , int codim >
403 : public GatherScatterBaseImpl<GridType,DataCollectorType,codim>
404 {
405 enum { dim = GridType::dimension };
407 typedef typename GridType::template Codim<codim>::Entity EntityType;
408 typedef typename GridType::template Codim<codim>::EntityImp RealEntityType;
409
410 typedef typename GridType::MPICommunicatorType Comm;
411
413 typedef typename ImplTraits::template Codim< dim, codim >::ImplementationType IMPLElementType;
414 typedef typename ImplTraits::template Codim< dim, codim >::InterfaceType HElementType;
415
416 typedef typename ImplTraits::template Codim< dim, 1 >::InterfaceType HFaceType;
417
418 typedef typename ImplTraits::template Codim< dim, 0 >::GhostInterfaceType HGhostType;
419 typedef typename ImplTraits::template Codim< dim, 0 >::GhostImplementationType ImplGhostType;
420
421 typedef typename ImplTraits::PllElementType PllElementType;
422
423 typedef typename GridType::LevelIndexSetImp LevelIndexSetImp;
424
425 const LevelIndexSetImp & levelSet_;
426 const int level_;
427 public:
428 // use containsItem for ghost element from BaseType
430
432 GatherScatterLevelData(const GridType & grid, EntityType & en,
433 RealEntityType & realEntity , DataCollectorType & dc,
434 const LevelIndexSetImp & levelSet, const int level)
435 : BaseType(grid,en,realEntity,dc) , levelSet_(levelSet) , level_(level)
436 {
437 }
438
439 // returns true, if element is contained in set of comm interface
440 bool containsItem (const HElementType & elem) const
441 {
442 return (dim == 2 ? elem.is2d() : true) && levelSet_.containsIndex(codim, elem.getIndex() );
443 }
444
445 // set elem to realEntity
446 void setElement(const HElementType & elem)
447 {
448 this->realEntity_.setElement(elem,level_);
449 }
450
451 };
452
454 // this class is for the 2d grid - it masks out the edgeGatherScatter
455 template <class GridType, class DataCollectorType , int codim >
457 : public GatherScatterBaseImpl<GridType,DataCollectorType,codim>
458 {
459 enum { dim = GridType::dimension };
461 typedef typename GridType::template Codim<codim>::Entity EntityType;
462 typedef typename GridType::template Codim<codim>::EntityImp RealEntityType;
463
464 typedef typename GridType::MPICommunicatorType Comm;
465
467
468 typedef typename ImplTraits::template Codim< 2, codim >::ImplementationType IMPLElementType;
469 typedef typename ImplTraits::template Codim< 2, codim >::InterfaceType HElementType;
470 //We want to have the real 3d no data gatherscatter so set dim to 3 here
471 typedef typename ImplTraits::template Codim< 3, codim >::ImplementationType RealIMPLElementType;
472 typedef typename ImplTraits::template Codim< 3, codim >::InterfaceType RealHElementType;
473
474 typedef typename ImplTraits::template Codim< dim, 1 >::InterfaceType HFaceType;
475
476 typedef typename ImplTraits::template Codim< dim, 0 >::GhostInterfaceType HGhostType;
477 typedef typename ImplTraits::template Codim< dim, 0 >::GhostImplementationType ImplGhostType;
478
479 typedef typename ImplTraits::PllElementType PllElementType;
480
481 typedef typename GridType::LevelIndexSetImp LevelIndexSetImp;
482
483 public:
484 // use containsItem for ghost element from BaseType
486
488 GatherScatterNoData(const GridType & grid, EntityType & en,
489 RealEntityType & realEntity , DataCollectorType & dc,
490 const LevelIndexSetImp & levelSet, const int level)
491 : BaseType(grid,en,realEntity,dc)
492 {
493 }
494
496 GatherScatterNoData(const GridType & grid, EntityType & en,
497 RealEntityType & realEntity , DataCollectorType & dc)
498 : BaseType(grid,en,realEntity,dc)
499 {
500 }
501
502 // returns true, if element is contained in set of comm interface
503 bool containsItem (const HElementType & elem) const
504 {
505 return false;
506 }
507
508 // returns true, if element is contained in set of comm interface
509 bool containsItem (const RealHElementType & elem) const
510 {
511 return false;
512 }
513
514 // set elem to realEntity
515 void setElement(const HElementType & elem)
516 {
517 //we should not get here hopefully
518 alugrid_assert(false);
519 return;
520 }
521
522 // set elem to realEntity
523 void setElement(const RealHElementType & elem)
524 {
525 //we should not get here hopefully
526 alugrid_assert(false);
527 return;
528 }
529
530 };
531
532
534 template <class GridType, class DataCollectorType>
535 class GatherScatterLevelData<GridType,DataCollectorType,0>
536 : public GatherScatterBaseImpl<GridType,DataCollectorType,0>
537 {
538 enum { codim = 0 };
539 enum { dim = GridType:: dimension };
541 typedef typename GridType::template Codim<codim>::Entity EntityType;
542 typedef typename GridType::template Codim<codim>::EntityImp RealEntityType;
543
544 typedef typename GridType::MPICommunicatorType Comm;
545
547 typedef typename ImplTraits::template Codim< dim, codim >::ImplementationType IMPLElementType;
548 typedef typename ImplTraits::template Codim< dim, codim >::InterfaceType HElementType;
549
550 typedef typename ImplTraits::template Codim< dim, 1 >::InterfaceType HFaceType;
551
552 typedef typename ImplTraits::template Codim< dim, 0 >::GhostInterfaceType HGhostType;
553 typedef typename ImplTraits::template Codim< dim, 0 >::GhostImplementationType ImplGhostType;
554
555 typedef typename ImplTraits::PllElementType PllElementType;
556
557 typedef typename GridType::LevelIndexSetImp LevelIndexSetImp;
558
559 const LevelIndexSetImp & levelSet_;
560 const int level_;
561 public:
563 GatherScatterLevelData(const GridType & grid, EntityType & en,
564 RealEntityType & realEntity , DataCollectorType & dc,
565 const LevelIndexSetImp & levelSet, const int level)
566 : BaseType(grid,en,realEntity,dc) , levelSet_(levelSet) , level_(level) {}
567
568 // returns true, if element is contained in set of comm interface
569 bool containsItem (const HElementType & elem) const
570 {
571 return levelSet_.containsIndex(codim, elem.getIndex() );
572 }
573
574 // returns true, if element is contained in set of comm interface
575 bool containsItem (const HGhostType & ghost) const
576 {
577 alugrid_assert ( ghost.getGhost().first );
578 return containsItem( * (ghost.getGhost().first) );
579 }
580
581 // returns true, if interior element is contained in set of comm interface
582 bool containsInterior (const HFaceType & face, PllElementType & pll) const
583 {
584 // if face level is not level_ then interior cannot be contained
585 if(face.level() != level_) return false;
586
587 typedef Gitter::helement_STI HElementType;
588 typedef Gitter::hbndseg_STI HBndSegType;
589
590 // check interior element here, might have a coarser level
591 std::pair< HElementType *, HBndSegType * > p( (HElementType *)0, (HBndSegType *)0 );
592 pll.getAttachedElement( p );
593 alugrid_assert ( p.first );
594 // check inside level
595 bool contained = (p.first->level() == level_);
596 alugrid_assert ( contained == this->containsItem( *p.first ));
597 return contained;
598 }
599
600 // returns true, if ghost is contianed in set of comm interface
601 bool containsGhost (const HFaceType & face, PllElementType & pll) const
602 {
603 // if face level is not level_ then ghost cannot be contained
604 if(face.level() != level_) return false;
605 // otherwise check ghost level
606 return (pll.ghostLevel() == level_);
607 }
608 };
609
610
612 //
613 // --GatherScatterLoadBalance: ALU data handle implementation for user defined load balance
614 //
616 template <class GridType, class LoadBalanceHandleType, bool useExternal>
617 class GatherScatterLoadBalance : public GatherScatter
618 {
619 protected:
620 typedef typename GridType::MPICommunicatorType Comm;
621
623 typedef typename ImplTraits::template Codim< GridType::dimension, 0 >::InterfaceType HElementType;
624
625 typedef typename GridType :: template Codim< 0 > :: Entity EntityType ;
626 typedef typename GridType :: template Codim< 0 > :: EntityImp EntityImpType ;
627
628 template < bool useHandlerOpts, typename D = void>
630 {
631 bool importRank( const LoadBalanceHandleType &lb,
632 std::set<int>& ranks ) const
633 {
634 return lb.importRanks( ranks );
635 }
636 int destination( const LoadBalanceHandleType &lb,
637 const EntityType& entity ) const
638 {
639 return lb( entity );
640 }
641 int loadWeight( const LoadBalanceHandleType &lb,
642 const EntityType& entity ) const
643 {
644 return lb( entity );
645 }
646 };
647 template <typename D>
648 struct UseExternalHandlerOpts< false, D >
649 {
650 bool importRank( const LoadBalanceHandleType &lb,
651 std::set<int>& ranks ) const
652 {
653 return false;
654 }
655 int destination( const LoadBalanceHandleType &lb,
656 const EntityType& entity ) const
657 {
658 std::abort();
659 return -1;
660 }
661 int loadWeight( const LoadBalanceHandleType &lb,
662 const EntityType& entity ) const
663 {
664 std::abort();
665 return -1;
666 }
667 };
668
669 private:
670 // no copying
672
673 protected:
674 GridType & grid_;
675
677
678 // pointer to load balancing user interface (if NULL internal load balancing is used)
679 LoadBalanceHandleType* ldbHandle_;
680
681 // true if userDefinedPartitioning is used, false if loadWeights is used
682 // both are disabled if ldbHandle_ is NULL
683
684 public:
686 GatherScatterLoadBalance( GridType & grid,
687 LoadBalanceHandleType& ldb)
688 : grid_(grid),
690 ldbHandle_( &ldb )
691 {}
692
694 explicit GatherScatterLoadBalance( GridType & grid )
695 : grid_(grid),
697 ldbHandle_( 0 )
698 {}
699
700 // return false, since no user dataHandle is present
701 bool hasUserData() const { return false ; }
702
703 // return true if user defined partitioning methods should be used
705 {
706 return useExternal && ldbHandle_ ;
707 }
708
709 // return true if user defined load balancing weights are provided
711 {
712 return ! useExternal && ldbHandle_ ;
713 }
714
715 // returns true if user defined partitioning needs to be readjusted
717 {
718 return userDefinedPartitioning(); // Note: user calls repartition() before calling loadBalance on the grid
719 }
720
721 // return set of ranks data is imported from during load balance
722 // this method is only used for user defined repartitioning
723 bool importRanks( std::set<int>& ranks ) const
724 {
727 }
728
729 // return set of ranks data is exported to during load balance
730 // this method is only used for user defined repartitioning
731 bool exportRanks( std::set<int>& ranks ) const
732 {
733 // NOTE: This feature is not yet include in the user interface
734 //alugrid_assert( userDefinedPartitioning() );
735 //return ldbHandle().exportRanks( ranks );
736 return false ;
737 }
738
739 // return destination (i.e. rank) where the given element should be moved to
740 // this needs the methods userDefinedPartitioning to return true
742 {
743 // make sure userDefinedPartitioning is enabled
744 alugrid_assert ( elem.level () == 0 );
747 }
748
749 // return load weight of given element
751 {
752 // make sure userDefinedLoadWeights is enabled
754 alugrid_assert ( elem.level() == 0 );
755 static const bool useWeights = std::is_same<LoadBalanceHandleType, GatherScatter> :: value == false ;
757 }
758
759 protected:
761 {
762 entity_.impl().setElement( elem );
763 return entity_ ;
764 }
765
766 LoadBalanceHandleType& ldbHandle()
767 {
769 return *ldbHandle_;
770 }
771
772 const LoadBalanceHandleType& ldbHandle() const
773 {
775 return *ldbHandle_;
776 }
777
778 };
779
781 //
782 // --GatherScatterLoadBalance: ALU data handle implementation for CommDataHandleIF
783 //
785 template <class GridType, class LoadBalanceHandleType, class DataHandleImpl, class Data, bool useExternal>
787 : public GatherScatterLoadBalance< GridType, LoadBalanceHandleType, useExternal >
788 {
789 // no copying
791
793 protected:
794 static const int dimension = GridType :: dimension ;
795 typedef typename GridType :: Traits :: HierarchicIterator HierarchicIterator;
796
797 template< int codim >
798 struct Codim
799 {
800 typedef typename GridType :: Traits :: template Codim< codim > :: Entity Entity;
801 };
802
803 typedef typename GridType::MPICommunicatorType Comm;
806
807 typedef typename BaseType :: EntityType EntityType ;
808
809 typedef Dune::CommDataHandleIF< DataHandleImpl, Data > DataHandleType;
810
811 template <class DH, bool>
813 {
814 static DataHandleImpl& asImp( DH& dh ) { return static_cast<DataHandleImpl &> (dh); }
815
816 static void reserveMemory( DH& dataHandle, const size_t newElements )
817 {
818 asImp( dataHandle ).reserveMemory( newElements );
819 }
820 static void compress( DH& dataHandle )
821 {
822 asImp( dataHandle ).compress();
823 }
824 };
825
826 template <class DH>
827 struct CompressAndReserve< DH, false >
828 {
829 static void reserveMemory( DH& dataHandle, const size_t newElements ) {}
830 static void compress( DH& dataHandle ) {}
831 };
832
833 // check whether DataHandleImpl is derived from LoadBalanceHandleWithReserveAndCompress
834 static const bool hasCompressAndReserve = std::is_base_of< LoadBalanceHandleWithReserveAndCompress, DataHandleImpl >::value;
835 // don't transmit size in case we have special DataHandleImpl
836 static const bool transmitSize = ! hasCompressAndReserve ;
837
839
840 // data handle (CommDataHandleIF)
842
843 // used MessageBuffer
844 typedef typename GatherScatter :: ObjectStreamType ObjectStreamType;
845
846 using BaseType :: grid_ ;
847 using BaseType :: setEntity ;
848 using BaseType :: entity_ ;
849
850 // return true if maxLevel is the same on all cores
852 {
853 int maxLevel = grid_.maxLevel();
854 maxLevel = grid_.comm().max( maxLevel );
855 return maxLevel == grid_.maxLevel();
856 }
857 public:
860 DataHandleType& dh,
861 LoadBalanceHandleType& ldb)
862 : BaseType( grid, ldb ),
863 dataHandle_( dh )
864 {
866 }
867
870 : BaseType( grid ),
871 dataHandle_( dh )
872 {
874 }
875
876 // return true if dim,codim combination is contained in data set
877 bool contains(int dim, int cd) const
878 {
879 //dimension is GridImp::dimension
880 if(dim == dimension)
881 {
882 //the original call
883 return dataHandle_.contains(dim,cd);
884 }
885 //adaptation for 2d
886 else if(dimension == 2)
887 {
888 //we do not want to transmit edge data
889 if(cd == 2)
890 return false;
891 else if (cd == 3)
892 return dataHandle_.contains(dimension, 2);
893 else
894 return dataHandle_.contains(dimension, cd);
895 }
896 //
897 else
898 {
899 std::cerr << "DataHandle.contains called with non-matching dim and codim" << std::endl;
900 return false;
901 }
902 }
903
904 // return true if user dataHandle is present which is the case here
905 bool hasUserData() const { return true ; }
906
909 void inlineData ( ObjectStreamType & str , HElementType & elem, const int estimatedElements )
910 {
911 // store number of elements to be written (for restore)
912 str.write(estimatedElements);
913 // set element and then start
914 alugrid_assert ( elem.level () == 0 );
915
916 // pack data for the whole hierarchy
917 inlineHierarchy( str, elem );
918 }
919
923 {
924 alugrid_assert ( elem.level () == 0 );
925
926 // read number of elements to be restored
927 int newElements = 0 ;
928 str.read( newElements );
929
930 // if data handle provides reserve feature, reserve memory
931 // the data handle has to be derived from LoadBalanceHandleWithReserveAndCompress
932 CompressAndReserveType :: reserveMemory( dataHandle_, newElements );
933
934 // unpack data for the hierarchy
935 xtractHierarchy( str, elem );
936 }
937
939 void compress ()
940 {
941 // if data handle provides compress, do compress here
942 // the data handle has to be derived from LoadBalanceHandleWithReserveAndCompress
943 CompressAndReserveType :: compress( dataHandle_ );
944 }
945
946 protected:
947 // inline data for the hierarchy
949 {
950 // pack elements data
951 inlineElementData( str, setEntity( elem ) );
952 // pack using deep first strategy
953 for( HElementType* son = elem.down(); son ; son = son->next() )
954 inlineHierarchy( str, *son );
955 }
956
957 // inline data for the hierarchy
959 {
960 xtractElementData( str, setEntity( elem ) );
961 // reset element is new flag
962 elem.resetRefinedTag();
963 // unpack using deep first strategy
964 for( HElementType* son = elem.down(); son ; son = son->next() )
965 xtractHierarchy( str, *son );
966 }
967
968 void inlineElementData ( ObjectStreamType &stream, const EntityType &element )
969 {
970 // call element data direct without creating entity pointer
971 if( dataHandle_.contains( dimension, 0 ) )
972 {
973 inlineEntityData<0>( stream, element );
974 }
975
976 // now call all higher codims
977 inlineCodimData< 1 >( stream, element );
978 inlineCodimData< 2 >( stream, element );
979 if(dimension == 3)
980 inlineCodimData< dimension >( stream, element );
981 }
982
983 void xtractElementData ( ObjectStreamType &stream, const EntityType &element )
984 {
985 // call element data direct without creating entity pointer
986 if( dataHandle_.contains( dimension, 0 ) )
987 {
988 xtractEntityData<0>( stream, element );
989 }
990
991 // now call all higher codims
992 xtractCodimData< 1 >( stream, element );
993 xtractCodimData< 2 >( stream, element );
994 if(dimension == 3)
995 xtractCodimData< dimension >( stream, element );
996 }
997
998 template <int codim>
999 int subEntities( const EntityType &element ) const
1000 {
1001 return element.subEntities( codim );
1002 }
1003
1004 template< int codim >
1005 void inlineCodimData ( ObjectStreamType &stream, const EntityType &element ) const
1006 {
1007 if( dataHandle_.contains( dimension, codim ) )
1008 {
1009 const int numSubEntities = this->template subEntities< codim >( element );
1010 for( int i = 0; i < numSubEntities; ++i )
1011 {
1012 inlineEntityData< codim >( stream, element.template subEntity< codim >( i ) );
1013 }
1014 }
1015 }
1016
1017 template< int codim >
1018 void xtractCodimData ( ObjectStreamType &stream, const EntityType &element )
1019 {
1020 if( dataHandle_.contains( dimension, codim ) )
1021 {
1022 const int numSubEntities = this->template subEntities< codim >( element );
1023 for( int i = 0; i < numSubEntities; ++i )
1024 {
1025 xtractEntityData< codim >( stream, element.template subEntity< codim >( i ) );
1026 }
1027 }
1028 }
1029
1030 template< int codim >
1032 const typename Codim< codim > :: Entity &entity ) const
1033 {
1034 if( transmitSize )
1035 {
1036 const size_t size = dataHandle_.size( entity );
1037 stream.write( size );
1038 }
1039 dataHandle_.gather( stream, entity );
1040 }
1041
1042 template< int codim >
1044 const typename Codim< codim > :: Entity &entity )
1045 {
1046 size_t size = 0;
1047 if( transmitSize )
1048 {
1049 stream.read( size );
1050 }
1051 dataHandle_.scatter( stream, entity, size );
1052 }
1053 };
1054
1056 //
1057 // --AdaptRestrictProlong
1058 //
1060 template< class GridType, class AdaptDataHandle >
1063 {
1064 GridType & grid_;
1065 typedef typename GridType::template Codim<0>::Entity EntityType;
1066 typedef typename GridType::template Codim<0>::EntityImp RealEntityType;
1067
1068 EntityType entity_;
1069
1070 AdaptDataHandle &rp_;
1071
1072 typedef typename GridType::MPICommunicatorType Comm;
1073
1075 typedef typename ImplTraits::HElementType HElementType;
1076 typedef typename ImplTraits::HBndSegType HBndSegType;
1077 typedef typename ImplTraits::BNDFaceType BNDFaceType;
1078
1079 //using AdaptRestrictProlongType :: postRefinement ;
1080 //using AdaptRestrictProlongType :: preCoarsening ;
1081
1082 public:
1085 AdaptDataHandle &rp )
1086 : grid_(grid)
1087 , entity_( RealEntityType() )
1088 , rp_(rp)
1089 {
1090 }
1091
1093 {
1094 }
1095
1097 int preCoarsening ( HElementType & father )
1098 {
1099 entity_.impl().setElement( father );
1100 rp_.preCoarsening( entity_ );
1101
1102 // reset refinement marker
1103 father.resetRefinedTag();
1104 return 0;
1105 }
1106
1108 int postRefinement ( HElementType & father )
1109 {
1110 entity_.impl().setElement( father );
1111 rp_.postRefinement( entity_ );
1112
1113 // reset refinement markers
1114 father.resetRefinedTag();
1115 for( HElementType *son = father.down(); son ; son = son->next() )
1116 son->resetRefinedTag();
1117
1118 return 0;
1119 }
1120
1122 int preCoarsening ( HBndSegType & ghost ) { return 0; }
1123
1124
1126 int postRefinement ( HBndSegType & ghost ) { return 0; }
1127 };
1128
1129
1130
1131 template< class GridType, class AdaptDataHandle, class GlobalIdSetImp >
1134 {
1136 GlobalIdSetImp & set_;
1137 typedef typename GridType::template Codim<0>::Entity EntityType;
1138 typedef typename GridType::template Codim<0>::EntityImp RealEntityType;
1139
1140 typedef typename GridType::MPICommunicatorType Comm;
1141
1143 typedef typename ImplTraits::HElementType HElementType;
1144 typedef typename ImplTraits::HBndSegType HBndSegType;
1145
1146 using AdaptRestrictProlongType :: postRefinement ;
1147 using AdaptRestrictProlongType :: preCoarsening ;
1148
1149 public:
1152 AdaptDataHandle &rp,
1153 GlobalIdSetImp & set )
1154 : BaseType( grid, rp ),
1155 set_( set )
1156 {}
1157
1159
1161 int postRefinement ( HElementType & elem )
1162 {
1163 set_.postRefinement( elem );
1164 return BaseType :: postRefinement(elem );
1165 }
1166 };
1167
1168} // namespace ALUGrid
1169
1170#endif // #ifndef DUNE_ALU3DGRIDDATAHANDLE_HH
#define alugrid_assert(EX)
Definition: alugrid_assert.hh:20
Definition: alu3dinclude.hh:33
Gitter::AdaptRestrictProlong AdaptRestrictProlongType
Definition: alu3dinclude.hh:35
Definition: alu3dinclude.hh:242
the corresponding interface class is defined in bsinclude.hh
Definition: datahandle.hh:66
virtual void setElement(const HElementType &elem)=0
DataCollectorType::DataType DataType
Definition: datahandle.hh:88
GridType::MPICommunicatorType Comm
Definition: datahandle.hh:73
const bool variableSize_
Definition: datahandle.hh:84
GridType::template Codim< codim >::Entity EntityType
Definition: datahandle.hh:70
bool contains(int dim, int cd) const
Definition: datahandle.hh:105
Dune::ALU3dImplTraits< GridType::elementType, Comm > ImplTraits
Definition: datahandle.hh:75
EntityType & entity_
Definition: datahandle.hh:79
RealEntityType & realEntity_
Definition: datahandle.hh:80
void recvData(ObjectStreamType &str, HElementType &elem)
read Data of one element from stream
Definition: datahandle.hh:151
void setData(ObjectStreamType &str, HElementType &elem)
Definition: datahandle.hh:117
DataCollectorType & dc_
Definition: datahandle.hh:82
GatherScatterBaseImpl(const GridType &grid, EntityType &en, RealEntityType &realEntity, DataCollectorType &dc)
Constructor.
Definition: datahandle.hh:97
GridType::template Codim< codim >::EntityImp RealEntityType
Definition: datahandle.hh:71
const GridType & grid_
Definition: datahandle.hh:69
size_t getSize(ObjectStreamType &str, EntityType &en)
Definition: datahandle.hh:161
@ dimension
Definition: datahandle.hh:68
void sendData(ObjectStreamType &str, HElementType &elem)
write Data of one element to stream
Definition: datahandle.hh:134
ImplTraits::template Codim< dimension, codim >::ImplementationType ImplElementType
Definition: datahandle.hh:76
virtual bool containsItem(const HElementType &elem) const =0
ImplTraits::template Codim< dimension, codim >::InterfaceType HElementType
Definition: datahandle.hh:77
GatherScatter::ObjectStreamType ObjectStreamType
Definition: datahandle.hh:86
RealEntityType & realEntity_
Definition: datahandle.hh:205
ImplTraits::template Codim< dimension, codim >::ImplementationType ImplElementType
Definition: datahandle.hh:194
GatherScatterBaseImpl(const GridType &grid, EntityType &en, RealEntityType &realEntity, DataCollectorType &dc)
Constructor.
Definition: datahandle.hh:225
ImplTraits::template Codim< dimension, codim >::InterfaceType HElementType
Definition: datahandle.hh:195
size_t getSize(ObjectStreamType &str, EntityType &en)
Definition: datahandle.hh:298
const bool variableSize_
Definition: datahandle.hh:210
ImplTraits::template Codim< dimension, codim >::GhostInterfaceType HGhostType
Definition: datahandle.hh:199
void sendData(ObjectStreamType &str, const HGhostType &ghost)
write Data of one ghost element to stream
Definition: datahandle.hh:262
const GridType & grid_
Definition: datahandle.hh:187
GridType::template Codim< 0 >::Entity EntityType
Definition: datahandle.hh:188
void recvData(ObjectStreamType &str, HGhostType &ghost)
read Data of one element from stream
Definition: datahandle.hh:286
ImplTraits::template Codim< dimension, 1 >::InterfaceType HFaceType
Definition: datahandle.hh:197
Dune::ALU3dImplTraits< GridType::elementType, Comm > ImplTraits
Definition: datahandle.hh:193
virtual bool containsItem(const HElementType &elem) const
Definition: datahandle.hh:241
EntityType & entity_
Definition: datahandle.hh:204
GridType::template Codim< 0 >::EntityImp RealEntityType
Definition: datahandle.hh:189
bool contains(int dim, int cd) const
Definition: datahandle.hh:235
ImplTraits::PllElementType PllElementType
Definition: datahandle.hh:202
ImplTraits::template Codim< dimension, codim >::GhostImplementationType ImplGhostType
Definition: datahandle.hh:200
GridType::MPICommunicatorType Comm
Definition: datahandle.hh:191
GatherScatter::ObjectStreamType ObjectStreamType
Definition: datahandle.hh:213
virtual bool containsItem(const HGhostType &ghost) const =0
void sendData(ObjectStreamType &str, const HElementType &elem)
write Data of one element to stream
Definition: datahandle.hh:250
void writeSize(ObjectStreamType &str, EntityType &en)
Definition: datahandle.hh:311
DataCollectorType & dc_
Definition: datahandle.hh:208
void recvData(ObjectStreamType &str, HElementType &elem)
read Data of one element from stream
Definition: datahandle.hh:276
the corresponding interface class is defined in bsinclude.hh
Definition: datahandle.hh:325
GatherScatterLeafData(const GridType &grid, EntityType &en, RealEntityType &realEntity, DataCollectorType &dc)
Constructor.
Definition: datahandle.hh:351
bool containsItem(const HGhostType &ghost) const
Definition: datahandle.hh:374
bool containsInterior(const HFaceType &face, PllElementType &pll) const
Definition: datahandle.hh:382
bool containsGhost(const HFaceType &face, PllElementType &pll) const
Definition: datahandle.hh:388
void setElement(const HElementType &elem)
Definition: datahandle.hh:394
bool containsItem(const HElementType &elem) const
Definition: datahandle.hh:368
the corresponding interface class is defined in bsinclude.hh
Definition: datahandle.hh:404
bool containsItem(const HElementType &elem) const
Definition: datahandle.hh:440
GatherScatterLevelData(const GridType &grid, EntityType &en, RealEntityType &realEntity, DataCollectorType &dc, const LevelIndexSetImp &levelSet, const int level)
Constructor.
Definition: datahandle.hh:432
void setElement(const HElementType &elem)
Definition: datahandle.hh:446
the corresponding interface class is defined in bsinclude.hh
Definition: datahandle.hh:458
void setElement(const HElementType &elem)
Definition: datahandle.hh:515
bool containsItem(const HElementType &elem) const
Definition: datahandle.hh:503
GatherScatterNoData(const GridType &grid, EntityType &en, RealEntityType &realEntity, DataCollectorType &dc)
Leaf Constructor.
Definition: datahandle.hh:496
GatherScatterNoData(const GridType &grid, EntityType &en, RealEntityType &realEntity, DataCollectorType &dc, const LevelIndexSetImp &levelSet, const int level)
Level Constructor.
Definition: datahandle.hh:488
void setElement(const RealHElementType &elem)
Definition: datahandle.hh:523
bool containsItem(const RealHElementType &elem) const
Definition: datahandle.hh:509
GatherScatterLevelData(const GridType &grid, EntityType &en, RealEntityType &realEntity, DataCollectorType &dc, const LevelIndexSetImp &levelSet, const int level)
Constructor.
Definition: datahandle.hh:563
bool containsGhost(const HFaceType &face, PllElementType &pll) const
Definition: datahandle.hh:601
bool containsInterior(const HFaceType &face, PllElementType &pll) const
Definition: datahandle.hh:582
bool containsItem(const HGhostType &ghost) const
Definition: datahandle.hh:575
bool containsItem(const HElementType &elem) const
Definition: datahandle.hh:569
Definition: datahandle.hh:618
GridType::template Codim< 0 >::Entity EntityType
Definition: datahandle.hh:625
ImplTraits::template Codim< GridType::dimension, 0 >::InterfaceType HElementType
Definition: datahandle.hh:623
EntityType entity_
Definition: datahandle.hh:676
EntityType & setEntity(HElementType &elem)
Definition: datahandle.hh:760
GridType::template Codim< 0 >::EntityImp EntityImpType
Definition: datahandle.hh:626
LoadBalanceHandleType & ldbHandle()
Definition: datahandle.hh:766
const LoadBalanceHandleType & ldbHandle() const
Definition: datahandle.hh:772
bool userDefinedLoadWeights() const
Definition: datahandle.hh:710
LoadBalanceHandleType * ldbHandle_
Definition: datahandle.hh:679
bool userDefinedPartitioning() const
Definition: datahandle.hh:704
GridType & grid_
Definition: datahandle.hh:674
GatherScatterLoadBalance(GridType &grid)
Constructor.
Definition: datahandle.hh:694
Dune::ALU3dImplTraits< GridType::elementType, Comm > ImplTraits
Definition: datahandle.hh:622
int loadWeight(HElementType &elem)
Definition: datahandle.hh:750
GridType::MPICommunicatorType Comm
Definition: datahandle.hh:620
int destination(HElementType &elem)
Definition: datahandle.hh:741
bool exportRanks(std::set< int > &ranks) const
Definition: datahandle.hh:731
bool importRanks(std::set< int > &ranks) const
Definition: datahandle.hh:723
bool hasUserData() const
Definition: datahandle.hh:701
bool repartition()
Definition: datahandle.hh:716
GatherScatterLoadBalance(GridType &grid, LoadBalanceHandleType &ldb)
Constructor.
Definition: datahandle.hh:686
bool importRank(const LoadBalanceHandleType &lb, std::set< int > &ranks) const
Definition: datahandle.hh:631
int loadWeight(const LoadBalanceHandleType &lb, const EntityType &entity) const
Definition: datahandle.hh:641
int destination(const LoadBalanceHandleType &lb, const EntityType &entity) const
Definition: datahandle.hh:636
int loadWeight(const LoadBalanceHandleType &lb, const EntityType &entity) const
Definition: datahandle.hh:661
int destination(const LoadBalanceHandleType &lb, const EntityType &entity) const
Definition: datahandle.hh:655
bool importRank(const LoadBalanceHandleType &lb, std::set< int > &ranks) const
Definition: datahandle.hh:650
Definition: datahandle.hh:788
void inlineElementData(ObjectStreamType &stream, const EntityType &element)
Definition: datahandle.hh:968
GatherScatterLoadBalanceDataHandle(GridType &grid, DataHandleType &dh, LoadBalanceHandleType &ldb)
Constructor taking load balance handle and data handle.
Definition: datahandle.hh:859
GatherScatterLoadBalanceDataHandle(GridType &grid, DataHandleType &dh)
Constructor for DataHandle only.
Definition: datahandle.hh:869
void inlineHierarchy(ObjectStreamType &str, HElementType &elem)
Definition: datahandle.hh:948
void xtractCodimData(ObjectStreamType &stream, const EntityType &element)
Definition: datahandle.hh:1018
DataHandleType & dataHandle_
Definition: datahandle.hh:841
bool contains(int dim, int cd) const
Definition: datahandle.hh:877
int subEntities(const EntityType &element) const
Definition: datahandle.hh:999
ImplTraits::template Codim< GridType::dimension, 0 >::InterfaceType HElementType
Definition: datahandle.hh:805
Dune::CommDataHandleIF< DataHandleImpl, Data > DataHandleType
Definition: datahandle.hh:809
GatherScatter::ObjectStreamType ObjectStreamType
Definition: datahandle.hh:844
static const int dimension
Definition: datahandle.hh:794
void inlineCodimData(ObjectStreamType &stream, const EntityType &element) const
Definition: datahandle.hh:1005
BaseType::EntityType EntityType
Definition: datahandle.hh:807
bool hasUserData() const
Definition: datahandle.hh:905
void compress()
call compress on data
Definition: datahandle.hh:939
void inlineEntityData(ObjectStreamType &stream, const typename Codim< codim > ::Entity &entity) const
Definition: datahandle.hh:1031
CompressAndReserve< DataHandleType, hasCompressAndReserve > CompressAndReserveType
Definition: datahandle.hh:838
Dune::ALU3dImplTraits< GridType::elementType, Comm > ImplTraits
Definition: datahandle.hh:804
void xtractHierarchy(ObjectStreamType &str, HElementType &elem)
Definition: datahandle.hh:958
bool maxLevelConsistency() const
Definition: datahandle.hh:851
void xtractElementData(ObjectStreamType &stream, const EntityType &element)
Definition: datahandle.hh:983
void xtractData(ObjectStreamType &str, HElementType &elem)
Definition: datahandle.hh:922
GridType::MPICommunicatorType Comm
Definition: datahandle.hh:803
void xtractEntityData(ObjectStreamType &stream, const typename Codim< codim > ::Entity &entity)
Definition: datahandle.hh:1043
static const bool transmitSize
Definition: datahandle.hh:836
static const bool hasCompressAndReserve
Definition: datahandle.hh:834
GridType::Traits::HierarchicIterator HierarchicIterator
Definition: datahandle.hh:795
void inlineData(ObjectStreamType &str, HElementType &elem, const int estimatedElements)
Definition: datahandle.hh:909
GridType::Traits::template Codim< codim >::Entity Entity
Definition: datahandle.hh:800
static void reserveMemory(DH &dataHandle, const size_t newElements)
Definition: datahandle.hh:816
static DataHandleImpl & asImp(DH &dh)
Definition: datahandle.hh:814
static void compress(DH &dataHandle)
Definition: datahandle.hh:820
static void reserveMemory(DH &dataHandle, const size_t newElements)
Definition: datahandle.hh:829
static void compress(DH &dataHandle)
Definition: datahandle.hh:830
Definition: datahandle.hh:1063
AdaptRestrictProlongImpl(GridType &grid, AdaptDataHandle &rp)
Constructor.
Definition: datahandle.hh:1084
int preCoarsening(HBndSegType &ghost)
restrict data for ghost elements
Definition: datahandle.hh:1122
int postRefinement(HElementType &father)
prolong data for elements
Definition: datahandle.hh:1108
int preCoarsening(HElementType &father)
restrict data for elements
Definition: datahandle.hh:1097
virtual ~AdaptRestrictProlongImpl()
Definition: datahandle.hh:1092
int postRefinement(HBndSegType &ghost)
prolong data for ghost elements
Definition: datahandle.hh:1126
Definition: datahandle.hh:1134
AdaptRestrictProlongGlSet(GridType &grid, AdaptDataHandle &rp, GlobalIdSetImp &set)
Constructor.
Definition: datahandle.hh:1151
virtual ~AdaptRestrictProlongGlSet()
Definition: datahandle.hh:1158
int postRefinement(HElementType &elem)
prolong data, elem is the father
Definition: datahandle.hh:1161