AliNDFunctionInterface.h

Go to the documentation of this file.

#ifndef AliNDFunctionInterface_H
#define AliNDFunctionInterface_H


#include <map>
class TGraph;
class TH1;
class TTreeSRedirector;
class THn;
class TObjArray;

namespace AliNDFunctionInterface {
  Int_t fVerbose=0;            
  template<typename T> vector<T> add_to_vector(vector<T> &z, T v);
  template<typename T, typename... Args> vector<T> add_to_vector(vector<T> &z, T v, Args... args);
  template<typename T, typename... Args> vector<T> make_vector(T v, Args... args);
  std::map<int, THn*> hnMapArrayInt;
  std::map<std::string, THn*> hnMapArrayName;
  // THn interpolation interface
  Double_t GetInterpolationLinear(THn * his, Double_t *xyz, Int_t  verbose);
  Double_t GetDeltaInterpolationLinear(THn * his, Double_t *xyz, Int_t dIndex, Int_t  verbose);
  // Global function interface
  Double_t GetInterpolationLinear(Int_t index, Double_t *xyz, Int_t  verbose){return GetInterpolationLinear(hnMapArrayInt[index], xyz,verbose);}
  Double_t GetDeltaInterpolationLinear(Int_t index, Double_t *xyz, Int_t dIndex, Int_t  verbose) {
      return GetDeltaInterpolationLinear(hnMapArrayInt[index], xyz, dIndex, verbose);
  }
  Double_t GetInterpolationLinear(const char *name, Double_t *xyz, Int_t  verbose){return GetInterpolationLinear(hnMapArrayName[name], xyz,verbose);}
  template<typename T, typename... Args> T EvalTHnLinear(int id, T v, Args... args);        
  map<int, TMVA::MethodBase *> readerMethodBase;            
  map<int, TObjArray* > readerMethodBaseArray;              
  map<std::string, std::string> regressionMethodSetting;    
  map<std::string, TMVA::Types::EMVA> regressionMethodID;   
  void registerDefaultMVAMethods();                         
  void registerMethod(std::string method,  std::string content, TMVA::Types::EMVA id){regressionMethodSetting[method]=content; regressionMethodID[method]=id;}
  Int_t  FitMVA(TTree *tree, const char *varFit, TCut cut, const char * variableList, const char *methodList, const char *weights=NULL, Int_t index=-1);   
  TMVA::MethodBase * LoadMVAReader(Int_t id, const char * inputFile, const char *method, const char *dir);
  Int_t  LoadMVAReaderArray(Int_t id, const char * inputFile, const char *methodMask, const char *dirMask);
  Int_t  AppendMethodToArray(Int_t index, TMVA::MethodBase * method);         
  Double_t   EvalMVAStatArray(int id, int statType, vector<float> point);     
  template<typename T, typename... Args> T EvalMVA(int id, T v, Args... args);        
  template<typename T, typename... Args> T EvalMVAStat(int id, int statType,  T v, Args... args);        

};


template<typename T> vector<T> AliNDFunctionInterface::add_to_vector(vector<T> &z, T v) {z.push_back(v); return z;}
template<typename T, typename... Args> vector<T> AliNDFunctionInterface::add_to_vector(vector<T> &z, T v, Args... args) {
    z.push_back(v);return add_to_vector<T>(z, args...);
}
template<typename T, typename... Args> vector<T> AliNDFunctionInterface::make_vector(T v, Args... args) {
    vector<T> z; z.push_back(v); return add_to_vector<T>(z, args...);
}

template<typename T, typename... Args> T AliNDFunctionInterface::EvalTHnLinear(int id, T v, Args... args){
  auto a = make_vector<double>(v, args...);
  THn *his = hnMapArrayInt[id];
  if (his!=NULL) return GetInterpolationLinear(his, a.data(), 0);
  return 0;
};


template<typename T, typename... Args> T AliNDFunctionInterface::EvalMVA(int id, T v, Args... args){
  auto a = make_vector<float>(v, args...);
  TMVA::Event  event = TMVA::Event(a,a.size());
  TMVA::MethodBase * method= readerMethodBase[id];
  if (method==NULL) return 0;                      
  return method->GetRegressionValues(&event)[0];
};


template<typename T, typename... Args> T AliNDFunctionInterface::EvalMVAStat(int id, int statType,  T v, Args... args) {        
  auto a = make_vector<float>(v, args...);
  return EvalMVAStatArray(id,statType,a);
};

#endif