intersectiondatahandle.hh

#ifndef __DUNE_ACFEM_INTERSECTIONDATAHANDLE_HH__
#define __DUNE_ACFEM_INTERSECTIONDATAHANDLE_HH__
 
#include <map>
#include <dune/common/version.hh>
#include <dune/grid/common/datahandleif.hh>
#include <dune/common/version.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;
     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 Entity>
      size_t size(const Entity& e) const
      {
        return storage_[indexSet_.index(e)].size();
      }
 
      template<class MessageBuffer, class Entity>
      void gather(MessageBuffer& buff, const Entity& e) const
      {
        for (const auto data : storage_[indexSet_.index(e)]) {
          buff.write(data);
        }
      }
 
      template<class MessageBuffer, class Entity>
      void scatter(MessageBuffer& buff, const Entity& e, size_t n)
      {
        assert(n == size(e));
        for (auto& data : storage_[indexSet_.index(e)]) {
          typename std::decay<decltype(data)>::type tmp;
          buff.read(tmp);
#if DUNE_VERSION_NEWER(DUNE_FEM, 2, 5)
          OperationType()(tmp, data);
#else
          OperationType::apply(tmp, data);
#endif
        }
      }
 
    private:
      const IndexSetType& indexSet_;
      CommunicationStorageType& storage_;
    };
 
  } // namespace ACFem
 
} // namespace Dune
 
 
#endif //  __DUNE_ACFEM_INTERSECTIONDATAHANDLE_HH__