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     ReferenceCube< double, dimworld > ref;
00117     const unsigned int size = ref.size( f, 1, dimworld );
00118     std :: vector< unsigned int > k( size );
00119     /*
00120     for (int i=0;i<size;i++) {
00121       k[i] = element[ref.subEntity(f,1,i,dimworld)];
00122     }
00123     if (dimworld==3) {
00124       if (f==2 || f==1 || f==5) {
00125         int ktmp=k[0];
00126         k[0]=k[1];
00127         k[1]=ktmp;
00128       }
00129       else {
00130         int ktmp=k[2];
00131         k[2]=k[3];
00132         k[3]=ktmp;
00133       }
00134     }
00135     */
00136     const int face = ElementTopologyMapping< hexa > :: dune2aluFace( f );
00137     for( unsigned int i = 0; i < size; ++i )
00138     {
00139       // int idxdune = ref.subEntity(f,1,i,dimworld);
00140       int idx = ElementTopologyMapping< hexa > :: alu2duneFaceVertex( face, i );
00141       int idxdune = ref.subEntity( f, 1, idx, dimworld );
00142       k[ size - (i+1) ] = element[ idxdune ];
00143     }    
00144     return DGFEntityKey< unsigned int >( k );
00145   }
00146 
00147 
00148   template< int dimworld >
00149   inline DGFEntityKey< unsigned int >
00150   ElementFaceUtil :: generateSimplexFace
00151     ( const std :: vector< unsigned int > &element, int f )
00152   {
00153     ReferenceSimplex< double, dimworld > ref;
00154     const unsigned int size = ref.size( f, 1, dimworld );
00155     std :: vector< unsigned int > k( size );
00156     for( unsigned int i = 0; i < size; ++i )
00157       k[ i ] = element[ ref.subEntity( f, 1, i, dimworld ) ];
00158     return DGFEntityKey< unsigned int >( k );
00159   }
00160 
00161   
00162   inline DGFEntityKey< unsigned int >
00163   ElementFaceUtil :: generateFace
00164     ( int dimw, const std :: vector< unsigned int > &element, int f )
00165   {
00166     if (element.size()==size_t(dimw+1)) { // Simplex element
00167       if (dimw==3) 
00168         return generateSimplexFace<3>(element,f);
00169       else if (dimw==2) 
00170         return generateSimplexFace<2>(element,f);
00171       else if (dimw==1) 
00172         return generateSimplexFace<1>(element,f);
00173     }
00174     else { // Cube element
00175       if (dimw==3) 
00176         return generateCubeFace<3>(element,f);
00177       else if (dimw==2) 
00178         return generateCubeFace<2>(element,f);
00179       else if (dimw==1) 
00180         return generateCubeFace<1>(element,f);
00181     }
00182     DUNE_THROW(DGFException,"WRONG DIMENSION");
00183     return generateCubeFace<1>(element,f);
00184   }
00185 
00186 } // end namespace Dune
00187 
00188 #endif // DUNE_ENTITYKEY_INLINE_HH

Generated on Tue Mar 3 12:06:49 2009 for dune-grid by  doxygen 1.5.6