BoundaryOperator.hpp

#pragma once
 
#include <amdis/BoundarySubset.hpp>
#include <amdis/ContextGeometry.hpp>
 
namespace AMDiS
{
  template <class LocalOperator, class Intersection>
  class BoundaryLocalOperator
  {
  public:
    BoundaryLocalOperator(LocalOperator lop, BoundarySubset<Intersection> bs)
      : lop_(std::move(lop))
      , bs_(std::move(bs))
    {}
 
    template <class Element>
    void bind(Element const& element)
    {
      if ((bound_ = element.hasBoundaryIntersections(), bound_))
        lop_.bind(element);
    }
 
    void unbind()
    {
      if (bound_) {
        lop_.unbind();
        bound_ = false;
      }
    }
 
    template <class... Args>
    void assemble(ContextGeometry<Intersection> const& cg, Args&&... args) const
    {
      if (bound_ && bs_(cg.context()))
        lop_.assemble(cg,FWD(args)...);
    }
 
  private:
    LocalOperator lop_;
    BoundarySubset<Intersection> bs_;
    bool bound_ = false;
  };
 
 
  template <class Operator, class Intersection>
  class BoundaryOperator
  {
  public:
    BoundaryOperator(Operator op, BoundarySubset<Intersection> bs)
      : op_(std::move(op))
      , bs_(std::move(bs))
    {}
 
    template <class GridView>
    void update(GridView const& gridView)
    {
      op_.update(gridView);
    }
 
    friend auto localOperator(BoundaryOperator const& bop)
    {
      return BoundaryLocalOperator{localOperator(bop.op_), bop.bs_};
    }
 
  private:
    Operator op_;
    BoundarySubset<Intersection> bs_;
  };
 
} // end namespace AMDiS