3#ifndef DUNE_ALBERTA_MISC_HH
4#define DUNE_ALBERTA_MISC_HH
12#include <dune/grid/albertagrid/albertaheader.hh>
17#ifndef DUNE_ALBERTA_CACHE_COORDINATES
18#define DUNE_ALBERTA_CACHE_COORDINATES 1
43 static const int dimWorld = DIM_OF_WORLD;
45 typedef ALBERTA REAL Real;
46 typedef ALBERTA REAL_B LocalVector;
47 typedef ALBERTA REAL_D GlobalVector;
48 typedef ALBERTA REAL_DD GlobalMatrix;
50#if DUNE_ALBERTA_VERSION >= 0x300
51 typedef ALBERTA AFF_TRAFO AffineTransformation;
53 struct AffineTransformation
60 typedef ALBERTA MESH Mesh;
61 typedef ALBERTA EL Element;
63 static const int meshRefined = MESH_REFINED;
64 static const int meshCoarsened = MESH_COARSENED;
66 static const int InteriorBoundary = INTERIOR;
67 static const int DirichletBoundary = DIRICHLET;
68#if DUNE_ALBERTA_VERSION >= 0x300
69 typedef ALBERTA BNDRY_TYPE BoundaryId;
71 typedef S_CHAR BoundaryId;
74 typedef U_CHAR ElementType;
76 typedef ALBERTA FE_SPACE DofSpace;
83 template<
class Data >
84 inline Data *memAlloc (
size_t size )
86 return MEM_ALLOC( size, Data );
89 template<
class Data >
90 inline Data *memCAlloc (
size_t size )
92 return MEM_CALLOC( size, Data );
95 template<
class Data >
96 inline Data *memReAlloc ( Data *ptr,
size_t oldSize,
size_t newSize )
98 return MEM_REALLOC( ptr, oldSize, newSize, Data );
101 template<
class Data >
102 inline void memFree ( Data *ptr,
size_t size )
104 return MEM_FREE( ptr, size, Data );
114 typedef GlobalSpace This;
117 typedef GlobalMatrix Matrix;
118 typedef GlobalVector Vector;
121 Matrix identityMatrix_;
126 for(
int i = 0; i < dimWorld; ++i )
128 for(
int j = 0; j < dimWorld; ++j )
129 identityMatrix_[ i ][ j ] = Real( 0 );
130 identityMatrix_[ i ][ i ] = Real( 1 );
131 nullVector_[ i ] = Real( 0 );
135 static This &instance ()
137 static This theInstance;
142 static const Matrix &identityMatrix ()
144 return instance().identityMatrix_;
147 static const Vector &nullVector ()
149 return instance().nullVector_;
158 template<
int dim,
int codim >
159 struct NumSubEntities;
162 struct NumSubEntities< dim, 0 >
164 static const int value = 1;
168 struct NumSubEntities< dim, dim >
170 static const int value = dim+1;
174 struct NumSubEntities< 0, 0 >
176 static const int value = 1;
180 struct NumSubEntities< 2, 1 >
182 static const int value = 3;
186 struct NumSubEntities< 3, 1 >
188 static const int value = 4;
192 struct NumSubEntities< 3, 2 >
194 static const int value = 6;
202 template<
int dim,
int codim >
206 struct CodimType< dim, 0 >
208 static const int value = CENTER;
212 struct CodimType< dim, dim >
214 static const int value = VERTEX;
218 struct CodimType< 2, 1 >
220 static const int value = EDGE;
224 struct CodimType< 3, 1 >
226 static const int value = FACE;
230 struct CodimType< 3, 2 >
232 static const int value = EDGE;
243 typedef ALBERTA FLAGS Flags;
245 static const Flags nothing = FILL_NOTHING;
247 static const Flags coords = FILL_COORDS;
249 static const Flags neighbor = FILL_NEIGH;
251 static const Flags orientation = (dim == 3 ? FILL_ORIENTATION : FILL_NOTHING);
253 static const Flags projection = FILL_PROJECTION;
255#if DUNE_ALBERTA_VERSION >= 0x300
256 static const Flags elementType = FILL_NOTHING;
258 static const Flags elementType = (dim == 3 ? FILL_EL_TYPE : FILL_NOTHING);
261#if DUNE_ALBERTA_VERSION >= 0x300
262 static const Flags boundaryId = FILL_MACRO_WALLS;
264 static const Flags boundaryId = FILL_BOUND;
267#if DUNE_ALBERTA_VERSION >= 0x300
268 static const Flags nonPeriodic = FILL_NON_PERIODIC;
270 static const Flags nonPeriodic = FILL_NOTHING;
273 static const Flags all = coords | neighbor | boundaryId | nonPeriodic
274 | orientation | projection | elementType;
276#if DUNE_ALBERTA_VERSION >= 0x300
277 static const Flags standardWithCoords = all & ~nonPeriodic & ~projection;
279 static const Flags standardWithCoords = all;
282#if DUNE_ALBERTA_CACHE_COORDINATES
283 static const Flags standard = standardWithCoords & ~coords;
285 static const Flags standard = standardWithCoords;
295 struct RefinementEdge
297 static const int value = 0;
301 struct RefinementEdge< 2 >
303 static const int value = 2;
311 template<
int dim,
int codim >
312 struct Dune2AlbertaNumbering
314 static int apply (
const int i )
316 assert( (i >= 0) && (i < NumSubEntities< dim, codim >::value) );
322 struct Dune2AlbertaNumbering< 3, 2 >
324 static const int numSubEntities = NumSubEntities< 3, 2 >::value;
326 static int apply (
const int i )
328 assert( (i >= 0) && (i < numSubEntities) );
329 static int dune2alberta[ numSubEntities ] = { 0, 3, 1, 2, 4, 5 };
330 return dune2alberta[ i ];
339 template<
int dim,
int codim >
340 struct Generic2AlbertaNumbering
342 static int apply (
const int i )
344 assert( (i >= 0) && (i < NumSubEntities< dim, codim >::value) );
350 struct Generic2AlbertaNumbering< dim, 1 >
352 static int apply (
const int i )
354 assert( (i >= 0) && (i < NumSubEntities< dim, 1 >::value) );
360 struct Generic2AlbertaNumbering< 1, 1 >
362 static int apply (
const int i )
364 assert( (i >= 0) && (i < NumSubEntities< 1, 1 >::value) );
370 struct Generic2AlbertaNumbering< 3, 2 >
372 static const int numSubEntities = NumSubEntities< 3, 2 >::value;
374 static int apply (
const int i )
376 assert( (i >= 0) && (i < numSubEntities) );
377 static int generic2alberta[ numSubEntities ] = { 0, 1, 3, 2, 4, 5 };
378 return generic2alberta[ i ];
387 template<
int dim,
template<
int,
int >
class Numbering = Generic2AlbertaNumbering >
390 typedef NumberingMap< dim, Numbering > This;
392 template<
int codim >
395 int *dune2alberta_[ dim+1 ];
396 int *alberta2dune_[ dim+1 ];
397 int numSubEntities_[ dim+1 ];
399 NumberingMap (
const This & );
400 This &operator= (
const This & );
405 ForLoop< Initialize, 0, dim >::apply( *
this );
410 for(
int codim = 0; codim <= dim; ++codim )
412 delete[]( dune2alberta_[ codim ] );
413 delete[]( alberta2dune_[ codim ] );
417 int dune2alberta (
int codim,
int i )
const
419 assert( (codim >= 0) && (codim <= dim) );
420 assert( (i >= 0) && (i < numSubEntities( codim )) );
421 return dune2alberta_[ codim ][ i ];
424 int alberta2dune (
int codim,
int i )
const
426 assert( (codim >= 0) && (codim <= dim) );
427 assert( (i >= 0) && (i < numSubEntities( codim )) );
428 return alberta2dune_[ codim ][ i ];
431 int numSubEntities (
int codim )
const
433 assert( (codim >= 0) && (codim <= dim) );
434 return numSubEntities_[ codim ];
443 template<
int dim,
template<
int,
int >
class Numbering >
444 template<
int codim >
445 struct NumberingMap< dim, Numbering >::Initialize
447 static const int numSubEntities = NumSubEntities< dim, codim >::value;
449 static void apply ( NumberingMap< dim, Numbering > &map )
451 map.numSubEntities_[ codim ] = numSubEntities;
452 map.dune2alberta_[ codim ] =
new int[ numSubEntities ];
453 map.alberta2dune_[ codim ] =
new int[ numSubEntities ];
455 for(
int i = 0; i < numSubEntities; ++i )
457 const int j = Numbering< dim, codim >::apply( i );
458 map.dune2alberta_[ codim ][ i ] = j;
459 map.alberta2dune_[ codim ][ j ] = i;
469 template<
int dim,
int codim >
473 struct MapVertices< dim, 0 >
475 static int apply (
int subEntity,
int vertex )
477 assert( subEntity == 0 );
478 assert( (vertex >= 0) && (vertex <= NumSubEntities< dim, dim >::value) );
484 struct MapVertices< 2, 1 >
486 static int apply (
int subEntity,
int vertex )
488 assert( (subEntity >= 0) && (subEntity < 3) );
489 assert( (vertex >= 0) && (vertex < 2) );
491 static const int map[ 3 ][ 2 ] = { {1,2}, {0,2}, {0,1} };
492 return map[ subEntity ][ vertex ];
497 struct MapVertices< 3, 1 >
499 static int apply (
int subEntity,
int vertex )
501 assert( (subEntity >= 0) && (subEntity < 4) );
502 assert( (vertex >= 0) && (vertex < 3) );
504 static const int map[ 4 ][ 3 ] = { {1,2,3}, {0,2,3}, {0,1,3}, {0,1,2} };
505 return map[ subEntity ][ vertex ];
510 struct MapVertices< 3, 2 >
512 static int apply (
int subEntity,
int vertex )
514 assert( (subEntity >= 0) && (subEntity < 6) );
515 assert( (vertex >= 0) && (vertex < 2) );
516 static const int map[ 6 ][ 2 ] = { {0,1}, {0,2}, {0,3}, {1,2}, {1,3}, {2,3} };
517 return map[ subEntity ][ vertex ];
522 struct MapVertices< dim, dim >
524 static int apply (
int subEntity,
int vertex )
526 assert( (subEntity >= 0) && (subEntity < NumSubEntities< dim, 1 >::value) );
527 assert( vertex == 0 );
557 template<
int dim,
int subdim >
560 static const int numSubEntities = NumSubEntities< dim, dim-subdim >::value;
562 static const int minTwist = 0;
563 static const int maxTwist = 0;
565 static int twist (
const Element *element,
int subEntity )
567 assert( (subEntity >= 0) && (subEntity < numSubEntities) );
573 struct Twist< dim, 1 >
575 static const int numSubEntities = NumSubEntities< dim, dim-1 >::value;
577 static const int minTwist = 0;
578 static const int maxTwist = 1;
580 static int twist (
const Element *element,
int subEntity )
582 assert( (subEntity >= 0) && (subEntity < numSubEntities) );
583 const int numVertices = NumSubEntities< 1, 1 >::value;
584 int dof[ numVertices ];
585 for(
int i = 0; i < numVertices; ++i )
587 const int j = MapVertices< dim, dim-1 >::apply( subEntity, i );
588 dof[ i ] = element->dof[ j ][ 0 ];
590 return (dof[ 0 ] < dof[ 1 ] ? 0 : 1);
598 static const int minTwist = 0;
599 static const int maxTwist = 0;
601 static int twist (
const Element *element,
int subEntity )
603 assert( subEntity == 0 );
610 struct Twist< dim, 2 >
612 static const int numSubEntities = NumSubEntities< dim, dim-2 >::value;
614 static const int minTwist = -3;
615 static const int maxTwist = 2;
617 static int twist (
const Element *element,
int subEntity )
619 assert( (subEntity >= 0) && (subEntity < numSubEntities) );
620 const int numVertices = NumSubEntities< 2, 2 >::value;
621 int dof[ numVertices ];
622 for(
int i = 0; i < numVertices; ++i )
624 const int j = MapVertices< dim, dim-2 >::apply( subEntity, i );
625 dof[ i ] = element->dof[ j ][ 0 ];
628 const int twist[ 8 ] = { -2, 1, 666, -1, 2, 666, -3, 0 };
629 const int k = int( dof[ 0 ] < dof[ 1 ] )
630 | (int( dof[ 0 ] < dof[ 2 ] ) << 1)
631 | (
int( dof[ 1 ] < dof[ 2 ] ) << 2);
632 assert( twist[ k ] != 666 );
641 static const int minTwist = 0;
642 static const int maxTwist = 0;
644 static int twist (
const Element *element,
int subEntity )
646 assert( subEntity == 0 );
654 inline int applyTwist (
int twist,
int i )
656 const int numCorners = NumSubEntities< dim, dim >::value;
657 return (twist < 0 ? (2*numCorners + 1 - i + twist) : i + twist) % numCorners;
661 inline int applyInverseTwist (
int twist,
int i )
663 const int numCorners = NumSubEntities< dim, dim >::value;
664 return (twist < 0 ? (2*numCorners + 1 - i + twist) : numCorners + i - twist) % numCorners;
A few common exception classes.
A static for loop for template meta-programming.
Dune namespace.
Definition: alignment.hh:14
Traits for type conversions and type information.