intersectiondatahandle.hh

#ifndef __DUNE_ACFEM_INTERSECTIONDATAHANDLE_HH__
#define __DUNE_ACFEM_INTERSECTIONDATAHANDLE_HH__
 
#include <map>
#include <dune/grid/common/datahandleif.hh>
 
namespace Dune  {
 
  namespace ACFem {
 
    template<class Storage>
    struct IntersectionDataHandleTraits
    {
      typedef Storage StorageType;
      typedef typename StorageType::value_type IntersectionStorageType;
      typedef typename IntersectionStorageType::value_type DataItemType;
    };
 
    template<class Key, class IntersectionStorage, class... Further>
    struct IntersectionDataHandleTraits<std::map<Key, IntersectionStorage, Further...> >
    {
      typedef std::map<Key, IntersectionStorage, Further...> StorageType;
      typedef IntersectionStorage IntersectionStorageType;
      typedef typename IntersectionStorageType::value_type DataItemType;
    };
 
    template<class IndexSet, class Storage, class Operation>
    class IntersectionDataHandle
      : public CommDataHandleIF<IntersectionDataHandle<IndexSet, Storage, Operation>,
                                typename IntersectionDataHandleTraits<Storage>::DataItemType>
    {
    public:
      typedef IndexSet IndexSetType;
      typedef Storage CommunicationStorageType;
     private:
      typedef IntersectionDataHandleTraits<Storage> TraitsType;
      typedef typename TraitsType::IntersectionStorageType IntersectionStorageType;
      typedef typename TraitsType::DataItemType DataItemType;
      typedef Operation OperationType;
      typedef typename IndexSetType::IndexType IndexType;
     public:
 
      IntersectionDataHandle(const IndexSetType& idxSet, CommunicationStorageType& storage)
        : indexSet_(idxSet), storage_(storage)
      {}
 
      IntersectionDataHandle(const IntersectionDataHandle& other)
        : indexSet_(other.indexSet_), storage_(other.storage_)
      {}
 
      bool contains(int dim, int codim) const
      {
        return codim == 1;
      }
 
      bool fixedsize(int dim, int codim) const
      {
        return false;
      }
 
      template<class EntityType>
      size_t size(EntityType& e) const
      {
        IndexType idx = indexSet_.index(e);
        return storage_[idx].size();
      }
 
      template<class MessageBuffer, class EntityType>
      void gather(MessageBuffer& buff, const EntityType& e) const
      {
        IndexType idx = indexSet_.index(e);
 
        const auto& intersectionStorage(storage_[idx]);
        const auto end = intersectionStorage.end();
        for (auto it = intersectionStorage.begin(); it != end; ++it) {
          buff.write(*it);
        }
      }
 
      template<class MessageBuffer, class EntityType>
      void scatter(MessageBuffer& buff, const EntityType& e, size_t n)
      {
        assert(n == size(e));
 
        int idx = indexSet_.index(e);
        auto& intersectionStorage(storage_[idx]);
        const auto end = intersectionStorage.end();
        for (auto it = intersectionStorage.begin(); it != end; ++it) {
          DataItemType tmp;
          buff.read(tmp);
#if DUNE_VERSION_NEWER(DUNE_FEM, 2, 5)
          OperationType()(tmp, *it);
#else
          OperationType::apply(tmp, *it);
#endif
        }
      }
 
    private:
      const IndexSetType& indexSet_;
      CommunicationStorageType& storage_;
    };
 
  } // namespace ACFem
 
} // namespace Dune
 
 
#endif //  __DUNE_ACFEM_INTERSECTIONDATAHANDLE_HH__