flyweight.hh

Go to the documentation of this file.

 
#ifndef CONCEPTS_FLYWEIGHT
#define CONCEPTS_FLYWEIGHT
 
#include <unordered_map>
#include "integration/quadRule.hh"
#include "integration/adaptiveQuadRule.hh"
 
namespace concepts {
 
  class ShapeFunction1DOrder {
  public:
    class Hash {
    public:
      std::size_t operator()(const ShapeFunction1DOrder& order) const {
        return ( (order.polynomialDegree_ << 10 | order.nQuadraturePoints_) << 10) | order.quadratureType_;
      }
    };
    
    ShapeFunction1DOrder(const uint polynomialDegree,
                         const uint nQuadraturePoints,
                         const concepts::intRule quadratureType) : 
      polynomialDegree_(polynomialDegree), nQuadraturePoints_(nQuadraturePoints), 
      quadratureType_(quadratureType)
    {}
    
    //     bool operator<(const Order& other) const {
    //       if (static_cast<const Orders<1>&>(*this) == static_cast<const Orders<1>&>(other))
    //         return quadratureType_ < other.quadratureType_;
    //       else
    //         return static_cast<const Orders<1>&>(*this) < static_cast<const Orders<1>&>(other);
    //     }
    
    bool operator==(const ShapeFunction1DOrder& other) const {
      return 
        polynomialDegree_ == other.polynomialDegree_ &&
        nQuadraturePoints_ == other.nQuadraturePoints_ &&
        quadratureType_ == other.quadratureType_;
    }
    
  private:
    uint polynomialDegree_;
    uint nQuadraturePoints_;    
    concepts::intRule quadratureType_;
  };  
 
  class QuadratureOrder {
  public:
    class Hash {
    public:
      std::size_t operator()(const QuadratureOrder& order) const {
        return (order.nQuadraturePoints_ << 10) | order.quadratureType_;
      }
    };
    
    QuadratureOrder(const uint nQuadraturePoints,
                    const concepts::intRule quadratureType) : 
      nQuadraturePoints_(nQuadraturePoints), 
      quadratureType_(quadratureType)
    {}
    
    
    bool operator==(const QuadratureOrder& other) const {
      return 
        nQuadraturePoints_ == other.nQuadraturePoints_ &&
        quadratureType_ == other.quadratureType_;
    }
    
  private:
    uint nQuadraturePoints_;    
    concepts::intRule quadratureType_;
  };
 
  template<class KeyT>
  class Hash;
 
  template<>
  class Hash<ShapeFunction1DOrder>
  {
    typedef typename ShapeFunction1DOrder::Hash type;
  };
 
  template<>
  class Hash<QuadratureOrder>
  {
    typedef typename QuadratureOrder::Hash type;
  };
 
  template<class KeyT, class ValueT>
  class Flyweight { 
  public: 
    Flyweight() {}
    
    std::shared_ptr<const ValueT> get(const KeyT& key) {
      auto it = container_.find(key);
      if (it != container_.end() )
        return it->lock();
      else
        return std::make_shared<const ValueT>();
    }
    
    void insert(const KeyT& key, std::shared_ptr<const ValueT>& value) {
      auto it = container_.find(key);
      if (it != container_.end() )
        conceptsAssert(!container_[key].lock(),Assertion());
      container_[key] = value;
    }
    
    
  protected:
    std::unordered_map<KeyT,std::weak_ptr<const ValueT>, Hash<KeyT> > container_;    
  };
  
  template <class FunctionT>
  std::shared_ptr<const FunctionT> makeShapeFunction(const concepts::QuadratureRule1d& quadratureRule,
                                                     const uint polynomialDegree)
  {
      
    using Order = ShapeFunction1DOrder;
    static Flyweight<Order,FunctionT> flyweight_;
    
    intRule ruleType;
    if (dynamic_cast<const QuadratureRule1dGaussJacobi*>(&quadratureRule) != nullptr)
      ruleType = intRule::GAUSS_JACOBI;
    else if (dynamic_cast<const QuadratureRule1dGaussLobatto*>(&quadratureRule) != nullptr)
      ruleType = intRule::GAUSS_LOBATTO;
    else if (dynamic_cast<const QuadratureRule1dTrapeze*>(&quadratureRule) != nullptr)
      ruleType = intRule::TRAPEZE;
    
    Order order(polynomialDegree,
                quadratureRule.n(), 
                ruleType);
    
    if(auto function = flyweight_.lock(order))
      return function;
    else {
      function = std::make_shared<FunctionT>(polynomialDegree,
                                             quadratureRule);
      
      flyweight_.insert(order,function);
      return function;
    }
  };
  
  template <class FunctionT>
  std::shared_ptr<const FunctionT> makeQuadrature(const uint nQuadraturePoints,
                                                  const intRule quadratureType) {
      
    using Order = QuadratureOrder;
    static Flyweight<Order,FunctionT> flyweight_quadrature_;
    
    Order order(nQuadraturePoints, quadratureType);
    
    if(auto quadrature = flyweight_quadrature_.lock(order))
      return quadrature;
    else {
      
      if (quadratureType == intRule::GAUSS_JACOBI)
        {
          quadrature = std::make_shared<QuadratureRule1dGaussJacobi>(nQuadraturePoints);
        }
      else if (quadratureType == intRule::GAUSS_LOBATTO)
        {
          quadrature = std::make_shared<QuadratureRule1dGaussLobatto>(nQuadraturePoints);
        }
      else if (quadratureType == intRule::TRAPEZE)
        {
          quadrature = std::make_shared<QuadratureRule1dTrapeze>(nQuadraturePoints);
        }
      else
        {
          throw conceptsException(concepts::MissingFeature("quadrature rule not defined"));
        }
      
      flyweight_quadrature_.insert(order,quadrature);
      return quadrature;
    }
  }
  
  template <class FunctionT>
  std::shared_ptr<const FunctionT> makeAdaptiveQuadrature(const uint nQuadraturePoints,
                                                          const intRule quadratureType) {
    
    using Order = QuadratureOrder;
 
    static Flyweight<Order,FunctionT> flyweight_quadrature_;
    
    Order order(nQuadraturePoints, quadratureType);
    
    if(auto quadrature = flyweight_quadrature_.lock(order))
      return quadrature;
    else {
      if (quadratureType == intRule::GAUSS_JACOBI)
        {
          quadrature = std::make_shared<AdaptiveQuadratureRule1d<intRule::GAUSS_JACOBI> >(nQuadraturePoints);
        }
      else if (quadratureType == intRule::GAUSS_LOBATTO)
        {
          quadrature = std::make_shared<AdaptiveQuadratureRule1d<intRule::GAUSS_LOBATTO> >(nQuadraturePoints);
        }
      else if (quadratureType == intRule::TRAPEZE)
        {
          quadrature = std::make_shared<AdaptiveQuadratureRule1d<intRule::TRAPEZE> >(nQuadraturePoints);
        }
      else
        {
          throw conceptsException(concepts::MissingFeature("quadrature rule not defined"));
        }
 
      flyweight_quadrature_.insert(order,quadrature);
      return quadrature;
    }
  }
  
}
 
#endif