Dune Core Modules (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
27
32
33//- Local includes
34// some cpp defines and include of alberta.h
35#include "albertaheader.hh"
36
37#include <dune/grid/albertagrid/misc.hh>
38#include <dune/grid/albertagrid/capabilities.hh>
39#include <dune/grid/albertagrid/backuprestore.hh>
40
41#include <dune/grid/albertagrid/coordcache.hh>
43#include <dune/grid/albertagrid/level.hh>
44#include <dune/grid/albertagrid/intersection.hh>
46#include <dune/grid/albertagrid/datahandle.hh>
47#include <dune/grid/albertagrid/entityseed.hh>
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
57namespace 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 {
110 < dim, dimworld, Alberta::Real, AlbertaGridFamily< dim, dimworld > >
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 >
135 friend class Alberta::AdaptRestrictProlongHandler;
136
137 public:
139 typedef AlbertaGridFamily< dim, dimworld > GridFamily;
140
141 typedef typename GridFamily::ctype ctype;
142
143 static const int dimension = GridFamily::dimension;
144 static const int dimensionworld = GridFamily::dimensionworld;
145
146 // the Traits
147 typedef typename AlbertaGridFamily< dim, dimworld >::Traits Traits;
148
153
155 typedef typename Traits::HierarchicIndexSet HierarchicIndexSet;
156
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 {
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 //**********************************************************************
511 typedef MakeableInterfaceObject< typename Traits::template Codim< 0 >::Entity >
512 EntityObject;
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
562 Alberta::NumberingMap< dimension, Alberta::Dune2AlbertaNumbering > numberingMap_;
563 Alberta::NumberingMap< dimension, Alberta::Generic2AlbertaNumbering > genericNumberingMap_;
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
594 Alberta::CoordCache< dimension > coordCache_;
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 the GridFamily for AlbertaGrid
Implementation of the IntersectionIterator for AlbertaGrid.
Interface class for the Grid's adapt method where the parameter is a AdaptDataHandleInterface.
Definition: adaptcallback.hh:31
Definition: entity.hh:44
Definition: hierarchiciterator.hh:27
hierarchic index set of AlbertaGrid
Definition: indexsets.hh:532
Definition: treeiterator.hh:187
[ 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
const CollectiveCommunication & comm() const
return reference to collective communication, if MPI found this is specialisation for MPI
Definition: agrid.hh:403
Traits::template Codim< codim >::template Partition< pitype >::LeafIterator leafbegin() const
return LeafIterator which points to first leaf entity
Traits::template Codim< cd >::template Partition< pitype >::LevelIterator lend(int level) const
one past the end on this level
int maxLevel() const
Definition: albertagrid.cc:481
AlbertaGrid()
create an empty grid
Definition: albertagrid.cc:40
Traits::template Codim< codim >::LevelIterator lbegin(int level) const
Iterator to first entity of given codim on level.
Traits::template Codim< codim >::LevelIterator lend(int level) const
one past the end on this level
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
void postAdapt()
clean up some markers
Definition: albertagrid.cc:354
Traits::template Codim< codim >::LeafIterator leafbegin() const
return LeafIterator which points to first leaf entity
const LocalIdSet & localIdSet() const
return local IdSet
Definition: agrid.hh:449
std::size_t numBoundarySegments() const
number of boundary segments within the macro grid
Definition: agrid.hh:348
AlbertaGridFamily< dim, dimworld > GridFamily
the grid family of AlbertaGrid
Definition: agrid.hh:139
Traits::template Codim< codim >::LeafIterator leafend() const
return LeafIterator which points behind last leaf entity
const Traits::LevelIndexSet & levelIndexSet(int level) const
return level index set for given level
Definition: albertagrid.cc:518
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
Traits::template Codim< codim >::template Partition< pitype >::LeafIterator leafend() const
return LeafIterator which points behind last leaf entity
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< cd >::template Partition< pitype >::LevelIterator lbegin(int level) const
Iterator to first entity of given codim on level.
const GlobalIdSet & globalIdSet() const
return global IdSet
Definition: agrid.hh:443
void globalRefine(int refCount)
uses the interface, mark on entity and refineLocal
Definition: albertagrid.cc:302
int getMark(const typename Traits::template Codim< 0 >::Entity &e) const
returns adaptation mark for given entity
Definition: albertagrid.cc:406
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
bool preAdapt()
returns true, if a least one element is marked for coarsening
Definition: albertagrid.cc:346
bool mark(int refCount, const typename Traits::template Codim< 0 >::Entity &e)
Marks an entity to be refined/coarsened in a subsequent adapt.
Definition: albertagrid.cc:383
Traits::CollectiveCommunication CollectiveCommunication
type of collective communication
Definition: agrid.hh:163
marker assigning subentities to one element containing them
Definition: treeiterator.hh:33
Store a reference to an entity with a minimal memory footprint.
Definition: entityseed.hh:24
Implementation & impl()
access to the underlying implementation
Definition: entityseed.hh:57
Implementation & impl()
access to the underlying implementation
Definition: entity.hh:78
Unique label for each type of entities that can occur in DUNE grids.
Definition: type.hh:123
Definition: 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: 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: grid.hh:916
Provide a generic factory class for unstructured grids.
Definition: gridfactory.hh:312
Grid view abstract base class.
Definition: gridview.hh:63
Id Set Interface.
Definition: indexidset.hh:450
Index Set Interface base class.
Definition: indexidset.hh:76
Default exception if a function was called while the object is not in a valid state for that function...
Definition: exceptions.hh:279
Different resources needed by all grid implementations.
Provide a generic factory class for unstructured grids.
Implements an utility class that provides collective communication methods for sequential programs.
Implements a matrix constructed from a given type representing a field and compile-time given number ...
Implements a vector constructed from a given type representing a field and a compile-time given size.
#define DUNE_THROW(E, m)
Definition: exceptions.hh:216
constexpr GeometryType vertex
GeometryType representing a vertex.
Definition: type.hh:504
Dune namespace.
Definition: alignedallocator.hh:11
Provides size cache classes to implement the grids size method efficiently.
Standard Dune debug streams.
Static tag representing a codimension.
Definition: dimension.hh:22
Interface class for vertex projection at the boundary.
Definition: boundaryprojection.hh:31
Contains #undefs for all preprocessor macros defined by alberta.
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Dec 22, 23:30, 2024)