persistentcontainer.hh

#ifndef DUNE_MMESH_MISC_PERSISTENTCONTAINER_HH
#define DUNE_MMESH_MISC_PERSISTENTCONTAINER_HH
 
#include <dune/grid/utility/persistentcontainer.hh>
#include <dune/grid/utility/persistentcontainermap.hh>
#include <unordered_map>
 
namespace Dune {
 
template <class HostGrid, int dim, class T>
class PersistentContainer<MMesh<HostGrid, dim>, T>
    : public Dune::PersistentContainerMap<
          MMesh<HostGrid, dim>, typename MMesh<HostGrid, dim>::LocalIdSet,
          std::unordered_map<typename MMesh<HostGrid, dim>::LocalIdSet::IdType,
                             T> > {
  typedef MMesh<HostGrid, dim> G;
  typedef PersistentContainerMap<
      G, typename G::LocalIdSet,
      std::unordered_map<typename G::LocalIdSet::IdType, T> >
      Base;
  typedef typename MMesh<HostGrid, dim>::LocalIdSet IdSet;
  typedef std::unordered_map<typename MMesh<HostGrid, dim>::LocalIdSet::IdType,
                             T>
      Map;
 
 public:
  typedef typename Base::Grid Grid;
  typedef typename Base::Value Value;
 
  PersistentContainer(const Grid &grid, int codim, const Value &value = Value())
      : Base(grid, codim, grid.localIdSet(), value) {}
 
  using Base::codimension;
  using Base::migrateLevel;
 
  void resize(const Value &value = Value()) {
    if (sequence_ != this->grid_->sequence()) {
      Hybrid::forEach(std::make_index_sequence<Grid::dimension + 1>{},
                      [&](auto i) {
                        if (i == this->codimension())
                          this->template resize<i>(value);
                      });
      sequence_ = this->grid_->sequence();
    }
  }
 
  template <int codim>
  void resize(const Value &value) {
    std::integral_constant<bool, Capabilities::hasEntity<Grid, codim>::v>
        hasEntity;
    assert(codim == codimension());
 
    // add one id for caching entity during adaptation
    if constexpr (codim == 0) {
      MMeshImpl::MultiId id(
          {std::size_t(-4), std::size_t(-3), std::size_t(-2)});
      this->data_.insert(std::make_pair(id, value));
    }
 
    // add one id for a every caching codim 1 entity during adaptation
    if constexpr (codim == 1) {
      MMeshImpl::MultiId eid0({std::size_t(-4), std::size_t(-3)});
      this->data_.insert(std::make_pair(eid0, value));
      MMeshImpl::MultiId eid1({std::size_t(-4), std::size_t(-2)});
      this->data_.insert(std::make_pair(eid1, value));
      MMeshImpl::MultiId eid2({std::size_t(-3), std::size_t(-2)});
      this->data_.insert(std::make_pair(eid2, value));
    }
 
    // add one id for every caching vertex during adaptation
    if constexpr (codim == dim) {
      MMeshImpl::MultiId vid0(std::size_t(-4));
      this->data_.insert(std::make_pair(vid0, value));
      MMeshImpl::MultiId vid1(std::size_t(-3));
      this->data_.insert(std::make_pair(vid1, value));
      MMeshImpl::MultiId vid2(std::size_t(-2));
      this->data_.insert(std::make_pair(vid2, value));
    }
 
    // create empty map, but keep old data
    Map data;
 
    // add new entries
    this->template migrateLevel<codim>(0, value, data, hasEntity);
  }
 
 private:
  int sequence_ = -1;
};
 
template <class MMesh, class T>
class PersistentContainer<MMeshInterfaceGrid<MMesh>, T>
    : public Dune::PersistentContainerMap<
          MMeshInterfaceGrid<MMesh>,
          typename MMeshInterfaceGrid<MMesh>::LocalIdSet,
          std::unordered_map<
              typename MMeshInterfaceGrid<MMesh>::LocalIdSet::IdType, T> > {
  typedef MMeshInterfaceGrid<MMesh> G;
  typedef PersistentContainerMap<
      G, typename G::LocalIdSet,
      std::unordered_map<typename G::LocalIdSet::IdType, T> >
      Base;
  typedef typename MMeshInterfaceGrid<MMesh>::LocalIdSet IdSet;
  typedef std::unordered_map<
      typename MMeshInterfaceGrid<MMesh>::LocalIdSet::IdType, T>
      Map;
  static constexpr int dim = MMesh::dimensionworld - 1;
 
 public:
  typedef typename Base::Grid Grid;
  typedef typename Base::Value Value;
 
  PersistentContainer(const Grid &grid, int codim, const Value &value = Value())
      : Base(grid, codim, grid.localIdSet(), value) {}
 
  using Base::codimension;
  using Base::migrateLevel;
 
  void resize(const Value &value = Value()) {
    if (sequence_ != this->grid_->sequence()) {
      Hybrid::forEach(std::make_index_sequence<Grid::dimension + 1>{},
                      [&](auto i) {
                        if (i == this->codimension())
                          this->template resize<i>(value);
                      });
      sequence_ = this->grid_->sequence();
    }
  }
 
  template <int codim>
  void resize(const Value &value) {
    std::integral_constant<bool, Capabilities::hasEntity<Grid, codim>::v>
        hasEntity;
    assert(codim == codimension());
 
    // add one id for caching entity during adaptation
    if constexpr (codim == 0) {
      MMeshImpl::MultiId id({std::size_t(-3), std::size_t(-2)});
      this->data_.insert(std::make_pair(id, value));
    }
 
    // add one id for every caching vertex during adaptation
    if constexpr (codim == dim) {
      MMeshImpl::MultiId vid0(std::size_t(-3));
      this->data_.insert(std::make_pair(vid0, value));
      MMeshImpl::MultiId vid1(std::size_t(-2));
      this->data_.insert(std::make_pair(vid1, value));
    }
 
    // create empty map, but keep old data
    Map data;
 
    // add new entries
    this->template migrateLevel<codim>(0, value, data, hasEntity);
  }
 
 private:
  int sequence_ = -1;
};
 
}  // namespace Dune
 
#endif  // #ifndef DUNE_MMESH_MISC_PERSISTENTCONTAINER_HH