basesetlocalkeystorage.hh

Go to the documentation of this file.

#ifndef DUNE_FEM_BASESETLOCALKEYSTORAGE_HH
#define DUNE_FEM_BASESETLOCALKEYSTORAGE_HH
 
#include <utility>
 
#include <dune/common/exceptions.hh>
 
#include <dune/geometry/type.hh>
#include <dune/geometry/typeindex.hh>
 
#include <dune/fem/common/forloop.hh>
#include <dune/fem/space/common/allgeomtypes.hh>
#include <dune/fem/storage/singletonlist.hh>
 
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< class Entry >
    class BaseSetLocalKeyStorage
    {
      // interface class for factory
      class FactoryIF
      {
      protected:
        FactoryIF () {}
      public:
        virtual ~FactoryIF () {}
        virtual Entry* getObject( const GeometryType& geomType ) const = 0;
        virtual void removeObjects( std::vector<Entry*>& entryStorage ) const = 0;
        virtual FactoryIF* clone() const = 0;
      };
 
      // factory implementation depends on type of singleton provider
      template <class SingletonProvider>
      class FactoryImpl : public FactoryIF
      {
      public:
        FactoryImpl() {}
 
        Entry* getObject( const GeometryType& geomType ) const
        {
          return & SingletonProvider :: getObject( geomType );
        }
 
        void removeObjects( std::vector<Entry*>& entryStorage ) const
        {
          const size_t size = entryStorage.size();
          for( size_t i=0; i<size; ++i )
          {
            if( entryStorage[ i ] )
            {
              SingletonProvider :: removeObject( *(entryStorage[ i ]) );
              entryStorage[ i ] = 0 ;
            }
          }
        }
 
        virtual FactoryIF* clone() const { return new FactoryImpl<SingletonProvider> (); }
      };
 
      // pointer to apropriate factory
      const FactoryIF* factory_;
      // vector caching singleton pointers
      std::vector< Entry* > entryStorage_;
    public:
      // export value type confomring to std::vector
      typedef Entry value_type ;
 
      // default constructor
      BaseSetLocalKeyStorage()
        : factory_( 0 )
        , entryStorage_()
      {}
 
      BaseSetLocalKeyStorage( const BaseSetLocalKeyStorage& other )
        : factory_( other.factory_ ? other.factory_->clone() : 0 )
        , entryStorage_( other.entryStorage_.size(), ( Entry * ) 0 )
      {
        // make a copy of the vector
        const size_t size = entryStorage_.size();
        for( size_t i=0; i<size; ++i )
        {
          Entry* otherEntry = other.entryStorage_[ i ];
          if( otherEntry )
          {
            // we need the interface method geometry
            // (on base function sets and compiled local keys )
            entryStorage_[ i ] = factory_->getObject( otherEntry->type() );
          }
        }
      }
 
      BaseSetLocalKeyStorage ( BaseSetLocalKeyStorage &&other )
        : factory_( other.factory_ ),
          entryStorage_( std::move( other.entryStorage_ ) )
      {
        other.factory_ = nullptr;
        other.entryStorage_.clear();
      }
 
      ~BaseSetLocalKeyStorage()
      {
        if( entryStorage_.size() > 0 )
        {
          factory_->removeObjects( entryStorage_ );
        }
 
        delete factory_;
        factory_ = 0;
      }
 
      // get maxSize of compiled keys
      unsigned int maxSize() const
      {
        unsigned int maxSize = 0;
        const size_t size = entryStorage_.size() ;
        for( size_t i=0; i<size; ++i)
        {
          if( entryStorage_[ i ] )
          {
            unsigned int enSize = entryStorage_[ i ]->size();
            maxSize = std::max( enSize , maxSize );
          }
        }
        return maxSize;
      }
 
      template <class SingletonProvider>
      bool insert( const GeometryType geomType )
      {
        // create factory if not existing yet
        if( factory_ == 0 )
        {
          factory_ = new FactoryImpl< SingletonProvider > ();
        }
 
        // check that type of factory is correct
        assert( dynamic_cast< const FactoryImpl< SingletonProvider >* > ( factory_ ) != 0 );
 
        // get geometry type index
        const size_t geomIndex = index( geomType ) ;
 
        if( entryStorage_.size() <= geomIndex )
          entryStorage_.resize( geomIndex + 1, (Entry* ) 0 );
 
        assert( geomIndex < entryStorage_.size() );
 
        // if entry is still not used, insert it
        if( entryStorage_[ geomIndex ] == 0 )
        {
          entryStorage_[ geomIndex ] = factory_->getObject( geomType );
          return true ;
        }
        return false ;
      }
 
      bool exists( const GeometryType& geomType ) const
      {
        if( index( geomType ) < static_cast< int >( entryStorage_.size() ) )
          return (entryStorage_[ index( geomType ) ] != 0) ;
        else
          return false;
      }
 
      const Entry& operator [] ( const GeometryType& geomType ) const
      {
        // assert( factory_ );
        assert( index( geomType ) < static_cast< int >( entryStorage_.size() ) );
        assert( entryStorage_[ index( geomType ) ] != 0 );
        return *( entryStorage_[ index( geomType ) ]);
      }
    protected:
      int index( const GeometryType& geomType ) const
      {
        return LocalGeometryTypeIndex::index( geomType );
      }
    };
 
 
 
    template< class CompiledLocalKey, unsigned int minPolOrder, unsigned int maxPolOrder >
    class CompiledLocalKeyContainer
    {
    public:
      // type of compiled local key
      typedef CompiledLocalKey CompiledLocalKeyType;
 
      typedef BaseSetLocalKeyStorage< CompiledLocalKeyType > LocalKeyStorageType;
 
      // vector containing storages for each polynomial order
      typedef std::vector< LocalKeyStorageType > LocalKeyVectorType;
 
    protected:
      enum { numOrders = maxPolOrder - minPolOrder + 1 };
 
      template <int pOrd>
      struct ConstructCompiledLocalKeys
      {
        class CompiledLocalKeyFactory
        {
        public:
          static CompiledLocalKeyType* createObject( const GeometryType& type )
          {
            return new CompiledLocalKeyType( type, pOrd );
          }
 
          static void deleteObject( CompiledLocalKeyType* obj )
          {
            delete obj;
          }
        };
 
        static void apply( LocalKeyVectorType& compiledLocalKeys,
                           const GeometryType& geometryType )
        {
          const size_t k = pOrd ;
 
          typedef SingletonList
            < GeometryType, CompiledLocalKeyType, CompiledLocalKeyFactory >
            CompiledLocalKeySingletonProviderType;
 
          // insert compiled local key
          compiledLocalKeys[ k - minPolOrder ].template insert< CompiledLocalKeySingletonProviderType > ( geometryType );
        }
      };
 
    protected:
      // all lagrange point sets for available geometry types
      LocalKeyVectorType compiledLocalKeys_ ;
 
    private:
      CompiledLocalKeyContainer( const CompiledLocalKeyContainer& );
 
    public:
      template <class GridPart>
      CompiledLocalKeyContainer( const GridPart& gridPart )
        : compiledLocalKeys_( numOrders )
      {
        typedef typename GridPart :: IndexSetType IndexSetType ;
        typedef typename GridPart :: GridType  GridType ;
        const IndexSetType &indexSet = gridPart.indexSet();
 
        // get all available geometry types
        AllGeomTypes< IndexSetType, GridType > allGeometryTypes( indexSet );
        const std :: vector< GeometryType >& geometryTypes
          = allGeometryTypes.geomTypes( 0 );
 
        // create compiled local keys
        for( unsigned int i = 0; i < geometryTypes.size(); ++i )
        {
          Fem::ForLoop< ConstructCompiledLocalKeys, minPolOrder, maxPolOrder > ::
              apply( compiledLocalKeys_, geometryTypes[ i ] );
        }
      }
 
      inline const LocalKeyStorageType& compiledLocalKeys( const int order ) const
      {
        assert( order - minPolOrder >= 0 );
        assert( int( order - minPolOrder ) < int( compiledLocalKeys_.size() ) );
        return compiledLocalKeys_[ order - minPolOrder ];
      }
 
      inline const CompiledLocalKeyType &compiledLocalKey( const GeometryType& type, const int order ) const
      {
        return compiledLocalKeys( order )[ type ];
      }
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // DUNE_FEM_BASESETLOCALKEYSTORAGE_HH