dune-grid  2.2.0
entitykey_inline.hh
Go to the documentation of this file.
1 #ifndef DUNE_ENTITYKEY_INLINE_HH
2 #define DUNE_ENTITYKEY_INLINE_HH
3 
4 #include <algorithm>
5 #include <dune/geometry/referenceelements.hh>
7 
8 namespace Dune
9 {
10 
11  // DGFEntityKey
12  // ------------
13 
14  template< class A >
15  inline DGFEntityKey< A > :: DGFEntityKey ( const std :: vector< A > &key, bool setOrigKey )
16  : key_( key.size() ),
17  origKey_( key.size() ),
18  origKeySet_( setOrigKey )
19  {
20  for (size_t i=0;i<key_.size();i++)
21  {
22  key_[i]=key[i];
23  origKey_[i]=key_[i];
24  }
25  std :: sort( key_.begin(), key_.end() );
26  }
27 
28 
29  template< class A >
30  inline DGFEntityKey< A > :: DGFEntityKey ( const std :: vector< A > &key,
31  int N, int offset, bool setOrigKey )
32  : key_( N ),
33  origKey_( N ),
34  origKeySet_( setOrigKey )
35  {
36  for (size_t i=0;i<key_.size();i++)
37  {
38  key_[i]=key[(i+offset)%key.size()];
39  origKey_[i]=key[(i+offset)%key.size()];
40  }
41  std :: sort( key_.begin(), key_.end() );
42  }
43 
44 
45  template< class A >
47  : key_( k.key_.size() ),
48  origKey_( k.key_.size() ),
49  origKeySet_( k. origKeySet_ )
50  {
51  for (size_t i=0;i<key_.size();i++)
52  {
53  key_[i]=k.key_[i];
54  origKey_[i]=k.origKey_[i];
55  }
56  }
57 
58 
59  template< class A >
61  {
62  assert(key_.size()==k.key_.size());
63  for (size_t i=0;i<key_.size();i++) {
64  key_[i]=k.key_[i];
65  origKey_[i]=k.origKey_[i];
66  }
67  origKeySet_ = k.origKeySet_;
68  return *this;
69  }
70 
71 
72  template< class A >
73  inline void DGFEntityKey< A >
74  :: orientation ( int base, std::vector< std :: vector< double > > &vtx )
75  {
76  if (key_.size()==3) {
77  assert( (size_t) origKey_[0] < vtx.size() );
78  std::vector<double>& p0 = vtx[origKey_[0]];
79  assert( (size_t) origKey_[1] < vtx.size() );
80  std::vector<double>& p1 = vtx[origKey_[1]];
81  assert( (size_t) origKey_[2] < vtx.size() );
82  std::vector<double>& p2 = vtx[origKey_[2]];
83  assert( (size_t) base < vtx.size() );
84  std::vector<double>& q = vtx[base];
85  double n[3];
86  n[0] = (p1[1]-p0[1])*(p2[2]-p0[2])-(p2[1]-p0[1])*(p1[2]-p0[2]);
87  n[1] = (p1[2]-p0[2])*(p2[0]-p0[0])-(p2[2]-p0[2])*(p1[0]-p0[0]);
88  n[2] = (p1[0]-p0[0])*(p2[1]-p0[1])-(p2[0]-p0[0])*(p1[1]-p0[1]);
89  double test = n[0]*(q[0]-p0[0])+n[1]*(q[1]-p0[1])+n[2]*(q[2]-p0[2]);
90  bool reorient = (test>0);
91  if (reorient) {
92  A key1=origKey_[1];
93  origKey_[1]=origKey_[2];
94  origKey_[2]=key1;
95  }
96  }
97  }
98 
99 
100  template< class A >
101  inline void DGFEntityKey< A > :: print ( std :: ostream &out ) const
102  {
103  for( size_t i = 0; i < key_.size(); ++i )
104  out << key_[ i ] << " ";
105  out << std :: endl;
106  }
107 
108 
109  // ElementFaceUtil
110  // ---------------
111 
112  template< int dim >
114  ElementFaceUtil::generateCubeFace
115  ( const std::vector< unsigned int > &element, int f )
116  {
117  const GenericReferenceElement< double, dim > &refCube
119  const unsigned int size = refCube.size( f, 1, dim );
120  std::vector< unsigned int > k( size );
121  for( unsigned int i = 0; i < size; ++ i )
122  k[ i ] = element[ refCube.subEntity( f, 1, i, dim ) ];
123  return DGFEntityKey< unsigned int >( k );
124  }
125 
126 
127  template< int dim >
128  inline DGFEntityKey< unsigned int >
129  ElementFaceUtil :: generateSimplexFace
130  ( const std :: vector< unsigned int > &element, int f )
131  {
132  const GenericReferenceElement< double, dim > &refSimplex
134  const unsigned int size = refSimplex.size( f, 1, dim );
135  std :: vector< unsigned int > k( size );
136  for( unsigned int i = 0; i < size; ++i )
137  k[ i ] = element[ refSimplex.subEntity( f, 1, i, dim ) ];
138  return DGFEntityKey< unsigned int >( k );
139  }
140 
141 
142  inline DGFEntityKey< unsigned int >
143  ElementFaceUtil::generateFace ( int dim, const std::vector< unsigned int > &element, int f )
144  {
145  if( element.size() == size_t(dim+1) )
146  {
147  // Simplex element
148  switch( dim )
149  {
150  case 3:
151  return generateSimplexFace< 3 >( element, f );
152  case 2:
153  return generateSimplexFace< 2 >( element, f );
154  case 1:
155  return generateSimplexFace< 1 >( element, f );
156  default:
157  DUNE_THROW( NotImplemented, "ElementUtil::generateFace not implemented for dim = " << dim << "." );
158  }
159  }
160  else
161  {
162  // Cube element
163  switch( dim )
164  {
165  case 3:
166  return generateCubeFace< 3 >( element, f );
167  case 2:
168  return generateCubeFace< 2 >( element, f );
169  case 1:
170  return generateCubeFace< 1 >( element, f );
171  default:
172  DUNE_THROW( NotImplemented, "ElementUtil::generateFace not implemented for dim = " << dim << "." );
173  }
174  }
175  }
176 
177 } // end namespace Dune
178 
179 #endif // DUNE_ENTITYKEY_INLINE_HH