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