BoundarySubset.hpp

#pragma once
 
#include <functional>
 
#include <amdis/Boundary.hpp>
#include <amdis/BoundaryManager.hpp>
#include <amdis/ContextGeometry.hpp>
#include <amdis/common/Concepts.hpp>
#include <amdis/common/ConceptsBase.hpp>
 
namespace AMDiS
{
 
  template <class IS>
  class BoundarySubset
  {
    using Domain = typename IS::GlobalCoordinate;
 
  public:
    using Intersection = IS;
 
    BoundarySubset()
      : predicate_([](Intersection const& is) -> bool { return is.boundary(); })
    {}
 
    template <class G>
    BoundarySubset(std::shared_ptr<BoundaryManager<G>> const& boundaryManager, BoundaryType id)
      : predicate_([boundaryManager, id](Intersection const& is) -> bool {
                     return is.boundary() && boundaryManager->boundaryId(is) == id;
                     })
    {}
 
    template <class G>
    BoundarySubset(BoundaryManager<G>& boundaryManager, BoundaryType id)
      : BoundarySubset{Dune::stackobject_to_shared_ptr(boundaryManager), id}
    {}
 
    template <class Predicate,
      REQUIRES(Concepts::Functor<Predicate, bool(Domain)>)>
    BoundarySubset(Predicate&& predicate)
      : predicate_([predicate](Intersection const& is) -> bool {
                     return predicate(is.geometry().center());
                     })
    {}
 
    bool operator()(Intersection const& is) const
    {
      return predicate_(is);
    }
 
  protected:
    std::function<bool(Intersection const&)> predicate_;
  };
 
  template <class Grid>
  BoundarySubset(std::shared_ptr<BoundaryManager<Grid>>, BoundaryType)
    -> BoundarySubset<typename Grid::LeafIntersection>;
 
  template <class Grid>
  BoundarySubset(BoundaryManager<Grid>&, BoundaryType)
    -> BoundarySubset<typename Grid::LeafIntersection>;
 
 
  template <class I>
  struct Impl::ContextTagType<BoundarySubset<I>>
  {
    using type = I;
  };
 
} // end namespace AMDiS