LocalOperator.hpp

#pragma once
 
#include <type_traits>
 
#include <dune/functions/common/typeerasure.hh>
 
#include <amdis/ContextGeometry.hpp>
#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/TypeTraits.hpp>
 
namespace AMDiS {
namespace Impl {
 
template <class Traits, class... Nodes>
struct LocalOperatorDefinition
{
  using MatVec = typename Traits::ElementContainer;
  using CG = ContextGeometry<typename Traits::LocalContext>;
  using Element = typename CG::Element;
 
  // Definition of the interface a LocalOperator must fulfill
  struct Interface
  {
    virtual ~Interface() = default;
    virtual void bind(Element const&) = 0;
    virtual void unbind() = 0;
    virtual void assemble(CG const&, Nodes const&..., MatVec&) const = 0;
  };
 
  // Templatized implementation of the interface
  template <class Impl>
  struct Model : public Impl
  {
    using Impl::Impl;
    void bind(Element const& e) final { this->get().bind(e); }
    void unbind() final { this->get().unbind(); }
    void assemble(CG const& cg, Nodes const&... ns, MatVec& mv) const final {
      this->get().assemble(cg,ns...,mv); }
  };
 
  // The Concept definition of a LocalOperator
  struct Concept
  {
    template <class LOp>
    auto require(LOp&& lop) -> decltype
    (
      lop.bind(std::declval<Element>()),
      lop.unbind(),
      lop.assemble(std::declval<CG>(), std::declval<Nodes>()..., std::declval<MatVec&>())
    );
  };
 
  using Base = Dune::Functions::TypeErasureBase<Interface, Model>;
};
 
} // end namespace Impl
 
 
 
template <class Traits, class... Nodes>
class LocalOperator
    : public Impl::LocalOperatorDefinition<Traits,Nodes...>::Base
{
  using Definition = Impl::LocalOperatorDefinition<Traits,Nodes...>;
  using Super = typename Definition::Base;
 
public:
  using MatVec = typename Traits::ElementContainer;
 
  using ContextGeo = ContextGeometry<typename Traits::LocalContext>;
 
  using Element = typename ContextGeo::Element;
 
public:
  template <class Impl, Dune::disableCopyMove<LocalOperator,Impl> = 0>
  LocalOperator(Impl&& impl)
    : Super{FWD(impl)}
  {
    static_assert(Concepts::models<typename Definition::Concept(Impl)>,
      "Implementation does not model the LocalOperator concept.");
  }
 
  LocalOperator() = default;
 
 
  void bind(Element const& element)
  {
    this->asInterface().bind(element);
  }
 
  void unbind()
  {
    this->asInterface().unbind();
  }
 
 
  void assemble(ContextGeo const& cg, Nodes const&... ns, MatVec& mv) const
  {
    this->asInterface().assemble(cg,ns...,mv);
  }
};
 
 
} // end namespace AMDiS