virtualinterface.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_LOCALFUNCTIONS_COMMON_VIRTUALINTERFACE_HH
#define DUNE_LOCALFUNCTIONS_COMMON_VIRTUALINTERFACE_HH
 
#include <type_traits>
#include <array>
#include <vector>
#include <functional>
 
#include <dune/geometry/type.hh>
 
#include <dune/localfunctions/common/localbasis.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;
 
 
 
  // -----------------------------------------------------------------
  // 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:
 
    using FunctionType = std::function<RangeType(DomainType)>;
 
    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:
 
    using FunctionType = std::function<RangeType(DomainType)>;
 
    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& f, std::vector<CoefficientType>& out) const
    {
      const LocalInterpolationVirtualInterfaceBase<DomainType, RangeType>& asBase = *this;
      asBase.interpolate(FunctionType(std::cref(f)),out);
    }
 
    template<class F, class C>
    void interpolate (const F& f, std::vector<C>& out) const
    {
      std::vector<CoefficientType> outDummy;
      const LocalInterpolationVirtualInterfaceBase<DomainType, RangeType>& asBase = *this;
      asBase.interpolate(FunctionType(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