entitykey_inline.hh
00001 #ifndef DUNE_ENTITYKEY_INLINE_HH
00002 #define DUNE_ENTITYKEY_INLINE_HH
00003
00004 #include <algorithm>
00005 #include <dune/grid/io/file/dgfparser/entitykey.hh>
00006
00007 namespace Dune
00008 {
00009
00010
00011
00012
00013 template< class A >
00014 inline DGFEntityKey< A > :: DGFEntityKey ( const std :: vector< A > &key, bool setOrigKey )
00015 : key_( key.size() ),
00016 origKey_( key.size() ),
00017 origKeySet_( setOrigKey )
00018 {
00019 for (size_t i=0;i<key_.size();i++)
00020 {
00021 key_[i]=key[i];
00022 origKey_[i]=key_[i];
00023 }
00024 std :: sort( key_.begin(), key_.end() );
00025 }
00026
00027
00028 template< class A >
00029 inline DGFEntityKey< A > :: DGFEntityKey ( const std :: vector< A > &key,
00030 int N, int offset, bool setOrigKey )
00031 : key_( N ),
00032 origKey_( N ),
00033 origKeySet_( setOrigKey )
00034 {
00035 for (size_t i=0;i<key_.size();i++)
00036 {
00037 key_[i]=key[(i+offset)%key.size()];
00038 origKey_[i]=key[(i+offset)%key.size()];
00039 }
00040 std :: sort( key_.begin(), key_.end() );
00041 }
00042
00043
00044 template< class A >
00045 inline DGFEntityKey< A > :: DGFEntityKey ( const DGFEntityKey< A > &k )
00046 : key_( k.key_.size() ),
00047 origKey_( k.key_.size() ),
00048 origKeySet_( k. origKeySet_ )
00049 {
00050 for (size_t i=0;i<key_.size();i++)
00051 {
00052 key_[i]=k.key_[i];
00053 origKey_[i]=k.origKey_[i];
00054 }
00055 }
00056
00057
00058 template< class A >
00059 inline DGFEntityKey< A > &DGFEntityKey< A > :: operator= ( const DGFEntityKey< A > &k )
00060 {
00061 assert(key_.size()==k.key_.size());
00062 for (size_t i=0;i<key_.size();i++) {
00063 key_[i]=k.key_[i];
00064 origKey_[i]=k.origKey_[i];
00065 }
00066 origKeySet_ = k.origKeySet_;
00067 return *this;
00068 }
00069
00070
00071 template< class A >
00072 inline void DGFEntityKey< A >
00073 :: orientation ( int base, std::vector< std :: vector< double > > &vtx )
00074 {
00075 if (key_.size()==3) {
00076 assert( (size_t) origKey_[0] < vtx.size() );
00077 std::vector<double>& p0 = vtx[origKey_[0]];
00078 assert( (size_t) origKey_[1] < vtx.size() );
00079 std::vector<double>& p1 = vtx[origKey_[1]];
00080 assert( (size_t) origKey_[2] < vtx.size() );
00081 std::vector<double>& p2 = vtx[origKey_[2]];
00082 assert( (size_t) base < vtx.size() );
00083 std::vector<double>& q = vtx[base];
00084 double n[3];
00085 n[0] = (p1[1]-p0[1])*(p2[2]-p0[2])-(p2[1]-p0[1])*(p1[2]-p0[2]);
00086 n[1] = (p1[2]-p0[2])*(p2[0]-p0[0])-(p2[2]-p0[2])*(p1[0]-p0[0]);
00087 n[2] = (p1[0]-p0[0])*(p2[1]-p0[1])-(p2[0]-p0[0])*(p1[1]-p0[1]);
00088 double test = n[0]*(q[0]-p0[0])+n[1]*(q[1]-p0[1])+n[2]*(q[2]-p0[2]);
00089 bool reorient = (test>0);
00090 if (reorient) {
00091 A key1=origKey_[1];
00092 origKey_[1]=origKey_[2];
00093 origKey_[2]=key1;
00094 }
00095 }
00096 }
00097
00098
00099 template< class A >
00100 inline void DGFEntityKey< A > :: print ( std :: ostream &out ) const
00101 {
00102 for( size_t i = 0; i < key_.size(); ++i )
00103 out << key_[ i ] << " ";
00104 out << std :: endl;
00105 }
00106
00107
00108
00109
00110
00111 template< int dimworld >
00112 inline DGFEntityKey< unsigned int >
00113 ElementFaceUtil :: generateCubeFace
00114 ( const std :: vector< unsigned int > &element, int f )
00115 {
00116 static const ReferenceCube< double, dimworld > ref;
00117 const unsigned int size = ref.size( f, 1, dimworld );
00118 std :: vector< unsigned int > k( size );
00119 const int face = ElementTopologyMapping< hexa > :: dune2aluFace( f );
00120 for( unsigned int i = 0; i < size; ++i )
00121 {
00122
00123 int idx = ElementTopologyMapping< hexa > :: alu2duneFaceVertex( face, i );
00124 int idxdune = ref.subEntity( f, 1, idx, dimworld );
00125 assert( idxdune < (int) element.size() );
00126 k[ size - (i+1) ] = element[ idxdune ];
00127 }
00128 return DGFEntityKey< unsigned int >( k );
00129 }
00130
00131
00132 template< int dimworld >
00133 inline DGFEntityKey< unsigned int >
00134 ElementFaceUtil :: generateSimplexFace
00135 ( const std :: vector< unsigned int > &element, int f )
00136 {
00137 static const ReferenceSimplex< double, dimworld > ref;
00138 const unsigned int size = ref.size( f, 1, dimworld );
00139 std :: vector< unsigned int > k( size );
00140 for( unsigned int i = 0; i < size; ++i )
00141 k[ i ] = element[ ref.subEntity( f, 1, i, dimworld ) ];
00142 return DGFEntityKey< unsigned int >( k );
00143 }
00144
00145
00146 inline DGFEntityKey< unsigned int >
00147 ElementFaceUtil :: generateFace
00148 ( int dimw, const std :: vector< unsigned int > &element, int f )
00149 {
00150 if (element.size()==size_t(dimw+1)) {
00151 if (dimw==3)
00152 return generateSimplexFace<3>(element,f);
00153 else if (dimw==2)
00154 return generateSimplexFace<2>(element,f);
00155 else if (dimw==1)
00156 return generateSimplexFace<1>(element,f);
00157 }
00158 else {
00159 if (dimw==3)
00160 return generateCubeFace<3>(element,f);
00161 else if (dimw==2)
00162 return generateCubeFace<2>(element,f);
00163 else if (dimw==1)
00164 return generateCubeFace<1>(element,f);
00165 }
00166 DUNE_THROW(DGFException,"WRONG DIMENSION");
00167 return generateCubeFace<1>(element,f);
00168 }
00169
00170 }
00171
00172 #endif // DUNE_ENTITYKEY_INLINE_HH