localfunction.hh

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <type_traits>
#include <vector>
 
#include <dune/common/concept.hh>
#include <dune/common/referencehelper.hh>
#include <dune/common/typetraits.hh>
#include <dune/vtk/gridfunctions/rangeproxy.hh>
 
namespace Dune::Vtk {
namespace Impl {
 
template <class ElementType, class ComponentMapperType>
struct LocalFunctionDefinition
{
  using Element = ElementType;
  using ComponentMapper = ComponentMapperType;
  using Domain = typename Element::Geometry::LocalCoordinate;
 
  // Definition of the interface a LocalFunction must fulfill
  struct Interface
  {
    virtual ~Interface() = default;
    virtual Interface* clone () const = 0;
    virtual void bind(Element const&) = 0;
    virtual void unbind() = 0;
    virtual double evaluate (int, Domain const&) const = 0;
  };
 
  // Templatized implementation of the interface
  template <class Impl>
  struct Model : public Interface
  {
    template <class I, disableCopyMove<Model,I> = 0>
    Model(I&& impl) : impl_(std::forward<I>(impl)) {}
    Model* clone() const final { return new Model(*this); }
    auto& impl() { return resolveRef(impl_); }
    const auto& impl() const { return resolveRef(impl_); }
 
    void bind(Element const& e) final { impl().bind(e); }
    void unbind() final { impl().unbind(); }
    double evaluate(int i, Domain const& x) const final {
      return ComponentMapper::map(i, x, impl()); }
 
  private:
    Impl impl_;
  };
 
  // The Concept definition of a LocalFunction
  struct Concept
  {
    template <class LOp>
    auto require(LOp&& lop) -> decltype
    (
      lop.bind(std::declval<Element>()),
      lop.unbind()
    );
  };
};
 
} // end namespace Impl
 
 
 
 
  template <class Element, class ComponentMapper>
  class LocalFunction
  {
    using Definition = Impl::LocalFunctionDefinition<Element,ComponentMapper>;
    using Interface = typename Definition::Interface;
    using Domain = typename Definition::Domain;
 
    template <class LF>
    using Model = typename Definition::template Model<std::remove_reference_t<LF>>;
 
  public:
    template <class LF>
    LocalFunction (LF&& lf, std::vector<int> components)
      : interface_(std::make_unique<Model<LF>>(std::forward<LF>(lf)))
      , components_(std::move(components))
    {
      static_assert(models<typename Definition::Concept,ResolveRef_t<LF>>(),
        "Implementation does not model the LocalFunction concept.");
    }
 
    LocalFunction () = default;
 
    LocalFunction (LocalFunction&&) = default;
 
    LocalFunction& operator= (LocalFunction&&) = default;
 
    LocalFunction (const LocalFunction& other)
      : interface_(other.interface_ ? other.interface_->clone() : nullptr)
      , components_(other.components_)
    {}
 
    LocalFunction& operator= (const LocalFunction& other)
    {
      return *this = LocalFunction(other);
    }
 
    void bind (Element const& element)
    {
      interface_->bind(element);
    }
 
    void unbind ()
    {
      interface_->unbind();
    }
 
    Impl::RangeProxy<LocalFunction,Domain> operator() (Domain const& x) const
    {
      return {this, x};
    }
 
    double evaluate (int i, Domain const& x) const
    {
      return i < int(components_.size()) ? interface_->evaluate(components_[i], x) : 0.0;
    }
 
    const std::vector<int>& components () const
    {
      return components_;
    }
 
    void setComponents (std::vector<int> components)
    {
      components_ = std::move(components);
    }
 
  private:
    std::unique_ptr<Interface> interface_;
    std::vector<int> components_{};
  };
 
} // end namespace Dune::Vtk