OperatorList.hpp

#pragma once

#include <list>
#include <memory>

#include <amdis/BoundarySubset.hpp>
#include <amdis/AssemblerInterface.hpp>
#include <amdis/typetree/TreeContainer.hpp>

namespace AMDiS
{
  namespace tag
  {
    template <class E> struct element_operator { using type = E; };
    template <class I> struct intersection_operator { using type = I; };
    template <class I> struct boundary_operator : public BoundarySubset<I>
    {
      using type = I;
      using BoundarySubset<I>::BoundarySubset;
    };
  }

  template <class GridView, class Container>
  class OperatorLists
  {
    using Element = typename GridView::template Codim<0>::Entity;
    using Intersection = typename GridView::Intersection;

    template <class Op>
    struct DataElement
    {
      std::shared_ptr<Op> op;
      BoundarySubset<Intersection> bs;
    };

    template <class... Nodes>
    struct Data
    {
      bool empty() const
      {
        return element_.empty() && boundary_.empty() && intersection_.empty();
      }

      bool doAssemble() const
      {
        return !assembled_ || changing_;
      }

      operator bool() const
      {
        return doAssemble() && !empty();
      }

      template <class Geo>
      void bind(Element const& elem, Geo const& geo)
      {
        for (auto& op : element_) op->bind(elem,geo);
        for (auto& op : intersection_) op->bind(elem,geo);
        for (auto& data : boundary_) data.op->bind(elem,geo);
      }

      void unbind()
      {
        for (auto& op : element_) op->unbind();
        for (auto& op : intersection_) op->unbind();
        for (auto& data : boundary_) data.op->unbind();
        assembled_ = true;
      }


      template <class Op>
      void push(tag::element_operator<Element>, Op&& op)
      {
        element_.emplace_back(FWD(op));
      }

      template <class Op>
      void push(tag::intersection_operator<Intersection>, Op&& op)
      {
        intersection_.emplace_back(FWD(op));
      }

      template <class Op>
      void push(tag::boundary_operator<Intersection> b, Op&& op)
      {
        boundary_.push_back({FWD(op), b});
      }


      auto&       onElement()       { return element_; }
      auto const& onElement() const { return element_; }

      auto&       onIntersection()       { return intersection_; }
      auto const& onIntersection() const { return intersection_; }

      auto&       onBoundary()       { return boundary_; }
      auto const& onBoundary() const { return boundary_; }

    private:
      using ElementTraits = DefaultAssemblerTraits<Element,Container>;
      using IntersectionTraits = DefaultAssemblerTraits<Intersection,Container>;

      using ElementAssembler = AssemblerInterface<ElementTraits, Nodes...>;

      using IntersectionAssembler = AssemblerInterface<IntersectionTraits, Nodes...>;

      std::vector<std::shared_ptr<ElementAssembler>> element_;

      std::vector<std::shared_ptr<IntersectionAssembler>> intersection_;

      std::vector<DataElement<IntersectionAssembler>> boundary_;

      bool assembled_ = false;

      bool changing_ = true;
    };

  public:

    template <class RowNode, class ColNode>
    using MatData = Data<RowNode, ColNode>;

    template <class Node>
    using VecData = Data<Node>;
  };


  template <class RowBasis, class ColBasis, class ElementMatrix>
  using MatrixOperators
    = TypeTree::TreeMatrix<
        OperatorLists<typename RowBasis::GridView,ElementMatrix>::template MatData,
        typename RowBasis::LocalView::TreeCache,
        typename ColBasis::LocalView::TreeCache>;

  template <class Basis, class ElementVector>
  using VectorOperators
    = TypeTree::TreeContainer<
        OperatorLists<typename Basis::GridView,ElementVector>::template VecData,
        typename Basis::LocalView::TreeCache>;

} // end namespace AMDiS