DUNE PDELab (git)

agrid.hh
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
3// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
4// vi: set et ts=4 sw=2 sts=2:
5#ifndef DUNE_ALBERTAGRID_IMP_HH
6#define DUNE_ALBERTAGRID_IMP_HH
7
13#if HAVE_ALBERTA || DOXYGEN
14
15#include <cassert>
16#include <cstddef>
17
18#include <algorithm>
19#include <iostream>
20#include <fstream>
21#include <memory>
22#include <vector>
23
24// Dune includes
29
34
35//- Local includes
36// some cpp defines and include of alberta.h
37#include "albertaheader.hh"
38
39#include <dune/grid/albertagrid/misc.hh>
40#include <dune/grid/albertagrid/capabilities.hh>
41#include <dune/grid/albertagrid/backuprestore.hh>
42
43#include <dune/grid/albertagrid/coordcache.hh>
45#include <dune/grid/albertagrid/level.hh>
46#include <dune/grid/albertagrid/intersection.hh>
48#include <dune/grid/albertagrid/datahandle.hh>
49#include <dune/grid/albertagrid/entityseed.hh>
50
51#include "indexsets.hh"
52#include "geometry.hh"
53#include "entity.hh"
54#include "hierarchiciterator.hh"
55#include "treeiterator.hh"
56#include "leveliterator.hh"
57#include "leafiterator.hh"
58
59namespace Dune
60{
61
62 // External Forward Declarations
63 // -----------------------------
64
65 template< class Grid >
66 struct DGFGridFactory;
67
68
69
70 // AlbertaGrid
71 // -----------
72
105 template< int dim, int dimworld = Alberta::dimWorld >
108 < dim, dimworld, Alberta::Real, AlbertaGridFamily< dim, dimworld > >
109 {
112 < dim, dimworld, Alberta::Real, AlbertaGridFamily< dim, dimworld > >
113 Base;
114
115 template< int, int, class > friend class AlbertaGridEntity;
116 template< class > friend class AlbertaLevelGridView;
117 template< class > friend class AlbertaLeafGridView;
118 template< int, class, bool > friend class AlbertaGridTreeIterator;
119 template< class > friend class AlbertaGridHierarchicIterator;
120
121 friend class GridFactory< This >;
122 friend struct DGFGridFactory< This >;
123
124 friend class AlbertaGridIntersectionBase< const This >;
125 friend class AlbertaGridLeafIntersection< const This >;
126
127 friend class AlbertaMarkerVector< dim, dimworld >;
128#if (__GNUC__ < 4) && !(defined __ICC)
129 // add additional friend decls for gcc 3.4
130 friend struct AlbertaMarkerVector< dim, dimworld >::MarkSubEntities<true>;
131 friend struct AlbertaMarkerVector< dim, dimworld >::MarkSubEntities<false>;
132#endif
133 friend class AlbertaGridIndexSet< dim, dimworld >;
134 friend class AlbertaGridHierarchicIndexSet< dim, dimworld >;
135
136 template< class, class >
137 friend class Alberta::AdaptRestrictProlongHandler;
138
139 public:
141 typedef AlbertaGridFamily< dim, dimworld > GridFamily;
142
143 typedef typename GridFamily::ctype ctype;
144
145 static const int dimension = GridFamily::dimension;
146 static const int dimensionworld = GridFamily::dimensionworld;
147
148 // the Traits
149 typedef typename AlbertaGridFamily< dim, dimworld >::Traits Traits;
150
155
157 typedef typename Traits::HierarchicIndexSet HierarchicIndexSet;
158
163
166
167 private:
169 typedef typename Traits::template Codim<0>::LeafIterator LeafIterator;
170
172 typedef AlbertaGridIdSet<dim,dimworld> IdSetImp;
173
175 struct AdaptationState
176 {
177 enum Phase { ComputationPhase, PreAdaptationPhase, PostAdaptationPhase };
178
179 private:
180 Phase phase_;
181 int coarsenMarked_;
182 int refineMarked_;
183
184 public:
185 AdaptationState ()
186 : phase_( ComputationPhase ),
187 coarsenMarked_( 0 ),
188 refineMarked_( 0 )
189 {}
190
191 void mark ( int count )
192 {
193 if( count < 0 )
194 ++coarsenMarked_;
195 if( count > 0 )
196 refineMarked_ += (2 << count);
197 }
198
199 void unmark ( int count )
200 {
201 if( count < 0 )
202 --coarsenMarked_;
203 if( count > 0 )
204 refineMarked_ -= (2 << count);
205 }
206
207 bool coarsen () const
208 {
209 return (coarsenMarked_ > 0);
210 }
211
212 int refineMarked () const
213 {
214 return refineMarked_;
215 }
216
217 void preAdapt ()
218 {
219 if( phase_ != ComputationPhase )
220 error( "preAdapt may only be called in computation phase." );
221 phase_ = PreAdaptationPhase;
222 }
223
224 void adapt ()
225 {
226 if( phase_ != PreAdaptationPhase )
227 error( "adapt may only be called in preadapdation phase." );
228 phase_ = PostAdaptationPhase;
229 }
230
231 void postAdapt ()
232 {
233 if( phase_ != PostAdaptationPhase )
234 error( "postAdapt may only be called in postadaptation phase." );
235 phase_ = ComputationPhase;
236
237 coarsenMarked_ = 0;
238 refineMarked_ = 0;
239 }
240
241 private:
242 void error ( const std::string &message )
243 {
245 }
246 };
247
248 template< class DataHandler >
249 struct AdaptationCallback;
250
251 // max number of allowed levels is 64
252 static const int MAXL = 64;
253
254 typedef Alberta::ElementInfo< dimension > ElementInfo;
255 typedef Alberta::MeshPointer< dimension > MeshPointer;
256 typedef Alberta::HierarchyDofNumbering< dimension > DofNumbering;
257 typedef AlbertaGridLevelProvider< dimension > LevelProvider;
258
259 public:
260 AlbertaGrid ( const This & ) = delete;
261 This &operator= ( const This & ) = delete;
262
264 AlbertaGrid ();
265
271 AlbertaGrid ( const Alberta::MacroData< dimension > &macroData,
272 const std::shared_ptr< DuneBoundaryProjection< dimensionworld > > &projection
273 = std::shared_ptr< DuneBoundaryProjection< dimensionworld > >() );
274
275 template< class Proj, class Impl >
276 AlbertaGrid ( const Alberta::MacroData< dimension > &macroData,
277 const Alberta::ProjectionFactoryInterface< Proj, Impl > &projectionFactory );
278
283 AlbertaGrid ( const std::string &macroGridFileName );
284
286 ~AlbertaGrid ();
287
290 int maxLevel () const;
291
293 template<int cd, PartitionIteratorType pitype>
294 typename Traits::template Codim<cd>::template Partition<pitype>::LevelIterator
295 lbegin (int level) const;
296
298 template<int cd, PartitionIteratorType pitype>
299 typename Traits::template Codim<cd>::template Partition<pitype>::LevelIterator
300 lend (int level) const;
301
303 template< int codim >
304 typename Traits::template Codim< codim >::LevelIterator
305 lbegin ( int level ) const;
306
308 template< int codim >
309 typename Traits::template Codim< codim >::LevelIterator
310 lend ( int level ) const;
311
313 template< int codim, PartitionIteratorType pitype >
314 typename Traits
315 ::template Codim< codim >::template Partition< pitype >::LeafIterator
316 leafbegin () const;
317
319 template< int codim, PartitionIteratorType pitype >
320 typename Traits
321 ::template Codim< codim >::template Partition< pitype >::LeafIterator
322 leafend () const;
323
325 template< int codim >
326 typename Traits::template Codim< codim >::LeafIterator
327 leafbegin () const;
328
330 template< int codim >
331 typename Traits::template Codim< codim >::LeafIterator
332 leafend () const;
333
338 int size (int level, int codim) const;
339
341 int size (int level, GeometryType type) const;
342
344 int size (int codim) const;
345
347 int size (GeometryType type) const;
348
350 std::size_t numBoundarySegments () const
351 {
352 return numBoundarySegments_;
353 }
354
356 typename Traits::LevelGridView levelGridView ( int level ) const
357 {
358 typedef typename Traits::LevelGridView View;
359 typedef typename View::GridViewImp ViewImp;
360 return View( ViewImp( *this, level ) );
361 }
362
365 {
366 typedef typename Traits::LeafGridView View;
367 typedef typename View::GridViewImp ViewImp;
368 return View( ViewImp( *this ) );
369 }
370
371 public:
372 //***************************************************************
373 // Interface for Adaptation
374 //***************************************************************
375 using Base::getMark;
376 using Base::mark;
377
379 int getMark ( const typename Traits::template Codim< 0 >::Entity &e ) const;
380
382 bool mark ( int refCount, const typename Traits::template Codim< 0 >::Entity &e );
383
385 void globalRefine ( int refCount );
386
387 template< class DataHandle >
388 void globalRefine ( int refCount, AdaptDataHandleInterface< This, DataHandle > &handle );
389
391 bool adapt ();
392
394 template< class DataHandle >
396
398 bool preAdapt ();
399
401 void postAdapt();
402
405 const Communication &comm () const
406 {
407 return comm_;
408 }
409
410 static std::string typeName ()
411 {
412 std::ostringstream s;
413 s << "AlbertaGrid< " << dim << ", " << dimworld << " >";
414 return s.str();
415 }
416
418 template< class EntitySeed >
419 typename Traits::template Codim< EntitySeed::codimension >::Entity
420 entity ( const EntitySeed &seed ) const
421 {
422 typedef typename Traits::template Codim< EntitySeed::codimension >::EntityImpl EntityImpl;
423 return EntityImpl( *this, seed.impl().elementInfo( meshPointer() ), seed.impl().subEntity() );
424 }
425
426 //**********************************************************
427 // End of Interface Methods
428 //**********************************************************
430 bool writeGrid( const std::string &filename, ctype time ) const;
431
433 bool readGrid( const std::string &filename, ctype &time );
434
435 // return hierarchic index set
436 const HierarchicIndexSet & hierarchicIndexSet () const { return hIndexSet_; }
437
439 const typename Traits :: LevelIndexSet & levelIndexSet (int level) const;
440
442 const typename Traits :: LeafIndexSet & leafIndexSet () const;
443
445 const GlobalIdSet &globalIdSet () const
446 {
447 return idSet_;
448 }
449
451 const LocalIdSet &localIdSet () const
452 {
453 return idSet_;
454 }
455
456 // access to mesh pointer, needed by some methods
457 ALBERTA MESH* getMesh () const
458 {
459 return mesh_;
460 };
461
462 const MeshPointer &meshPointer () const
463 {
464 return mesh_;
465 }
466
467 const DofNumbering &dofNumbering () const
468 {
469 return dofNumbering_;
470 }
471
472 const LevelProvider &levelProvider () const
473 {
474 return levelProvider_;
475 }
476
477 int dune2alberta ( int codim, int i ) const
478 {
479 return numberingMap_.dune2alberta( codim, i );
480 }
481
482 int alberta2dune ( int codim, int i ) const
483 {
484 return numberingMap_.alberta2dune( codim, i );
485 }
486
487 int generic2alberta ( int codim, int i ) const
488 {
489 return genericNumberingMap_.dune2alberta( codim, i );
490 }
491
492 int alberta2generic ( int codim, int i ) const
493 {
494 return genericNumberingMap_.alberta2dune( codim, i );
495 }
496
497 private:
498 typedef std::vector<int> ArrayType;
499
500 void setup ();
501
502 // make the calculation of indexOnLevel and so on.
503 // extra method because of Reihenfolge
504 void calcExtras();
505
506 private:
507 // delete mesh and all vectors
508 void removeMesh();
509
510 //***********************************************************************
511 // MemoryManagement for Entities and Geometries
512 //**********************************************************************
513 typedef MakeableInterfaceObject< typename Traits::template Codim< 0 >::Entity >
514 EntityObject;
515
516 public:
517 friend class AlbertaGridLeafIntersectionIterator< const This >;
518
519 template< int codim >
520 static int
521 getTwist ( const typename Traits::template Codim< codim >::Entity &entity )
522 {
523 return entity.impl().twist();
524 }
525
526 template< int codim >
527 static int
528 getTwist ( const typename Traits::template Codim< 0 >::Entity &entity, int subEntity )
529 {
530 return entity.impl().template twist< codim >( subEntity );
531 }
532
533 static int
534 getTwistInInside ( const typename Traits::LeafIntersection &intersection )
535 {
536 return intersection.impl().twistInInside();
537 }
538
539 static int
540 getTwistInOutside ( const typename Traits::LeafIntersection &intersection )
541 {
542 return intersection.impl().twistInOutside();
543 }
544
545 public:
546 // read global element number from elNumbers_
547 const Alberta::GlobalVector &
548 getCoord ( const ElementInfo &elementInfo, int vertex ) const;
549
550 private:
551 // pointer to an Albert Mesh, which contains the data
552 MeshPointer mesh_;
553
554 // communication
555 Communication comm_;
556
557 // maximum level of the mesh
558 int maxlevel_;
559
560 // number of boundary segments within the macro grid
561 size_t numBoundarySegments_;
562
563 // map between ALBERTA and DUNE numbering
564 Alberta::NumberingMap< dimension, Alberta::Dune2AlbertaNumbering > numberingMap_;
565 Alberta::NumberingMap< dimension, Alberta::Generic2AlbertaNumbering > genericNumberingMap_;
566
567 DofNumbering dofNumbering_;
568
569 LevelProvider levelProvider_;
570
571 // hierarchical numbering of AlbertaGrid, unique per codim
572 HierarchicIndexSet hIndexSet_;
573
574 // the id set of this grid
575 IdSetImp idSet_;
576
577 // the level index set, is generated from the HierarchicIndexSet
578 // is generated, when accessed
579 mutable std::vector< typename GridFamily::LevelIndexSetImp * > levelIndexVec_;
580
581 // the leaf index set, is generated from the HierarchicIndexSet
582 // is generated, when accessed
583 mutable typename GridFamily::LeafIndexSetImp* leafIndexSet_;
584
585 SizeCache< This > sizeCache_;
586
587 typedef AlbertaMarkerVector< dim, dimworld > MarkerVector;
588
589 // needed for VertexIterator, mark on which element a vertex is treated
590 mutable MarkerVector leafMarkerVector_;
591
592 // needed for VertexIterator, mark on which element a vertex is treated
593 mutable std::vector< MarkerVector > levelMarkerVector_;
594
595#if DUNE_ALBERTA_CACHE_COORDINATES
596 Alberta::CoordCache< dimension > coordCache_;
597#endif
598
599 // current state of adaptation
600 AdaptationState adaptationState_;
601 };
602
603} // namespace Dune
604
605#include "albertagrid.cc"
606
607// undef all dangerous defines
608#undef DIM
609#undef DIM_OF_WORLD
610
611#ifdef _ABS_NOT_DEFINED_
612#undef ABS
613#endif
614
615#ifdef _MIN_NOT_DEFINED_
616#undef MIN
617#endif
618
619#ifdef _MAX_NOT_DEFINED_
620#undef MAX
621#endif
622
623#ifdef obstack_chunk_alloc
624#undef obstack_chunk_alloc
625#endif
626#ifdef obstack_chunk_free
627#undef obstack_chunk_free
628#endif
630
631// We use MEM_ALLOC, so undefine it here.
632#undef MEM_ALLOC
633
634// We use MEM_REALLOC, so undefine it here.
635#undef MEM_REALLOC
636
637// We use MEM_CALLOC, so undefine it here.
638#undef MEM_CALLOC
639
640// We use MEM_FREE, so undefine it here.
641#undef MEM_FREE
642
643// Macro ERROR may be defined by alberta_util.h. If so, undefine it.
644#ifdef ERROR
645#undef ERROR
646#endif // #ifdef ERROR
647
648// Macro ERROR_EXIT may be defined by alberta_util.h. If so, undefine it.
649#ifdef ERROR_EXIT
650#undef ERROR_EXIT
651#endif // #ifdef ERROR_EXIT
652
653// Macro WARNING may be defined by alberta_util.h. If so, undefine it.
654#ifdef WARNING
655#undef WARNING
656#endif // #ifdef WARNING
657
658// Macro TEST may be defined by alberta_util.h. If so, undefine it.
659#ifdef TEST
660#undef TEST
661#endif // #ifdef TEST
662
663// Macro TEST_EXIT may be defined by alberta_util.h. If so, undefine it.
664#ifdef TEST_EXIT
665#undef TEST_EXIT
666#endif // #ifdef TEST_EXIT
667
668// Macro DEBUG_TEST may be defined by alberta_util.h. If so, undefine it.
669#ifdef DEBUG_TEST
670#undef DEBUG_TEST
671#endif // #ifdef DEBUG_TEST
672
673// Macro DEBUG_TEST_EXIT may be defined by alberta_util.h. If so, undefine it.
674#ifdef DEBUG_TEST_EXIT
675#undef DEBUG_TEST_EXIT
676#endif // #ifdef DEBUG_TEST_EXIT
677
678// Macro INFO may be defined by alberta_util.h. If so, undefine it.
679#ifdef INFO
680#undef INFO
681#endif // #ifdef INFO
682
683// Macro PRINT_INFO may be defined by alberta_util.h. If so, undefine it.
684#ifdef PRINT_INFO
685#undef PRINT_INFO
686#endif // #ifdef PRINT_INFO
687
688// Macro PRINT_INT_VEC may be defined by alberta_util.h. If so, undefine it.
689#ifdef PRINT_INT_VEC
690#undef PRINT_INT_VEC
691#endif // #ifdef PRINT_INT_VEC
692
693// Macro PRINT_REAL_VEC may be defined by alberta_util.h. If so, undefine it.
694#ifdef PRINT_REAL_VEC
695#undef PRINT_REAL_VEC
696#endif // #ifdef PRINT_REAL_VEC
697
698// Macro WAIT may be defined by alberta_util.h. If so, undefine it.
699#ifdef WAIT
700#undef WAIT
701#endif // #ifdef WAIT
702
703// Macro WAIT_REALLY may be defined by alberta_util.h. If so, undefine it.
704#ifdef WAIT_REALLY
705#undef WAIT_REALLY
706#endif // #ifdef WAIT_REALLY
707
708// Macro GET_WORKSPACE may be defined by alberta_util.h. If so, undefine it.
709#ifdef GET_WORKSPACE
710#undef GET_WORKSPACE
711#endif // #ifdef GET_WORKSPACE
712
713// Macro FREE_WORKSPACE may be defined by alberta_util.h. If so, undefine it.
714#ifdef FREE_WORKSPACE
715#undef FREE_WORKSPACE
716#endif // #ifdef FREE_WORKSPACE
717
718// Macro MAT_ALLOC may be defined by alberta_util.h. If so, undefine it.
719#ifdef MAT_ALLOC
720#undef MAT_ALLOC
721#endif // #ifdef MAT_ALLOC
722
723// Macro MAT_FREE may be defined by alberta_util.h. If so, undefine it.
724#ifdef MAT_FREE
725#undef MAT_FREE
726#endif // #ifdef MAT_FREE
727
728// Macro NAME may be defined by alberta_util.h. If so, undefine it.
729#ifdef NAME
730#undef NAME
731#endif // #ifdef NAME
732
733// Macro GET_STRUCT may be defined by alberta_util.h. If so, undefine it.
734#ifdef GET_STRUCT
735#undef GET_STRUCT
736#endif // #ifdef GET_STRUCT
737
738// Macro ADD_PARAMETER may be defined by alberta_util.h. If so, undefine it.
739#ifdef ADD_PARAMETER
740#undef ADD_PARAMETER
741#endif // #ifdef ADD_PARAMETER
742
743// Macro GET_PARAMETER may be defined by alberta_util.h. If so, undefine it.
744#ifdef GET_PARAMETER
745#undef GET_PARAMETER
746#endif // #ifdef GET_PARAMETER
747
748#define _ALBERTA_H_
749
750#endif // HAVE_ALBERTA || DOXYGEN
751
752#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:33
Definition: entity.hh:46
Definition: hierarchiciterator.hh:29
hierarchic index set of AlbertaGrid
Definition: indexsets.hh:518
Definition: treeiterator.hh:189
[ provides Dune::Grid ]
Definition: agrid.hh:109
bool readGrid(const std::string &filename, ctype &time)
read Grid from file filename and store time of mesh in time
Definition: albertagrid.cc:585
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
Traits::Communication Communication
type of communication
Definition: agrid.hh:165
int maxLevel() const
Definition: albertagrid.cc:483
AlbertaGrid()
create an empty grid
Definition: albertagrid.cc:42
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:364
bool adapt()
Refine all positive marked leaf entities, coarsen all negative marked entities if possible.
Definition: albertagrid.cc:415
void postAdapt()
clean up some markers
Definition: albertagrid.cc:356
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:451
std::size_t numBoundarySegments() const
number of boundary segments within the macro grid
Definition: agrid.hh:350
AlbertaGridFamily< dim, dimworld > GridFamily
the grid family of AlbertaGrid
Definition: agrid.hh:141
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:520
const Communication & comm() const
return reference to communication, if MPI found this is specialisation for MPI
Definition: agrid.hh:405
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:490
Traits::HierarchicIndexSet HierarchicIndexSet
type of hierarchic index set
Definition: agrid.hh:157
const Traits::LeafIndexSet & leafIndexSet() const
return leaf index set
Definition: albertagrid.cc:535
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:575
Traits::LevelGridView levelGridView(int level) const
View for a grid level for All_Partition.
Definition: agrid.hh:356
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:445
void globalRefine(int refCount)
uses the interface, mark on entity and refineLocal
Definition: albertagrid.cc:304
int getMark(const typename Traits::template Codim< 0 >::Entity &e) const
returns adaptation mark for given entity
Definition: albertagrid.cc:408
Traits::template Codim< EntitySeed::codimension >::Entity entity(const EntitySeed &seed) const
obtain Entity from EntitySeed.
Definition: agrid.hh:420
~AlbertaGrid()
destructor
Definition: albertagrid.cc:196
bool preAdapt()
returns true, if a least one element is marked for coarsening
Definition: albertagrid.cc:348
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:385
marker assigning subentities to one element containing them
Definition: treeiterator.hh:35
Store a reference to an entity with a minimal memory footprint.
Definition: entityseed.hh:26
Implementation & impl()
access to the underlying implementation
Definition: entityseed.hh:59
Implementation & impl()
access to the underlying implementation
Definition: entity.hh:80
Unique label for each type of entities that can occur in DUNE grids.
Definition: type.hh:114
Definition: grid.hh:848
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:929
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:941
Provide a generic factory class for unstructured grids.
Definition: gridfactory.hh:275
Grid view abstract base class.
Definition: gridview.hh:66
Id Set Interface.
Definition: indexidset.hh:447
Index Set Interface base class.
Definition: indexidset.hh:78
Default exception if a function was called while the object is not in a valid state for that function...
Definition: exceptions.hh:281
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:218
constexpr GeometryType vertex
GeometryType representing a vertex.
Definition: type.hh:492
Dune namespace.
Definition: alignedallocator.hh:13
Provides size cache classes to implement the grids size method efficiently.
Standard Dune debug streams.
Static tag representing a codimension.
Definition: dimension.hh:24
Interface class for vertex projection at the boundary.
Definition: boundaryprojection.hh:33
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 (Nov 24, 23:30, 2024)