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 DomainField;
      static const std::size_t dimDomainLocal = implementationDefined;
      static const std::size_t dimDomainGlobal = implementationDefined;
      typedef ImplementationDefined DomainLocal;
      typedef ImplementationDefined DomainGlobal;
 
 
 
      typedef ImplementationDefined RangeField;
      static const std::size_t dimRange = implementationDefined;
      typedef ImplementationDefined Range;
 
 
 
      typedef ImplementationDefined Jacobian;
 
      static const std::size_t diffOrder = implementationDefined;
    };
 
    std::size_t size () const;
    std::size_t order () const;
 
    void evaluateFunction(const Traits::DomainLocal& in,
                          std::vector<Traits::Range>& out) const;
 
    void evaluateJacobian(const Traits::DomainLocal& in,
                          std::vector<Traits::Jacobian>& out) const;
 
 
    void evaluate
      ( const std::array<std::size_t, Traits::dimDomainGlobal>& directions,
      const Traits::DomainLocal& in,
      std::vector<Traits::Range>& 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