combineddofstorage.hh

#ifndef DUNE_FEM_COMBINEDDOFSTORAGE_HH
#define DUNE_FEM_COMBINEDDOFSTORAGE_HH
 
//- local includes
#include <dune/fem/space/common/dofstorage.hh>
#include <dune/fem/storage/subvector.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< class ContainedMapper, int N, DofStoragePolicy policy >
    class CombinedDofConversionUtility;
 
 
    template< class ContainedMapper , int N >
    class CombinedDofConversionUtility< ContainedMapper, N, PointBased >
    : public PointBasedDofConversionUtility< N >
    {
      typedef PointBasedDofConversionUtility< N >  BaseType;
 
    public:
      typedef ContainedMapper ContainedMapperType;
 
      CombinedDofConversionUtility ( const ContainedMapperType & mapper, const int numComponents )
      : BaseType( numComponents )
      {}
    };
 
    template< class ContainedMapper, int N >
    class CombinedDofConversionUtility< ContainedMapper, N, VariableBased >
    {
    public:
      typedef ContainedMapper ContainedMapperType;
 
      CombinedDofConversionUtility ( const ContainedMapperType &mapper, int size )
      : mapper_( mapper )
      {}
 
      static DofStoragePolicy policy ()
      {
        return VariableBased;
      }
 
      void newSize ( int size )
      {}
 
      int component ( int combinedIndex ) const
      {
        return combinedIndex / containedSize();
      }
 
      int containedDof ( int combinedIndex ) const
      {
        return combinedIndex % containedSize();
      }
 
      int combinedDof ( int containedIndex, int component ) const
      {
        return containedIndex + (component * containedSize());
      }
 
    protected:
      const ContainedMapperType &mapper_;
 
      int containedSize () const
      {
        return mapper_.size();
      }
    };
 
 
 
    template< class MapperImp, int N, DofStoragePolicy policy  >
    class CombinedSubMapper
    : public Fem :: IndexMapperInterface< CombinedSubMapper< MapperImp, N, policy > >
    {
      typedef CombinedSubMapper< MapperImp, N , policy > ThisType;
 
    public:
      // original mapper
      typedef MapperImp ContainedMapperType;
      typedef CombinedDofConversionUtility< ContainedMapperType, N, policy > DofConversionType;
 
      CombinedSubMapper ( const ContainedMapperType& mapper, unsigned int component )
      : mapper_( mapper ),
        component_( component ),
        utilGlobal_(mapper_, policy  == PointBased ? N : mapper.size() )
      {
        assert(component_ < N);
      }
 
      CombinedSubMapper(const ThisType& ) = default;
      CombinedSubMapper(ThisType&& ) = default;
      ThisType& operator=(const ThisType& ) = delete;
      ThisType& operator=(ThisType&& ) = delete;
 
      unsigned int size () const
      {
        return mapper_.size();
      }
 
      unsigned int range () const
      {
        return size() * N;
      }
 
      unsigned int operator[] ( unsigned int index ) const
      {
        utilGlobal_.newSize( mapper_.size() );
        return utilGlobal_.combinedDof(index, component_);
      }
 
    private:
      const ContainedMapperType& mapper_;
      const unsigned int component_;
      mutable DofConversionType utilGlobal_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_COMBINEDDOFSTORAGE_HH