interface.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_LOCALFUNCTIONS_INTERFACE_HH
#define DUNE_LOCALFUNCTIONS_INTERFACE_HH
 
#ifndef HEADERCHECK
#error This header exists for documentation purposes only and should never be included directly.
#endif
 
#include <array>
#include <cstddef>
#include <vector>
 
 
#include <dune/geometry/type.hh>
 
#include <dune/localfunctions/common/localkey.hh>
 
namespace Dune {
 
  class FiniteElementInterface
  {
    struct ImplementationDefined;
 
  public:
 
    struct Traits
    {
 
      typedef ImplementationDefined Basis;
 
      typedef ImplementationDefined Coefficients;
 
      typedef ImplementationDefined Interpolation;
    };
 
 
    FiniteElementInterface(...);
    FiniteElementInterface(const FiniteElementInterface&);
 
 
    const Traits::Basis& basis() const;
 
    const Traits::Coefficients& coefficients() const;
 
    const Traits::Interpolation& interpolation() const;
    GeometryType type() const;
  };
 
 
  template<class Geometry, class VertexOrder>
  class FiniteElementFactoryInterface
  {
    struct ImplementationDefined;
 
  public:
 
    typedef ImplementationDefined FiniteElement;
 
 
    FiniteElementFactoryInterface(...);
 
 
    const FiniteElement make(const Geometry&, const VertexOrder&, ...);
    const FiniteElement make(const Geometry&, ...);
    const FiniteElement make(const VertexOrder&, ...);
 
    const FiniteElement make(const GeometryType&, ...);
    const FiniteElement make(...);
 
 
  };
 
  class BasisInterface
  {
    struct ImplementationDefined;
    enum { implementationDefined };
 
  public:
 
    struct Traits
    {
 
      typedef ImplementationDefined DomainFieldType;
      enum {
        dimDomain = implementationDefined
      };
      typedef ImplementationDefined DomainType;
 
 
 
      typedef ImplementationDefined RangeFieldType;
      enum {
        dimRange = implementationDefined
      };
      typedef ImplementationDefined RangeType;
 
 
 
      typedef ImplementationDefined Jacobian;
    };
 
    std::size_t size () const;
    std::size_t order () const;
 
    void evaluateFunction(const Traits::DomainType& in,
                          std::vector<Traits::RangeType>& out) const;
 
    void evaluateJacobian(const Traits::DomainType& in,
                          std::vector<Traits::Jacobian>& out) const;
 
    void partial(const std::array<unsigned int,Traits::dimDomain>& order,
                 const typename Traits::DomainType& in,
      std::vector<typename Traits::RangeType>& out) const;
  };
 
  struct InterpolationInterface
  {
 
    typedef BasisInterface::Traits Traits;
 
 
    template<typename F, typename C>
    void interpolate (const F& f, std::vector<C>& out) const;
  };
 
 
  struct CoefficientsInterface
  {
    std::size_t size() const;
 
    const LocalKey& localKey(std::size_t i) const;
  };
}
#endif // DUNE_LOCALFUNCTIONS_INTERFACE_HH