virtualinterface.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright (C) 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/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
  [[deprecated("Dune::LocalFiniteElementFunctionBase is deprecated after Dune 2.7. You can now pass functions providing operator() to interpolate.")]]
  LocalFiniteElementFunctionBase
  {
    typedef typename FE::Traits::LocalBasisType::Traits::DomainType Domain;
    typedef typename FE::Traits::LocalBasisType::Traits::RangeType Range;
 
    // Hack: Keep a copy of Dune::Function here. This allows to avoid depending
    // on the deprecated dune-common header while still keeping the LocalFiniteElementFunctionBase
    // mechanism working during its deprecation period.
    class FunctionBaseDummy
    {
    public:
 
      using RangeType = Range;
      using DomainType = Domain;
 
      struct Traits
      {
        using RangeType = Range;
        using DomainType = Domain;
      };
 
      void evaluate(const DomainType& x, RangeType& y) const;
    };
 
  public:
 
    using VirtualFunctionBase = FunctionBaseDummy;
    using FunctionBase = FunctionBaseDummy;
 
    using type = FunctionBaseDummy;
  };
 
 
 
  // -----------------------------------------------------------------
  // 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& ff, std::vector<CoefficientType>& out) const
    {
      const auto& f = Impl::makeFunctionWithCallOperator<DomainType>(ff);
 
      const LocalInterpolationVirtualInterfaceBase<DomainType, RangeType>& asBase = *this;
      asBase.interpolate(FunctionType(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(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