commindexmap.hh

#ifndef DUNE_FEM_COMMINDEXMAP_HH
#define DUNE_FEM_COMMINDEXMAP_HH
 
#include <set>
#include <vector>
 
#include <dune/fem/storage/dynamicarray.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    class CommunicationIndexMap
    {
    public:
      // this typedef will also change the type of index
      // for AuxiliaryDofs and AdaptiveLeafIndexSet
      // TODO: extract to a more common place
      typedef int IndexType ;
    private:
      DynamicArray< IndexType > indices_;
 
      static const IndexType invalidIndex = IndexType(-1);
 
    public:
      CommunicationIndexMap()
      : indices_( 0 )
      {
        indices_.setMemoryFactor( 1.1 );
      }
 
      CommunicationIndexMap( const CommunicationIndexMap& ) = delete;
 
      const IndexType& operator [] ( const size_t i ) const
      {
        assert( i < size() );
        return indices_[ i ];
      }
 
      void erase( const size_t i )
      {
        indices_[ i ] = invalidIndex;
      }
 
      void clear()
      {
        resize( 0 );
      }
 
      template <class GlobalKey>
      void insert( const std :: vector< GlobalKey > &idx )
      {
        const size_t size = idx.size();
        size_t  count = indices_.size();
 
        // reserve memory
        resize( count + size );
        assert( indices_.size() == (count + size) );
 
        // copy indices to index vector
        for( size_t i = 0; i < size; ++i, ++count )
        {
          assert( idx[ i ] >= 0 );
          indices_[ count ] = idx[ i ];
        }
      }
 
      template <class GlobalKey>
      void set( const std :: set< GlobalKey > &idxSet )
      {
        // resize to given new size
        resize( idxSet.size() );
 
        // copy all elements from set to array
        size_t count = 0;
        typedef typename std :: set< GlobalKey > :: const_iterator iterator;
        const iterator end = idxSet.end();
        for(iterator it = idxSet.begin(); it != end; ++it, ++count)
        {
          indices_[count] = *it;
        }
      }
 
      size_t size () const
      {
        return indices_.size();
      }
 
      void print( std :: ostream &s, int rank ) const
      {
        const size_t size = this->size();
        s << "Start print: size = " << size << std :: endl;
        for( size_t i = 0; i < size; ++i )
          s << rank << " idx[ " << i << " ] = " << indices_[ i ] << std :: endl;
        s << "End of Array" << std :: endl;
      }
 
      template <class CommBuffer>
      void writeToBuffer(CommBuffer& buffer) const
      {
        const size_t idxSize = indices_.size();
        buffer.write( idxSize );
        //std::cout << "P[" << MPIManager ::rank() << " write Buffer size " << idxSize << std::endl;
        for(size_t i=0; i<idxSize; ++i)
        {
          //std::cout << "P[" << MPIManager ::rank() << " write idx " << indices_[i] << std::endl;
          buffer.write( indices_[i] );
        }
      }
 
      template <class CommBuffer>
      void readFromBuffer(CommBuffer& buffer)
      {
        size_t idxSize;
        buffer.read( idxSize );
        //std::cout << "P[" << MPIManager ::rank() << " read Buffer size " << idxSize << std::endl;
        indices_.resize( idxSize );
        for(size_t i=0; i<idxSize; ++i)
        {
          buffer.read( indices_[i] );
          //std::cout << "P[" << MPIManager ::rank() << " read idx " << indices_[i] << std::endl;
        }
      }
 
      void compress()
      {
        size_t writePos = 0;
        const size_t idxSize = indices_.size();
        for(size_t i=0; i<idxSize; ++i)
        {
          if( indices_[ i ] != invalidIndex )
          {
            if( i != writePos )
              indices_[ writePos ] = indices_[ i ];
            writePos++;
          }
        }
        indices_.resize( writePos );
      }
 
    protected:
      inline void resize ( size_t size )
      {
        indices_.resize( size );
      }
 
      inline void reserve ( size_t size )
      {
        indices_.reserve( size );
      }
 
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_COMMINDEXMAP_HH