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   // DGFEntityKey
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   // ElementFaceUtil
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       // int idxdune = ref.subEntity(f,1,i,dimworld);
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)) { // Simplex element
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 { // Cube element
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 } // end namespace Dune
00171 
00172 #endif // DUNE_ENTITYKEY_INLINE_HH

Generated on Sun Nov 15 22:28:40 2009 for dune-grid by  doxygen 1.5.6