integration/karniadakis.hh

Go to the documentation of this file.

/* Expansion bases for tensorial shape functions not only for
 * quads and hexahedrons but also for triangles and tetrahedrons.
 * Due to Karniadakis, Sherwin
 */

#ifndef karniadakis_hh
#define karniadakis_hh

#include <iostream>

#if __ICC == 800
#  include <hash_map>
#  define __gnu_cxx std
#else
#  if __GNUC__ > 2
#    include <ext/hash_map>
#    if __GNUC__==3 && __GNUC_MINOR__ < 1
#      define __gnu_cxx std
#    endif
#  else
#    include <hash_map>
#    define __gnu_cxx std
#  endif
#endif

#include "basics/typedefs.hh"
#include "shapefunction.hh"

namespace concepts {

  // **************************************************************** Orders **

  class OrdersBase {
    public:
      OrdersBase() : P_(0) {}

      OrdersBase(const int P) : P_(P) {}

      inline int P() const { return P_; }
    protected:
      int P_;
  };

  template<int number>
    class Orders;

  template<int number>
    std::ostream& operator<< (std::ostream& os, const Orders<number>& o) { 
      for (unsigned int i = 0; i < number; ++i) {
        os << "p(" << i << ") = " << o.p_[i] << ", ";
      }
      os << "P = " << o.P_;
      return os;
    }

  template<int number>
    class Orders : public OrdersBase {
      friend std::ostream& operator<< <>(std::ostream& os,
          const Orders<number>& o);
      public:
      Orders();

      Orders(const int p0, const int P, const int p1 = 0, const int p2 = 0);

      inline int p(const uint i) const { 
        if (i < number) return p_[i];
        else return 0;
      }

      inline bool operator==(const Orders<number>& o) const {
        bool equal = true && (P_ == o.P_);
        for (uint i = 0; i < number; ++i)
          equal &= (p_[i] == o.p_[i]);
        return equal;
      }

      inline bool operator<(const Orders<number>& o) const {
        for (uint i = 0; i < number; ++i)
          if (p_[i] < o.p_[i]) return true;
        return false;
      }
      private:
      int p_[number];
    };

} // namespace concepts

namespace __gnu_cxx {

  template<int number>
    size_t hash_value(const concepts::Orders<number>& o);

  template<int number>
    struct hash<concepts::Orders<number> > {
      size_t operator()(const concepts::Orders<number>& o) const {
        return hash_value(o);
      }
    };

  template<int number>
    struct OrdersEqual {
      bool operator()(const concepts::Orders<number>& x,
          const concepts::Orders<number>& y) const {
        return x == y;
      }
    };
} // namespace __gnu_cxx

namespace concepts {

  // *********************************************************** Karniadakis **

  template<int type, int mode>
    class Karniadakis : public ShapeFunction1D<Real> {
      public:
        Karniadakis(const int P, const Real* xP, const int NxP,
            const int Q = 0, const int R = 0, const bool cache = true);

        Karniadakis(const Karniadakis<type, mode>& arg);
        static void clearCache() { principal_H.clear(); }

        ~Karniadakis();
      protected:
        virtual std::ostream& info(std::ostream& os) const;
      private:
        Orders<type> orders_;

        static typename __gnu_cxx::hash_map<Orders<type>, Real*,
                        __gnu_cxx::hash<Orders<type> >,
                        __gnu_cxx::OrdersEqual<type> > principal_H;

        bool cache_;
    };


} // namespace concepts

#endif // karniadakis_hh