iteratorsplit.hh

Go to the documentation of this file.

#ifndef DUNE_PDELAB_COMMON_PARTITION_ITERATORSPLIT_HH
#define DUNE_PDELAB_COMMON_PARTITION_ITERATORSPLIT_HH
 
#include <dune/pdelab/common/partition/halo/region.hh>
#include <dune/pdelab/common/partition/halo/colored.hh>
#include <dune/pdelab/common/partition/halo/uncolored.hh>
 
#include <dune/grid/common/gridenums.hh>
#include <dune/grid/concepts/gridview.hh>
 
#include <dune/common/iteratorrange.hh>
 
#include <vector>
#include <memory>
#include <array>
#include <algorithm>
 
namespace Dune::PDELab::EntitySetPartition {
 
namespace Impl {
 
template<Dune::Concept::GridView ES>
class IteratorSplitMixin {
public:
  using EntitySet = ES;
  using Element = typename EntitySet::template Codim<0>::Entity;
  using PatchSet = IteratorRange<typename EntitySet::template Codim<0>::Iterator>;
  using LabelSet = std::vector<PatchSet>;
  using PartitionSet = std::array<LabelSet,1>;
 
  explicit IteratorSplitMixin(const EntitySet& entity_set, std::size_t patches)
    : _entity_set{entity_set}
    , _patches{patches}
  {
    update(entity_set);
  }
 
  [[nodiscard]] auto entitySet() const noexcept { return _entity_set; }
 
  [[nodiscard]] auto begin() const {
    return _partition_set->begin();
  }
 
  [[nodiscard]] auto end() const {
    return _partition_set->end();
  }
 
protected:
  void update(EntitySet entity_set) {
    _entity_set = entity_set;
 
    if (_patches == 0) {
      std::size_t entities_per_patch = 100;
      switch(EntitySet::dimension) {
        case 1: entities_per_patch = 125; break;
        case 2: entities_per_patch = 250; break;
        default: entities_per_patch = 500; break;
      }
      _patches = std::max<std::size_t>(1, entity_set.size(0) / entities_per_patch);
    }
 
    PartitionSet partition_set;
    partition_set[0].clear();
    partition_set[0].reserve(_patches);
 
    auto begin_it = _entity_set.template begin<0>();
    auto end_it = _entity_set.template end<0>();
    auto dist = std::distance(begin_it, end_it);
    auto chunk = dist / _patches;
    auto remainder = dist % _patches;
 
    for (size_t i = 0; i < _patches-1; ++i) {
      auto next_end = std::next(begin_it, chunk + (remainder ? 1 : 0));
      partition_set[0].emplace_back(begin_it, next_end);
 
      begin_it = next_end;
      if (remainder) remainder -= 1;
    }
 
    // last chunk
    partition_set[0].emplace_back(begin_it, end_it);
    _partition_set = std::make_shared<PartitionSet>(std::move(partition_set));
  }
 
private:
  std::shared_ptr<PartitionSet> _partition_set;
  EntitySet _entity_set;
  std::size_t _patches;
};
 
} // namespace Impl
 
template<Dune::Concept::GridView EntitySet>
struct IteratorSplit
  : public Impl::IteratorSplitMixin<EntitySet>
  , public Impl::UncoloredHaloMixin<EntitySet>
{
 
  explicit IteratorSplit(const EntitySet& entity_set, std::size_t patches = 0, std::size_t halo_distance = all_interior_halo_region)
   : Impl::IteratorSplitMixin<EntitySet>{entity_set, patches}
   , Impl::UncoloredHaloMixin<EntitySet>::UncoloredHaloMixin{halo_distance}
  {
    Impl::UncoloredHaloMixin<EntitySet>::updateHalo(*this);
  }
 
  void update(const EntitySet& entity_set) {
    Impl::IteratorSplitMixin<EntitySet>::update(entity_set);
    Impl::UncoloredHaloMixin<EntitySet>::updateHalo(*this);
  }
};
 
template<Dune::Concept::GridView EntitySet>
struct IteratorSplitColored
  : public Impl::ColoredHaloAdaptor<Impl::IteratorSplitMixin<EntitySet>>
{
  explicit IteratorSplitColored(const EntitySet& entity_set, std::size_t patches = 0, std::size_t halo_distance = all_interior_halo_region)
    : Impl::ColoredHaloAdaptor<Impl::IteratorSplitMixin<EntitySet>>{Impl::IteratorSplitMixin<EntitySet>{entity_set, patches}, halo_distance}
    , _patches{patches}
  {}
 
  void update(const EntitySet& entity_set) {
    Impl::IteratorSplitMixin<EntitySet> base(entity_set, _patches);
    Impl::ColoredHaloAdaptor<Impl::IteratorSplitMixin<EntitySet>>::update(std::move(base));
  }
 
private:
  std::size_t _patches;
};
 
} // namespace Dune::PDELab::EntitySetPartition
 
#endif // DUNE_PDELAB_COMMON_PARTITION_ITERATORSPLIT_HH