ASTResolver.h

Go to the documentation of this file.

#include <memory>
#include <stddef.h>
#include <iosfwd>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <unordered_map>
#include <future>
 
#include "AmpGen/Expression.h"
#include "AmpGen/CacheTransfer.h"
#include "AmpGen/Spline.h"
 
namespace AmpGen {
  class MinuitParameter;
  class MinuitParameterSet;
  class MinuitParameterLink;
   
  class ASTResolver 
  { 
    public: 
      ASTResolver(const std::map<std::string, unsigned>& evtMap = {} , const MinuitParameterSet* mps = nullptr );
      std::vector<std::pair<uint64_t,Expression>> getOrderedSubExpressions( const Expression& expression);
 
      template <class TYPE> void resolve( const TYPE& obj ){}
      template <class TYPE, class ...ARGS> size_t addCacheFunction( const std::string& name, const ARGS&... args )
      {
        auto it = m_cacheFunctions.find(name);
        if( it != m_cacheFunctions.end() ) return it->second->address();
        m_cacheFunctions[name] = std::make_shared<TYPE>(m_nParameters, name, args... );
        m_nParameters += m_cacheFunctions[name]->size();
        return m_nParameters - m_cacheFunctions[name]->size();
      }
      size_t nParams() const { return m_nParameters ; }       
      bool enableCuda() const { return m_enable_cuda ; }
      bool enableAVX()  const { return m_enable_avx; }
      bool enableCompileConstants() const { return m_enable_compileTimeConstants ;} 
      void setEnableAVX(){ m_enable_avx = true ; }
      std::map<std::string, std::shared_ptr<CacheTransfer>> cacheFunctions() const;
      void addResolvedParameter(const IExpression* param, const std::string& thing);
      void addResolvedParameter(const IExpression* param, const size_t& address, const size_t& arg=0);
      std::string resolvedParameter( const IExpression* param ) const; 
      
      void clear();
 
      std::map<const IExpression*, std::string> parameters() const { return m_resolvedParameters; }
      std::vector<Parameter> unresolvedParameters()          const { return m_unresolvedParameters; }
    private: 
      std::vector<Parameter>                                m_unresolvedParameters;        
      std::map<const IExpression*, std::string>             m_resolvedParameters;          
      std::map<std::string, std::shared_ptr<CacheTransfer>> m_cacheFunctions;              
      std::map<std::string, unsigned>                       m_evtMap;                      
      std::map<std::string, std::string>                    m_parameterMapping;            
      const MinuitParameterSet*                             m_mps;                         
      std::map<const IExpression*, const SubTree*>          m_tempTrees;                   
      unsigned int                                          m_nParameters;                 
      bool                                                  m_enable_cuda                 {false}; 
      bool                                                  m_enable_compileTimeConstants {false}; 
      bool                                                  m_enable_avx                  {false}; 
      bool                                                  m_check_hashes                {false}; 
  };
  
  template <> void ASTResolver::resolve<Parameter>( const Parameter& obj );
  template <> void ASTResolver::resolve<SubTree>  ( const SubTree  & obj );
  template <> void ASTResolver::resolve<Spline>   ( const Spline   & obj );
  template <> void ASTResolver::resolve<MinuitParameterLink>( const MinuitParameterLink& obj );  
  template <> void ASTResolver::resolve<LambdaExpression>( const LambdaExpression& obj);
}