entitykey_inline.hh

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

Generated on Fri Apr 29 2011 with Doxygen (ver 1.7.1) [doxygen-log,error-log].