Assembler.hpp

#pragma once

#include <functional>
#include <memory>
#include <type_traits>

#include <dune/common/shared_ptr.hh>
#include <dune/geometry/quadraturerules.hh>

#include <amdis/ContextGeometry.hpp>
#include <amdis/AssemblerInterface.hpp>
#include <amdis/common/Concepts.hpp>
#include <amdis/typetree/FiniteElementType.hpp>

namespace AMDiS
{

  template <class Traits, class Operator, class... Nodes>
  class Assembler
      : public AssemblerInterface<Traits, Nodes...>
  {
    using Super = AssemblerInterface<Traits, Nodes...>;

    using LocalContext = typename Traits::LocalContext;
    using Element = typename Super::Element;
    using Geometry = typename Super::Geometry;
    using ElementContainer = typename Traits::ElementContainer;

  public:

    explicit Assembler(Operator const& op)
      : op_(Dune::wrap_or_move(op))
    {}

    explicit Assembler(Operator&& op)
      : op_(Dune::wrap_or_move(std::move(op)))
    {}

    explicit Assembler(std::reference_wrapper<Operator> op)
      : op_(Dune::wrap_or_move(op.get()))
    {}


    void bind(Element const& element, Geometry const& geometry) final
    {
      element_ = &element;
      geometry_ = &geometry;
      op_->bind(element, geometry);
    }


    void unbind() final
    {
      op_->unbind();
      geometry_ = nullptr;
      element_ = nullptr;
    }


    void assemble(LocalContext const& localContext, Nodes const&... nodes,
                  ElementContainer& ElementContainer) final
    {
      ContextGeometry<LocalContext> contextGeo{localContext, element(), geometry()};
      assembleImpl(contextGeo, nodes..., ElementContainer);
    }


#ifndef DOXYGEN

  protected: // implementation detail

    // matrix assembling
    template <class CG, class RN, class CN, class Mat>
    void assembleImpl(CG const& contextGeo, RN const& rowNode, CN const& colNode, Mat& elementMatrix)
    {
      op_->calculateElementMatrix(contextGeo, rowNode, colNode, elementMatrix);
    }

    // vector assembling
    template <class CG, class Node, class Vec>
    void assembleImpl(CG const& contextGeo, Node const& node, Vec& elementVector)
    {
      op_->calculateElementVector(contextGeo, node, elementVector);
    }

#endif // DOXYGEN

  public:

    Element const& element() const
    {
      assert( element_ );
      return *element_;
    }

    Geometry const& geometry() const
    {
      assert( geometry_ );
      return *geometry_;
    }


  private:

    std::shared_ptr<Operator> op_;

    Element const* element_ = nullptr;
    Geometry const* geometry_ = nullptr;
  };


  template <class Traits, class Operator, class... Nodes>
  auto makeAssembler(Operator&& op, Nodes const&...)
  {
    return Assembler<Traits, Underlying_t<Operator>, Nodes...>{FWD(op)};
  }

} // end namespace AMDiS