dofmappertupledatahandle.hh

#ifndef __DUNE_ACFEM_DOFMAPPERTUPLEDATAHANDLE_HH__
#define __DUNE_ACFEM_DOFMAPPERTUPLEDATAHANDLE_HH__
 
#include <dune/grid/common/datahandleif.hh>
 
#include "containertuple.hh"
 
namespace Dune  {
 
  namespace ACFem {
 
    template<class... Storages>
    struct DofMapperTupleDataHandleTraits
    {
      typedef ContainerTuple<Storages...> StorageType;
      typedef typename StorageType::ConstValueType DataItemType;
      typedef typename StorageType::ValueType DataItemScatterType;
    };
 
    template<class Mapper, class Operation, class... Storages>
    class DofMapperTupleDataHandle
      : public CommDataHandleIF<DofMapperTupleDataHandle<Mapper, Operation, Storages...>,
                                typename DofMapperTupleDataHandleTraits<Storages...>::DataItemType>
    {
    public:
      typedef Mapper MapperType;
      typedef Operation OperationType;
     private:
      typedef DofMapperTupleDataHandleTraits<Storages...> TraitsType;
      typedef typename TraitsType::DataItemType DataItemType;
      typedef typename TraitsType::DataItemScatterType DataItemScatterType;
      typedef ContainerTuple<Storages...> StorageTupleType;
     public:
      DofMapperTupleDataHandle(const MapperType& mapper,
                               const Operation& operation,
                               Storages&... storages)
        : mapper_(mapper), operation_(operation), storages_(storages...)
      {}
 
      DofMapperTupleDataHandle(const DofMapperTupleDataHandle& other)
        : mapper_(other.mapper_), operation_(other.operation_), storages_(other.storages_)
      {}
 
      bool contains(int dim, int codim) const
      {
        return mapper_.contains(codim);
      }
 
      bool fixedSize(int dim, int codim) const
      {
        return false;
      }
 
      template<class Entity>
      size_t size(const Entity& entity) const
      {
        return mapper_.numEntityDofs(entity);
      }
 
      template<class MessageBuffer, class Entity>
      void gather(MessageBuffer& buff, const Entity& entity) const
      {
        size_t localBlocks = mapper_.numEntityDofs(entity);
        std::vector<std::size_t> globalBlockDofs(localBlocks);
        mapper_.mapEntityDofs(entity, globalBlockDofs);
        assert(size(entity) == globalBlockDofs.size());
        for (size_t localBlock = 0; localBlock < globalBlockDofs.size(); ++ localBlock) {
          buff.write(storages_[globalBlockDofs[localBlock]]);
        }
      }
 
      template<class MessageBuffer, class Entity>
      void scatter(MessageBuffer& buff, const Entity& entity, size_t n)
      {
        size_t localBlocks = mapper_.numEntityDofs(entity);
        std::vector<std::size_t> globalBlockDofs(localBlocks);
        mapper_.mapEntityDofs(entity, globalBlockDofs);
        assert(size(entity) == n);
        assert(size(entity) == globalBlockDofs.size());
        for (size_t localBlock = 0; localBlock < globalBlockDofs.size(); ++ localBlock) {
          DataItemType src;
          buff.read(src);
          // We need the variable dest, because if one of the
          // tuple-components uses Fem::SubVector as blocks then dest
          // must contain a non-const copy of the block. Hence we
          // cannot pass dest as a const argument to operation_(), but
          // then without dest we would pass a non-const rvalue
          // reference as an lvalue reference to operation_() which is
          // not allowed.
          auto dest = storages_[globalBlockDofs[localBlock]];
          operation_(src, dest);
        }
      }
 
     private:
      const MapperType& mapper_;
      const Operation operation_;
      StorageTupleType storages_;
    };
 
    template<class Space, class Operation, class... Storages,
             std::enable_if_t<sizeof(typename Space::BlockMapperType) >= 0, int> = 0>
    auto dofMapperTupleDataHandle(const Space& space,
                                  const Operation& operation,
                                  Storages&... storages)
    {
      typedef DofMapperTupleDataHandle<typename Space::BlockMapperType, Operation, Storages...> ResultType;
      return ResultType(space.blockMapper(), operation, storages...);
    }
 
  } // namespace ACFem
 
} // namespace Dune
 
 
#endif // __DUNE_ACFEM_DOFMAPPERTUPLEDATAHANDLE_HH__