virtualinterface.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_LOCALFUNCTIONS_COMMON_VIRTUALINTERFACE_HH
#define DUNE_LOCALFUNCTIONS_COMMON_VIRTUALINTERFACE_HH
 
#include <type_traits>
#include <array>
#include <vector>
 
#include <dune/common/function.hh>
 
#include <dune/geometry/type.hh>
 
#include <dune/localfunctions/common/localbasis.hh>
#include <dune/localfunctions/common/localinterpolation.hh>
#include <dune/localfunctions/common/localkey.hh>
#include <dune/localfunctions/common/localfiniteelementtraits.hh>
 
namespace Dune
{
 
  // forward declaration needed by the helper traits
  template<class DomainType, class RangeType>
  class LocalInterpolationVirtualInterface;
 
  // -----------------------------------------------------------------
  // Helper traits classes
  // -----------------------------------------------------------------
 
  template<class FE>
  class LocalFiniteElementFunctionBase
  {
    typedef typename FE::Traits::LocalBasisType::Traits::DomainType DomainType;
    typedef typename FE::Traits::LocalBasisType::Traits::RangeType RangeType;
 
    typedef LocalInterpolationVirtualInterface<DomainType, RangeType> Interface;
    typedef typename FE::Traits::LocalInterpolationType Implementation;
 
  public:
 
    typedef VirtualFunction<DomainType, RangeType> VirtualFunctionBase;
    typedef Function<const DomainType&, RangeType&> FunctionBase;
 
    typedef typename std::conditional<std::is_base_of<Interface, Implementation>::value, VirtualFunctionBase, FunctionBase>::type type;
  };
 
 
 
  // -----------------------------------------------------------------
  // Basis
  // -----------------------------------------------------------------
 
  template<class T>
  class LocalBasisVirtualInterface
  {
  public:
    using Traits = T;
 
 
    virtual ~LocalBasisVirtualInterface() {}
 
    virtual unsigned int size () const = 0;
 
    virtual unsigned int order () const = 0;
 
    virtual void evaluateFunction (const typename Traits::DomainType& in,
                                   std::vector<typename Traits::RangeType>& out) const = 0;
 
    virtual void evaluateJacobian(const typename Traits::DomainType& in,         // position
                                  std::vector<typename Traits::JacobianType>& out) const = 0;
 
    virtual void partial(const std::array<unsigned int,Traits::dimDomain>& order,
                         const typename Traits::DomainType& in,
                         std::vector<typename Traits::RangeType>& out) const = 0;
  };
 
 
 
  // -----------------------------------------------------------------
  // Interpolation
  // -----------------------------------------------------------------
 
  template<class DomainType, class RangeType>
  class LocalInterpolationVirtualInterfaceBase
  {
  public:
 
    typedef Dune::VirtualFunction<DomainType, RangeType> FunctionType;
 
    typedef typename RangeType::field_type CoefficientType;
 
    virtual ~LocalInterpolationVirtualInterfaceBase() {}
 
    virtual void interpolate (const FunctionType& f, std::vector<CoefficientType>& out) const = 0;
  };
 
  template<class DomainType, class RangeType>
  class LocalInterpolationVirtualInterface
    : public LocalInterpolationVirtualInterfaceBase<DomainType, RangeType>
  {
  public:
 
    typedef Dune::VirtualFunction<DomainType, RangeType> FunctionType;
 
    typedef typename RangeType::field_type CoefficientType;
 
 
    virtual ~LocalInterpolationVirtualInterface() {}
 
    // This method is only noted again for to make the documentation complete.
 
    virtual void interpolate (const FunctionType& f, std::vector<CoefficientType>& out) const = 0;
 
    template<class F,
      std::enable_if_t<not std::is_base_of<FunctionType, F>::value, int> = 0>
    void interpolate (const F& ff, std::vector<CoefficientType>& out) const
    {
      const auto& f = Impl::makeFunctionWithCallOperator<DomainType>(ff);
 
      const LocalInterpolationVirtualInterfaceBase<DomainType, RangeType>& asBase = *this;
      asBase.interpolate(makeVirtualFunction<DomainType, RangeType>(std::cref(f)),out);
    }
 
    template<class F, class C>
    void interpolate (const F& ff, std::vector<C>& out) const
    {
      const auto& f = Impl::makeFunctionWithCallOperator<DomainType>(ff);
 
      std::vector<CoefficientType> outDummy;
      const LocalInterpolationVirtualInterfaceBase<DomainType, RangeType>& asBase = *this;
      asBase.interpolate(makeVirtualFunction<DomainType, RangeType>(std::cref(f)),outDummy);
      out.resize(outDummy.size());
      for(typename std::vector<CoefficientType>::size_type i=0; i<outDummy.size(); ++i)
        out[i] = outDummy[i];
    }
  };
 
 
 
  // -----------------------------------------------------------------
  // Coefficients
  // -----------------------------------------------------------------
 
  class LocalCoefficientsVirtualInterface
  {
  public:
 
    virtual ~LocalCoefficientsVirtualInterface() {}
 
    virtual std::size_t size () const = 0;
 
    const virtual LocalKey& localKey (std::size_t i) const = 0;
 
  };
 
 
 
  // -----------------------------------------------------------------
  // Finite Element
  // -----------------------------------------------------------------
 
 
  template<class T>
  class LocalFiniteElementVirtualInterface
  {
    using LocalBasisTraits = T;
  public:
    typedef LocalFiniteElementTraits<
        LocalBasisVirtualInterface<LocalBasisTraits>,
        LocalCoefficientsVirtualInterface,
        LocalInterpolationVirtualInterface<
            typename LocalBasisTraits::DomainType,
            typename LocalBasisTraits::RangeType> > Traits;
 
    virtual ~LocalFiniteElementVirtualInterface() {}
 
    virtual const typename Traits::LocalBasisType& localBasis () const = 0;
 
    virtual const typename Traits::LocalCoefficientsType& localCoefficients () const = 0;
 
    virtual const typename Traits::LocalInterpolationType& localInterpolation () const = 0;
 
    virtual unsigned int size () const = 0;
 
    virtual const GeometryType type () const = 0;
 
    virtual LocalFiniteElementVirtualInterface<T>* clone() const = 0;
  };
}
#endif