karniadakis.hh

Go to the documentation of this file.

 
#ifndef karniadakis_hh
#define karniadakis_hh
 
#include <iostream>
#include "toolbox/hashMap.hh"
#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 std {
 
  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 std
 
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 int P, int NxP, const Real* values,
            const int Q = 0, const int R = 0);
 
 
 
 
        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 std::unordered_map<Orders<type>, Real*,
                        std::hash<Orders<type> >,
                        std::OrdersEqual<type> > principal_H;
 
        bool cache_;
    };
 
 
 
 
 
 
 
} // namespace concepts
 
#endif // karniadakis_hh