ASTResolver.h

Go to the documentation of this file.

#ifndef AMPGEN_ASTRESOLVER_H
#define AMPGEN_ASTRESOLVER_H
#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 MinuitProxy;

  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 false; }
    bool enableAVX() const { return m_enableAVX; }
    void setEnableAVX() { m_enableAVX = 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 resolvedVariable(const IExpression *param) const;
 
    void clear();
 
    std::map<const IExpression *, std::string> parameters() const { return m_resolvedParameters; }
    std::vector<Variable> unresolvedVariables() const { return m_unresolvedVariables; }
 
  private:
    std::vector<Variable> m_unresolvedVariables;                            
    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{0};                                          
    bool m_enableAVX{false};                                                
  };
 
  template <> void ASTResolver::resolve<Variable>(const Variable &obj);
  template <> void ASTResolver::resolve<SubTree>(const SubTree &obj);
  template <> void ASTResolver::resolve<Spline>(const Spline &obj);
  template <> void ASTResolver::resolve<MinuitProxy>(const MinuitProxy &obj);
  template <> void ASTResolver::resolve<LambdaExpression>(const LambdaExpression &obj);
}
 
#endif