virtualwrappers.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_VIRTUALWRAPPERS_HH
#define DUNE_LOCALFUNCTIONS_COMMON_VIRTUALWRAPPERS_HH
 
#include <array>
 
#include <dune/localfunctions/common/localbasis.hh>
#include <dune/localfunctions/common/localkey.hh>
#include <dune/localfunctions/common/virtualinterface.hh>
 
namespace Dune
{
 
  // forward declaration needed by friend declarations
  template<class Imp>
  class LocalFiniteElementVirtualImp;
 
  // default clone method is the copy constructor
  template<class Imp, bool IsInterface>
  struct LocalFiniteElementCloneFactoryHelper
  {
    static Imp* clone(const Imp& imp)
    {
      return new Imp(imp);
    }
  };
 
  // if FE derives from virtual interface the clone method is used
  template<class Imp>
  struct LocalFiniteElementCloneFactoryHelper<Imp, true>
  {
    static Imp* clone(const Imp& imp)
    {
      return imp.clone();
    }
  };
 
  // factory template to clone and create an objects
  template<class Imp>
  struct LocalFiniteElementCloneFactory
  {
    typedef LocalFiniteElementVirtualInterface<typename Imp::Traits::LocalBasisType::Traits> Interface;
 
    static Imp* clone(const Imp& imp)
    {
      return LocalFiniteElementCloneFactoryHelper<Imp, std::is_base_of<Interface, Imp>::value>::clone(imp);
    }
 
    static Imp* create()
    {
      return new Imp;
    }
  };
 
 
 
  // -----------------------------------------------------------------
  // Basis
  // -----------------------------------------------------------------
 
 
 
  template<class T , class Imp>
  class LocalBasisVirtualImp
    : public LocalBasisVirtualInterface<T>
  {
    template<class FEImp>
    friend class LocalFiniteElementVirtualImp;
 
  protected:
 
    LocalBasisVirtualImp( const Imp &imp )
      : impl_(imp)
    {}
 
  public:
    using Traits = T;
 
    unsigned int size () const
    {
      return impl_.size();
    }
 
    unsigned int order () const
    {
      return impl_.order();
    }
 
    inline void evaluateFunction (const typename Traits::DomainType& in,
                                  std::vector<typename Traits::RangeType>& out) const
    {
      impl_.evaluateFunction(in,out);
    }
 
    inline void evaluateJacobian(
      const typename Traits::DomainType& in,
      std::vector<typename Traits::JacobianType>& out) const
    {
      impl_.evaluateJacobian(in,out);
    }
 
    void partial(const std::array<unsigned int,Traits::dimDomain>& order,
                 const typename Traits::DomainType& in,
                 std::vector<typename Traits::RangeType>& out) const
    {
      impl_.partial(order,in,out);
    }
 
  protected:
    const Imp& impl_;
  };
 
 
 
  // -----------------------------------------------------------------
  // Interpolation
  // -----------------------------------------------------------------
 
  template<class DomainType, class RangeType, class Imp>
  class LocalInterpolationVirtualImp
    : public LocalInterpolationVirtualInterface< DomainType, RangeType >
  {
    template<class FEImp>
    friend class LocalFiniteElementVirtualImp;
 
    typedef LocalInterpolationVirtualInterface< DomainType, RangeType > Base;
 
  protected:
 
    LocalInterpolationVirtualImp( const Imp &imp)
      : impl_(imp) {}
 
  public:
 
    typedef typename Base::FunctionType FunctionType;
 
    typedef typename Base::CoefficientType CoefficientType;
 
    virtual void interpolate (const FunctionType& f, std::vector<CoefficientType>& out) const
    {
      impl_.interpolate(f,out);
    }
 
  protected:
    const Imp& impl_;
 
  };
 
 
 
  // -----------------------------------------------------------------
  // Coefficients
  // -----------------------------------------------------------------
 
  template<class Imp>
  class LocalCoefficientsVirtualImp
    : public LocalCoefficientsVirtualInterface
  {
    template<class FEImp>
    friend class LocalFiniteElementVirtualImp;
 
  protected:
 
    LocalCoefficientsVirtualImp( const Imp &imp )
      : impl_(imp)
    {}
 
  public:
 
    std::size_t size () const
    {
      return impl_.size();
    }
 
    const LocalKey& localKey (std::size_t i) const
    {
      return impl_.localKey(i);
    }
 
  protected:
    const Imp& impl_;
 
  };
 
 
 
  // -----------------------------------------------------------------
  // Finite Element
  // -----------------------------------------------------------------
 
  template<class Imp>
  class LocalFiniteElementVirtualImp
    : public LocalFiniteElementVirtualInterface<typename Imp::Traits::LocalBasisType::Traits>
  {
    using LocalBasisTraits = typename Imp::Traits::LocalBasisType::Traits;
    using Interface = LocalFiniteElementVirtualInterface<LocalBasisTraits>;
 
  public:
    typedef typename Interface::Traits Traits;
 
    LocalFiniteElementVirtualImp( const Imp &imp )
      : impl_(LocalFiniteElementCloneFactory<Imp>::clone(imp)),
        localBasisImp_(impl_->localBasis()),
        localCoefficientsImp_(impl_->localCoefficients()),
        localInterpolationImp_(impl_->localInterpolation())
    {}
 
    LocalFiniteElementVirtualImp()
      : impl_(LocalFiniteElementCloneFactory<Imp>::create()),
        localBasisImp_(impl_->localBasis()),
        localCoefficientsImp_(impl_->localCoefficients()),
        localInterpolationImp_(impl_->localInterpolation())
    {}
 
    LocalFiniteElementVirtualImp(const LocalFiniteElementVirtualImp& other)
      : impl_(LocalFiniteElementCloneFactory<Imp>::clone(*other.impl_)),
        localBasisImp_(impl_->localBasis()),
        localCoefficientsImp_(impl_->localCoefficients()),
        localInterpolationImp_(impl_->localInterpolation())
    {}
 
    ~LocalFiniteElementVirtualImp()
    {
      delete impl_;
    }
 
    const typename Traits::LocalBasisType& localBasis () const
    {
      return localBasisImp_;
    }
 
    const typename Traits::LocalCoefficientsType& localCoefficients () const
    {
      return localCoefficientsImp_;
    }
 
    const typename Traits::LocalInterpolationType& localInterpolation () const
    {
      return localInterpolationImp_;
    }
 
    unsigned int size () const
    {
      return impl_->size();
    }
 
    const GeometryType type () const
    {
      return impl_->type();
    }
 
    virtual LocalFiniteElementVirtualImp<Imp>* clone() const
    {
      return new LocalFiniteElementVirtualImp<Imp>(*this);
    }
 
  protected:
    const Imp* impl_;
 
    const LocalBasisVirtualImp<LocalBasisTraits, typename Imp::Traits::LocalBasisType> localBasisImp_;
    const LocalCoefficientsVirtualImp<typename Imp::Traits::LocalCoefficientsType> localCoefficientsImp_;
    const LocalInterpolationVirtualImp<typename LocalBasisTraits::DomainType,
        typename LocalBasisTraits::RangeType,
        typename Imp::Traits::LocalInterpolationType> localInterpolationImp_;
  };
}
#endif