dune-grid  2.8.0
agrid.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_ALBERTAGRID_IMP_HH
4 #define DUNE_ALBERTAGRID_IMP_HH
5 
11 #if HAVE_ALBERTA || DOXYGEN
12 
13 #include <cassert>
14 #include <cstddef>
15 
16 #include <algorithm>
17 #include <iostream>
18 #include <fstream>
19 #include <memory>
20 #include <vector>
21 
22 // Dune includes
23 #include <dune/common/fvector.hh>
24 #include <dune/common/fmatrix.hh>
25 #include <dune/common/stdstreams.hh>
26 #include <dune/common/parallel/communication.hh>
27 
28 #include <dune/grid/common/grid.hh>
32 
33 //- Local includes
34 // some cpp defines and include of alberta.h
35 #include "albertaheader.hh"
36 
40 
48 
49 #include "indexsets.hh"
50 #include "geometry.hh"
51 #include "entity.hh"
52 #include "hierarchiciterator.hh"
53 #include "treeiterator.hh"
54 #include "leveliterator.hh"
55 #include "leafiterator.hh"
56 
57 namespace Dune
58 {
59 
60  // External Forward Declarations
61  // -----------------------------
62 
63  template< class Grid >
64  struct DGFGridFactory;
65 
66 
67 
68  // AlbertaGrid
69  // -----------
70 
103  template< int dim, int dimworld = Alberta::dimWorld >
106  < dim, dimworld, Alberta::Real, AlbertaGridFamily< dim, dimworld > >
107  {
111  Base;
112 
113  template< int, int, class > friend class AlbertaGridEntity;
114  template< class > friend class AlbertaLevelGridView;
115  template< class > friend class AlbertaLeafGridView;
116  template< int, class, bool > friend class AlbertaGridTreeIterator;
117  template< class > friend class AlbertaGridHierarchicIterator;
118 
119  friend class GridFactory< This >;
120  friend struct DGFGridFactory< This >;
121 
122  friend class AlbertaGridIntersectionBase< const This >;
123  friend class AlbertaGridLeafIntersection< const This >;
124 
125  friend class AlbertaMarkerVector< dim, dimworld >;
126 #if (__GNUC__ < 4) && !(defined __ICC)
127  // add additional friend decls for gcc 3.4
128  friend struct AlbertaMarkerVector< dim, dimworld >::MarkSubEntities<true>;
129  friend struct AlbertaMarkerVector< dim, dimworld >::MarkSubEntities<false>;
130 #endif
131  friend class AlbertaGridIndexSet< dim, dimworld >;
132  friend class AlbertaGridHierarchicIndexSet< dim, dimworld >;
133 
134  template< class, class >
136 
137  public:
139  typedef AlbertaGridFamily< dim, dimworld > GridFamily;
140 
141  typedef typename GridFamily::ctype ctype;
142 
143  static const int dimension = GridFamily::dimension;
145 
146  // the Traits
147  typedef typename AlbertaGridFamily< dim, dimworld >::Traits Traits;
148 
153 
156 
160  typedef typename Traits::LocalIdSet LocalIdSet;
161 
164 
165  private:
167  typedef typename Traits::template Codim<0>::LeafIterator LeafIterator;
168 
170  typedef AlbertaGridIdSet<dim,dimworld> IdSetImp;
171 
173  struct AdaptationState
174  {
175  enum Phase { ComputationPhase, PreAdaptationPhase, PostAdaptationPhase };
176 
177  private:
178  Phase phase_;
179  int coarsenMarked_;
180  int refineMarked_;
181 
182  public:
183  AdaptationState ()
184  : phase_( ComputationPhase ),
185  coarsenMarked_( 0 ),
186  refineMarked_( 0 )
187  {}
188 
189  void mark ( int count )
190  {
191  if( count < 0 )
192  ++coarsenMarked_;
193  if( count > 0 )
194  refineMarked_ += (2 << count);
195  }
196 
197  void unmark ( int count )
198  {
199  if( count < 0 )
200  --coarsenMarked_;
201  if( count > 0 )
202  refineMarked_ -= (2 << count);
203  }
204 
205  bool coarsen () const
206  {
207  return (coarsenMarked_ > 0);
208  }
209 
210  int refineMarked () const
211  {
212  return refineMarked_;
213  }
214 
215  void preAdapt ()
216  {
217  if( phase_ != ComputationPhase )
218  error( "preAdapt may only be called in computation phase." );
219  phase_ = PreAdaptationPhase;
220  }
221 
222  void adapt ()
223  {
224  if( phase_ != PreAdaptationPhase )
225  error( "adapt may only be called in preadapdation phase." );
226  phase_ = PostAdaptationPhase;
227  }
228 
229  void postAdapt ()
230  {
231  if( phase_ != PostAdaptationPhase )
232  error( "postAdapt may only be called in postadaptation phase." );
233  phase_ = ComputationPhase;
234 
235  coarsenMarked_ = 0;
236  refineMarked_ = 0;
237  }
238 
239  private:
240  void error ( const std::string &message )
241  {
242  DUNE_THROW( InvalidStateException, message );
243  }
244  };
245 
246  template< class DataHandler >
247  struct AdaptationCallback;
248 
249  // max number of allowed levels is 64
250  static const int MAXL = 64;
251 
252  typedef Alberta::ElementInfo< dimension > ElementInfo;
253  typedef Alberta::MeshPointer< dimension > MeshPointer;
254  typedef Alberta::HierarchyDofNumbering< dimension > DofNumbering;
255  typedef AlbertaGridLevelProvider< dimension > LevelProvider;
256 
257  public:
258  AlbertaGrid ( const This & ) = delete;
259  This &operator= ( const This & ) = delete;
260 
262  AlbertaGrid ();
263 
269  AlbertaGrid ( const Alberta::MacroData< dimension > &macroData,
270  const std::shared_ptr< DuneBoundaryProjection< dimensionworld > > &projection
271  = std::shared_ptr< DuneBoundaryProjection< dimensionworld > >() );
272 
273  template< class Proj, class Impl >
274  AlbertaGrid ( const Alberta::MacroData< dimension > &macroData,
275  const Alberta::ProjectionFactoryInterface< Proj, Impl > &projectionFactory );
276 
281  AlbertaGrid ( const std::string &macroGridFileName );
282 
284  ~AlbertaGrid ();
285 
288  int maxLevel () const;
289 
291  template<int cd, PartitionIteratorType pitype>
292  typename Traits::template Codim<cd>::template Partition<pitype>::LevelIterator
293  lbegin (int level) const;
294 
296  template<int cd, PartitionIteratorType pitype>
297  typename Traits::template Codim<cd>::template Partition<pitype>::LevelIterator
298  lend (int level) const;
299 
301  template< int codim >
302  typename Traits::template Codim< codim >::LevelIterator
303  lbegin ( int level ) const;
304 
306  template< int codim >
307  typename Traits::template Codim< codim >::LevelIterator
308  lend ( int level ) const;
309 
311  template< int codim, PartitionIteratorType pitype >
312  typename Traits
313  ::template Codim< codim >::template Partition< pitype >::LeafIterator
314  leafbegin () const;
315 
317  template< int codim, PartitionIteratorType pitype >
318  typename Traits
319  ::template Codim< codim >::template Partition< pitype >::LeafIterator
320  leafend () const;
321 
323  template< int codim >
324  typename Traits::template Codim< codim >::LeafIterator
325  leafbegin () const;
326 
328  template< int codim >
329  typename Traits::template Codim< codim >::LeafIterator
330  leafend () const;
331 
336  int size (int level, int codim) const;
337 
339  int size (int level, GeometryType type) const;
340 
342  int size (int codim) const;
343 
345  int size (GeometryType type) const;
346 
348  std::size_t numBoundarySegments () const
349  {
350  return numBoundarySegments_;
351  }
352 
354  typename Traits::LevelGridView levelGridView ( int level ) const
355  {
356  typedef typename Traits::LevelGridView View;
357  typedef typename View::GridViewImp ViewImp;
358  return View( ViewImp( *this, level ) );
359  }
360 
363  {
364  typedef typename Traits::LeafGridView View;
365  typedef typename View::GridViewImp ViewImp;
366  return View( ViewImp( *this ) );
367  }
368 
369  public:
370  //***************************************************************
371  // Interface for Adaptation
372  //***************************************************************
373  using Base::getMark;
374  using Base::mark;
375 
377  int getMark ( const typename Traits::template Codim< 0 >::Entity &e ) const;
378 
380  bool mark ( int refCount, const typename Traits::template Codim< 0 >::Entity &e );
381 
383  void globalRefine ( int refCount );
384 
385  template< class DataHandle >
386  void globalRefine ( int refCount, AdaptDataHandleInterface< This, DataHandle > &handle );
387 
389  bool adapt ();
390 
392  template< class DataHandle >
394 
396  bool preAdapt ();
397 
399  void postAdapt();
400 
404  {
405  return comm_;
406  }
407 
408  static std::string typeName ()
409  {
410  std::ostringstream s;
411  s << "AlbertaGrid< " << dim << ", " << dimworld << " >";
412  return s.str();
413  }
414 
416  template< class EntitySeed >
417  typename Traits::template Codim< EntitySeed::codimension >::Entity
418  entity ( const EntitySeed &seed ) const
419  {
420  typedef typename Traits::template Codim< EntitySeed::codimension >::EntityImpl EntityImpl;
421  return EntityImpl( *this, seed.impl().elementInfo( meshPointer() ), seed.impl().subEntity() );
422  }
423 
424  //**********************************************************
425  // End of Interface Methods
426  //**********************************************************
428  bool writeGrid( const std::string &filename, ctype time ) const;
429 
431  bool readGrid( const std::string &filename, ctype &time );
432 
433  // return hierarchic index set
434  const HierarchicIndexSet & hierarchicIndexSet () const { return hIndexSet_; }
435 
437  const typename Traits :: LevelIndexSet & levelIndexSet (int level) const;
438 
440  const typename Traits :: LeafIndexSet & leafIndexSet () const;
441 
443  const GlobalIdSet &globalIdSet () const
444  {
445  return idSet_;
446  }
447 
449  const LocalIdSet &localIdSet () const
450  {
451  return idSet_;
452  }
453 
454  // access to mesh pointer, needed by some methods
455  ALBERTA MESH* getMesh () const
456  {
457  return mesh_;
458  };
459 
460  const MeshPointer &meshPointer () const
461  {
462  return mesh_;
463  }
464 
465  const DofNumbering &dofNumbering () const
466  {
467  return dofNumbering_;
468  }
469 
470  const LevelProvider &levelProvider () const
471  {
472  return levelProvider_;
473  }
474 
475  int dune2alberta ( int codim, int i ) const
476  {
477  return numberingMap_.dune2alberta( codim, i );
478  }
479 
480  int alberta2dune ( int codim, int i ) const
481  {
482  return numberingMap_.alberta2dune( codim, i );
483  }
484 
485  int generic2alberta ( int codim, int i ) const
486  {
487  return genericNumberingMap_.dune2alberta( codim, i );
488  }
489 
490  int alberta2generic ( int codim, int i ) const
491  {
492  return genericNumberingMap_.alberta2dune( codim, i );
493  }
494 
495  private:
496  typedef std::vector<int> ArrayType;
497 
498  void setup ();
499 
500  // make the calculation of indexOnLevel and so on.
501  // extra method because of Reihenfolge
502  void calcExtras();
503 
504  private:
505  // delete mesh and all vectors
506  void removeMesh();
507 
508  //***********************************************************************
509  // MemoryManagement for Entitys and Geometrys
510  //**********************************************************************
513 
514  public:
515  friend class AlbertaGridLeafIntersectionIterator< const This >;
516 
517  template< int codim >
518  static int
519  getTwist ( const typename Traits::template Codim< codim >::Entity &entity )
520  {
521  return entity.impl().twist();
522  }
523 
524  template< int codim >
525  static int
526  getTwist ( const typename Traits::template Codim< 0 >::Entity &entity, int subEntity )
527  {
528  return entity.impl().template twist< codim >( subEntity );
529  }
530 
531  static int
532  getTwistInInside ( const typename Traits::LeafIntersection &intersection )
533  {
534  return intersection.impl().twistInInside();
535  }
536 
537  static int
538  getTwistInOutside ( const typename Traits::LeafIntersection &intersection )
539  {
540  return intersection.impl().twistInOutside();
541  }
542 
543  public:
544  // read global element number from elNumbers_
545  const Alberta::GlobalVector &
546  getCoord ( const ElementInfo &elementInfo, int vertex ) const;
547 
548  private:
549  // pointer to an Albert Mesh, which contains the data
550  MeshPointer mesh_;
551 
552  // collective communication
554 
555  // maximum level of the mesh
556  int maxlevel_;
557 
558  // number of boundary segments within the macro grid
559  size_t numBoundarySegments_;
560 
561  // map between ALBERTA and DUNE numbering
564 
565  DofNumbering dofNumbering_;
566 
567  LevelProvider levelProvider_;
568 
569  // hierarchical numbering of AlbertaGrid, unique per codim
570  HierarchicIndexSet hIndexSet_;
571 
572  // the id set of this grid
573  IdSetImp idSet_;
574 
575  // the level index set, is generated from the HierarchicIndexSet
576  // is generated, when accessed
577  mutable std::vector< typename GridFamily::LevelIndexSetImp * > levelIndexVec_;
578 
579  // the leaf index set, is generated from the HierarchicIndexSet
580  // is generated, when accessed
581  mutable typename GridFamily::LeafIndexSetImp* leafIndexSet_;
582 
583  SizeCache< This > sizeCache_;
584 
585  typedef AlbertaMarkerVector< dim, dimworld > MarkerVector;
586 
587  // needed for VertexIterator, mark on which element a vertex is treated
588  mutable MarkerVector leafMarkerVector_;
589 
590  // needed for VertexIterator, mark on which element a vertex is treated
591  mutable std::vector< MarkerVector > levelMarkerVector_;
592 
593 #if DUNE_ALBERTA_CACHE_COORDINATES
595 #endif
596 
597  // current state of adaptation
598  AdaptationState adaptationState_;
599  };
600 
601 } // namespace Dune
602 
603 #include "albertagrid.cc"
604 
605 // undef all dangerous defines
606 #undef DIM
607 #undef DIM_OF_WORLD
608 
609 #ifdef _ABS_NOT_DEFINED_
610 #undef ABS
611 #endif
612 
613 #ifdef _MIN_NOT_DEFINED_
614 #undef MIN
615 #endif
616 
617 #ifdef _MAX_NOT_DEFINED_
618 #undef MAX
619 #endif
620 
621 #ifdef obstack_chunk_alloc
622 #undef obstack_chunk_alloc
623 #endif
624 #ifdef obstack_chunk_free
625 #undef obstack_chunk_free
626 #endif
628 
629 // We use MEM_ALLOC, so undefine it here.
630 #undef MEM_ALLOC
631 
632 // We use MEM_REALLOC, so undefine it here.
633 #undef MEM_REALLOC
634 
635 // We use MEM_CALLOC, so undefine it here.
636 #undef MEM_CALLOC
637 
638 // We use MEM_FREE, so undefine it here.
639 #undef MEM_FREE
640 
641 // Macro ERROR may be defined by alberta_util.h. If so, undefine it.
642 #ifdef ERROR
643 #undef ERROR
644 #endif // #ifdef ERROR
645 
646 // Macro ERROR_EXIT may be defined by alberta_util.h. If so, undefine it.
647 #ifdef ERROR_EXIT
648 #undef ERROR_EXIT
649 #endif // #ifdef ERROR_EXIT
650 
651 // Macro WARNING may be defined by alberta_util.h. If so, undefine it.
652 #ifdef WARNING
653 #undef WARNING
654 #endif // #ifdef WARNING
655 
656 // Macro TEST may be defined by alberta_util.h. If so, undefine it.
657 #ifdef TEST
658 #undef TEST
659 #endif // #ifdef TEST
660 
661 // Macro TEST_EXIT may be defined by alberta_util.h. If so, undefine it.
662 #ifdef TEST_EXIT
663 #undef TEST_EXIT
664 #endif // #ifdef TEST_EXIT
665 
666 // Macro DEBUG_TEST may be defined by alberta_util.h. If so, undefine it.
667 #ifdef DEBUG_TEST
668 #undef DEBUG_TEST
669 #endif // #ifdef DEBUG_TEST
670 
671 // Macro DEBUG_TEST_EXIT may be defined by alberta_util.h. If so, undefine it.
672 #ifdef DEBUG_TEST_EXIT
673 #undef DEBUG_TEST_EXIT
674 #endif // #ifdef DEBUG_TEST_EXIT
675 
676 // Macro INFO may be defined by alberta_util.h. If so, undefine it.
677 #ifdef INFO
678 #undef INFO
679 #endif // #ifdef INFO
680 
681 // Macro PRINT_INFO may be defined by alberta_util.h. If so, undefine it.
682 #ifdef PRINT_INFO
683 #undef PRINT_INFO
684 #endif // #ifdef PRINT_INFO
685 
686 // Macro PRINT_INT_VEC may be defined by alberta_util.h. If so, undefine it.
687 #ifdef PRINT_INT_VEC
688 #undef PRINT_INT_VEC
689 #endif // #ifdef PRINT_INT_VEC
690 
691 // Macro PRINT_REAL_VEC may be defined by alberta_util.h. If so, undefine it.
692 #ifdef PRINT_REAL_VEC
693 #undef PRINT_REAL_VEC
694 #endif // #ifdef PRINT_REAL_VEC
695 
696 // Macro WAIT may be defined by alberta_util.h. If so, undefine it.
697 #ifdef WAIT
698 #undef WAIT
699 #endif // #ifdef WAIT
700 
701 // Macro WAIT_REALLY may be defined by alberta_util.h. If so, undefine it.
702 #ifdef WAIT_REALLY
703 #undef WAIT_REALLY
704 #endif // #ifdef WAIT_REALLY
705 
706 // Macro GET_WORKSPACE may be defined by alberta_util.h. If so, undefine it.
707 #ifdef GET_WORKSPACE
708 #undef GET_WORKSPACE
709 #endif // #ifdef GET_WORKSPACE
710 
711 // Macro FREE_WORKSPACE may be defined by alberta_util.h. If so, undefine it.
712 #ifdef FREE_WORKSPACE
713 #undef FREE_WORKSPACE
714 #endif // #ifdef FREE_WORKSPACE
715 
716 // Macro MAT_ALLOC may be defined by alberta_util.h. If so, undefine it.
717 #ifdef MAT_ALLOC
718 #undef MAT_ALLOC
719 #endif // #ifdef MAT_ALLOC
720 
721 // Macro MAT_FREE may be defined by alberta_util.h. If so, undefine it.
722 #ifdef MAT_FREE
723 #undef MAT_FREE
724 #endif // #ifdef MAT_FREE
725 
726 // Macro NAME may be defined by alberta_util.h. If so, undefine it.
727 #ifdef NAME
728 #undef NAME
729 #endif // #ifdef NAME
730 
731 // Macro GET_STRUCT may be defined by alberta_util.h. If so, undefine it.
732 #ifdef GET_STRUCT
733 #undef GET_STRUCT
734 #endif // #ifdef GET_STRUCT
735 
736 // Macro ADD_PARAMETER may be defined by alberta_util.h. If so, undefine it.
737 #ifdef ADD_PARAMETER
738 #undef ADD_PARAMETER
739 #endif // #ifdef ADD_PARAMETER
740 
741 // Macro GET_PARAMETER may be defined by alberta_util.h. If so, undefine it.
742 #ifdef GET_PARAMETER
743 #undef GET_PARAMETER
744 #endif // #ifdef GET_PARAMETER
745 
746 #define _ALBERTA_H_
747 
748 #endif // HAVE_ALBERTA || DOXYGEN
749 
750 #endif
interfaces and wrappers needed for the callback adaptation provided by AlbertaGrid and dune-ALUGrid
Provides size cache classes to implement the grids size method efficiently.
#define ALBERTA
Definition: albertaheader.hh:27
Contains #undefs for all preprocessor macros defined by alberta.
Include standard header files.
Definition: agrid.hh:58
ALBERTA REAL Real
Definition: misc.hh:46
ALBERTA REAL_D GlobalVector
Definition: misc.hh:48
GeometryType
Type representing VTK's entity geometry types.
Definition: common.hh:130
@ vertex
Definition: common.hh:131
Definition: dgfgridfactory.hh:36
[ provides Dune::Grid ]
Definition: agrid.hh:107
bool readGrid(const std::string &filename, ctype &time)
read Grid from file filename and store time of mesh in time
Definition: albertagrid.cc:583
int generic2alberta(int codim, int i) const
Definition: agrid.hh:485
static std::string typeName()
Definition: agrid.hh:408
const DofNumbering & dofNumbering() const
Definition: agrid.hh:465
Traits ::template Codim< codim >::template Partition< pitype >::LeafIterator leafbegin() const
return LeafIterator which points to first leaf entity
static const int dimension
Definition: agrid.hh:143
bool mark(int refCount, const typename Traits ::template Codim< 0 >::Entity &e)
Marks an entity to be refined/coarsened in a subsequent adapt.
Definition: common/grid.hh:904
int dune2alberta(int codim, int i) const
Definition: agrid.hh:475
int getMark(const typename Traits::template Codim< 0 >::Entity &e) const
returns adaptation mark for given entity, i.e. here the default implementation returns 0.
Definition: common/grid.hh:916
const HierarchicIndexSet & hierarchicIndexSet() const
Definition: agrid.hh:434
int maxLevel() const
Definition: albertagrid.cc:481
const LevelProvider & levelProvider() const
Definition: agrid.hh:470
Traits::template Codim< cd >::template Partition< pitype >::LevelIterator lbegin(int level) const
Iterator to first entity of given codim on level.
Definition: albertagrid.cc:204
const MeshPointer & meshPointer() const
Definition: agrid.hh:460
AlbertaGrid()
create an empty grid
Definition: albertagrid.cc:40
Traits::template Codim< cd >::template Partition< pitype >::LevelIterator lend(int level) const
one past the end on this level
Definition: albertagrid.cc:224
static int getTwistInOutside(const typename Traits::LeafIntersection &intersection)
Definition: agrid.hh:538
ALBERTA MESH * getMesh() const
Definition: agrid.hh:455
const Alberta::GlobalVector & getCoord(const ElementInfo &elementInfo, int vertex) const
Definition: albertagrid.cc:469
Traits::LeafGridView leafGridView() const
View for the leaf grid for All_Partition.
Definition: agrid.hh:362
bool adapt()
Refine all positive marked leaf entities, coarsen all negative marked entities if possible.
Definition: albertagrid.cc:413
const LocalIdSet & localIdSet() const
return local IdSet
Definition: agrid.hh:449
static const int dimensionworld
Definition: agrid.hh:144
static int getTwistInInside(const typename Traits::LeafIntersection &intersection)
Definition: agrid.hh:532
void postAdapt()
clean up some markers
Definition: albertagrid.cc:354
This & operator=(const This &)=delete
std::size_t numBoundarySegments() const
number of boundary segments within the macro grid
Definition: agrid.hh:348
const CollectiveCommunication & comm() const
return reference to collective communication, if MPI found this is specialisation for MPI
Definition: agrid.hh:403
GridFamily::ctype ctype
Definition: agrid.hh:141
AlbertaGrid(const This &)=delete
const Traits ::LevelIndexSet & levelIndexSet(int level) const
return level index set for given level
Definition: albertagrid.cc:518
int alberta2generic(int codim, int i) const
Definition: agrid.hh:490
static int getTwist(const typename Traits::template Codim< codim >::Entity &entity)
Definition: agrid.hh:519
int size(int level, int codim) const
Number of grid entities per level and codim because lbegin and lend are none const,...
Definition: albertagrid.cc:488
Traits::HierarchicIndexSet HierarchicIndexSet
type of hierarchic index set
Definition: agrid.hh:155
const Traits ::LeafIndexSet & leafIndexSet() const
return leaf index set
Definition: albertagrid.cc:533
bool writeGrid(const std::string &filename, ctype time) const
write Grid to file in Xdr
Definition: albertagrid.cc:573
Traits::LevelGridView levelGridView(int level) const
View for a grid level for All_Partition.
Definition: agrid.hh:354
Traits ::template Codim< codim >::template Partition< pitype >::LeafIterator leafend() const
return LeafIterator which points behind last leaf entity
int alberta2dune(int codim, int i) const
Definition: agrid.hh:480
static int getTwist(const typename Traits::template Codim< 0 >::Entity &entity, int subEntity)
Definition: agrid.hh:526
void globalRefine(int refCount)
uses the interface, mark on entity and refineLocal
Definition: albertagrid.cc:302
Traits::template Codim< EntitySeed::codimension >::Entity entity(const EntitySeed &seed) const
obtain Entity from EntitySeed.
Definition: agrid.hh:418
~AlbertaGrid()
desctructor
Definition: albertagrid.cc:194
const GlobalIdSet & globalIdSet() const
return global IdSet
Definition: agrid.hh:443
bool preAdapt()
returns true, if a least one element is marked for coarsening
Definition: albertagrid.cc:346
Traits::CollectiveCommunication CollectiveCommunication
type of collective communication
Definition: agrid.hh:163
Definition: coordcache.hh:23
Definition: albertagrid/datahandle.hh:25
Intersection of a mesh entity of codimension 0 ("element") with a "neighboring" element or with the d...
Definition: common/intersection.hh:162
Implementation & impl()
access to the underlying implementation
Definition: common/intersection.hh:176
Definition: treeiterator.hh:187
Definition: hierarchiciterator.hh:27
Definition: albertagrid/intersection.hh:103
Definition: albertagrid/intersectioniterator.hh:25
Definition: albertagrid/entity.hh:44
Definition: albertagrid/indexsets.hh:40
hierarchic index set of AlbertaGrid
Definition: albertagrid/indexsets.hh:532
Definition: albertagrid/indexsets.hh:333
Definition: albertagrid/gridfamily.hh:81
static const int dimension
Definition: albertagrid/gridfamily.hh:86
static const int dimensionworld
Definition: albertagrid/gridfamily.hh:87
AlbertaGridIndexSet< dim, dimworld > LeafIndexSetImp
Definition: albertagrid/gridfamily.hh:90
Alberta::Real ctype
Definition: albertagrid/gridfamily.hh:84
Definition: albertagrid/gridfamily.hh:96
IndexSet< GridImp, LeafIndexSetImp, int, std::array< GeometryType, 1 > > LeafIndexSet
Definition: albertagrid/gridfamily.hh:141
IndexSet< GridImp, LevelIndexSetImp, int, std::array< GeometryType, 1 > > LevelIndexSet
Definition: albertagrid/gridfamily.hh:140
Dune::CollectiveCommunication< No_Comm > CollectiveCommunication
Definition: albertagrid/gridfamily.hh:146
Definition: albertagrid/gridview.hh:74
Definition: albertagrid/gridview.hh:282
Definition: albertagrid/intersection.hh:30
int alberta2dune(int codim, int i) const
Definition: misc.hh:395
int dune2alberta(int codim, int i) const
Definition: misc.hh:388
Definition: albertagrid/projection.hh:78
marker assigning subentities to one element containing them
Definition: treeiterator.hh:33
Interface class for the Grid's adapt method where the parameter is a AdaptDataHandleInterface.
Definition: adaptcallback.hh:31
Interface class for vertex projection at the boundary.
Definition: boundaryprojection.hh:31
Implementation & impl()
access to the underlying implementation
Definition: common/entity.hh:78
Store a reference to an entity with a minimal memory footprint.
Definition: common/entityseed.hh:24
Implementation & impl()
access to the underlying implementation
Definition: common/entityseed.hh:57
Definition: common/grid.hh:851
bool mark(int refCount, const typename Traits ::template Codim< 0 >::Entity &e)
Marks an entity to be refined/coarsened in a subsequent adapt.
Definition: common/grid.hh:904
int getMark(const typename Traits::template Codim< 0 >::Entity &e) const
returns adaptation mark for given entity, i.e. here the default implementation returns 0.
Definition: common/grid.hh:916
Index Set Interface base class.
Definition: indexidset.hh:76
Id Set Interface.
Definition: indexidset.hh:450
A Traits struct that collects all associated types of one implementation.
Definition: common/grid.hh:414
GridFamily::Traits::template Codim< cd >::Entity Entity
A type that is a model of a Dune::Entity<cd,dim,...>.
Definition: common/grid.hh:422
Definition: common/grid.hh:1092
Provide a generic factory class for unstructured grids.
Definition: common/gridfactory.hh:312
Grid view abstract base class.
Definition: common/gridview.hh:63
organizes the caching of sizes for one grid and one GeometryType
Definition: sizecache.hh:31
Different resources needed by all grid implementations.
Provide a generic factory class for unstructured grids.
provides the GridFamily for AlbertaGrid
Implementation of the IntersectionIterator for AlbertaGrid.