mstein/triggerStudy/tools.h

#include <iostream>
#include <iomanip>
#include <vector>
#include <map>
#include <fstream>
#include <sstream>
#include <Rtypes.h>
#include "TChain.h"
#include "TFile.h"
#include "TString.h"
#include "TStopwatch.h"
#include "TCanvas.h"
#include "TH1D.h"
#include "TLeafC.h"
#include "TSystem.h"
#include <stdio.h>
#include <stdlib.h>


using namespace std;

#ifndef tools_h
#define tools_h
namespace tools{
  UInt_t toollevel    = 0; 
  Int_t toolverbosity = 0;
  TStopwatch tooltimer;
  TChain *toolfChain;
  
  void adjusth1d(TH1D *h1, TH1D *h2);
  void enterFcn(TString name, Int_t max, Int_t timer_flg=0);
  void exitFcn(TString name, Int_t max, Int_t timer_flg=0);
  void SetVerbosity(Int_t v){toolverbosity=v;}
  void SetLevel(Int_t l){toollevel=l;}
  void progress(Long64_t cnt);
  void percent(Double_t arg1, Double_t arg2, ostream& os=cout);
  void SetCurrentChain(TChain *chain){toolfChain = chain;}
  template <typename T>
  void Swap(T &value1, T &value2);
  
  TString create_number(Int_t number, Int_t number_max);
  vector<TString> splitToWords(TString rawString, TString newWord=";");
  map<TString, TString> splitToWords(TString rawString, TString newWord, TString newValue); 
  TChain* GetCurrentChain(){return toolfChain;}
    
  template <typename T>
  void printVector(TString name, vector<T> v, Int_t length=40, ostream& os=cout);
  template <typename T>
  void printVectorSize(TString name, vector<T> v, Int_t length=40, ostream& os=cout);   
  
  template<typename T> 
  void addLeaf(TChain *chain, TString name, vector<T> **pt);
  template<typename T>
  void addLeaf(TChain *chain, TString name, vector<T> &pt);  
  template<typename T>  
  void addLeaf(TChain *chain, TString name, T **pt);
  template <typename T>
  void addLeaf(TChain *chain, TString name, T &pt);

  template<typename T> 
  void addLeaf(TString name, vector<T> **pt){addLeaf(toolfChain, name, &(*pt));}
  template<typename T> 
  void addLeaf(TString name, vector<T> &pt){addLeaf(toolfChain, name, (pt));}
  template<typename T> 
  void addLeaf(TString name, T **pt){addLeaf(toolfChain, name, &(*pt));}
  template<typename T> 
  void addLeaf(TString name, T &pt){addLeaf(toolfChain, name, (pt));}
  template <typename T>
  
  
  void GetValueFromLeaf(TString fileName, TString branchName, TString leafName, vector<T> **pt, Long64_t entry=0);
  template<typename T1, typename T2>
  void printMap(map<T1, T2> m);
    
  //template <typename T>
  //vector<T> GetValueFromLeaf(TString fileName, TString branchName, TString leafName, Long64_t entry=0);
    
  //TString GetStringFromLeaf(TString fileName, TString branchName, TString leafName, Long64_t entry=0);
  
    
//   // -------------------------------------------------------------------------------------
//   static std::string toString(double d) {
//     std::stringstream ss;
//     ss << d;
//     return ss.str();
//   }
//   
//   // -------------------------------------------------------------------------------------
//   static std::string toString(double d, int decPlaces) {
//     std::stringstream ss;
//     ss << round(d,decPlaces);
//     return ss.str();
//   }
//   
//   // -------------------------------------------------------------------------------------
//   static TString toTString(double d, int decPlaces) {
//     return toString(d,decPlaces).c_str();
//   }
//   
//   
//   // -------------------------------------------------------------------------------------
//   static TString toTString(double d) {
//     return toString(d).c_str();
//   }
//   
  
  
  //================================================================================= addToCanvas
//   template <typename T>
//   void addToCanvas(TCanvas* c, T* h){
//     static map<TCanvas*, Bool_t> canExists;
//     TCanvas *ich = new TCanvas();
//     
//     canExists[ich] = 1;
//     
//     if(canExists.find(c) != canExists.end()) 
//       cout<<"jo den gibts schon" <<endl;
//     else{
//       cout<<"ein neuer!"<<endl;
//     }
//   }
  
  
/*  
  void addToCanvas(TCanvas *c, TH1D* h){
    static map<TCanvas* , Bool_t> canExists;
    if(canExists.find(c) != canExists.end()) 
      cout<<"jo den gibts schon" <<endl;
    else{
      canExists[c] = 1;
      cout<<"ein neuer!"<<endl;
    }
  }*/
  
  
 //template <typename T>
 //T GetHistFromFile(TString fileName, TString histName);
  
  //TH1D* GetHistFromFile(TString &fileName, TString &histName);
  
  //template <typename T>
  //void addToCanvas(TCanvas* can, T* h);
    
  //template <typename T>
      
  //================================================================================= enterFcn
  //Help for debugging and to measure running time of a function
  //0: silent
  //1: functions called once per run
  //2: functions multiple times per event
  //3: functions called once per event
  //4: functions called multiple times per event
  void enterFcn(TString name, Int_t max, Int_t timer_flg){
    ++toollevel;
    if(toolverbosity>=max){
      for(UInt_t ilevel=0; ilevel<toollevel; ++ilevel)     cout << "++";
      cout << " enter " << name << endl;
    }
    if(timer_flg){tooltimer.Reset(); tooltimer.Start();}
  }
  
  
  //================================================================================= exitFcn
  void exitFcn(TString name, Int_t max, Int_t timer_flg){
    if(timer_flg){
      tooltimer.Stop(); 
      cout<< name << ": Time (real|CPU) = "<<tooltimer.RealTime()<<" | "<<tooltimer.CpuTime()<<endl;
    }
    --toollevel;
    if(toolverbosity>=max){
      for(UInt_t ilevel=0; ilevel<=toollevel; ++ilevel) cout << "++";
      cout << " exit  " << name << endl;
    }
  }
  
  
  //================================================================================= progress
  void progress(Long64_t cnt){
    static Long64_t step(1),next(1);
    ++cnt;
    if(cnt==next || cnt%10000==0){
      cout << "=========================================================== " << "Enter event " << cnt << endl;
      next+=step;
    }
    if((cnt+1)/step==10)step*=10;
  }
  
  
  //================================================================================= printVector
  template <typename T>
  void printVector(TString name, vector<T> v, Int_t length, ostream& os){
    printVectorSize(name,v);
    if(v.size()>0){
      for(Int_t i=0,N=v.size(); i<N; ++i){
        TString temp_name = name;
        temp_name += "[";
        temp_name += i;
        temp_name += "] = ";
        os << setw(length) << temp_name << v[i] << endl;
      }
      os<<endl;
    }
  }
  
  
  //================================================================================= printVectorSize
  template <typename T>
  void printVectorSize(TString name, vector<T> v, Int_t length, ostream& os){
    name += ".size() = ";
    os << setw(length) << name << v.size();
    os << endl;
  }
  
  
  //================================================================================= percent
  void percent(Double_t arg1, Double_t arg2, ostream& os){
    os<<setw(5)<<setprecision(4)<<arg1/arg2*100<<"%";
  }
  
  
  //================================================================================= create_number
  TString create_number(Int_t number, Int_t number_max){
    TString name = ""; name+=number;
    Int_t mag_number=1, mag_number_max=1;
    Int_t n_zero=0;
    if(number==0) mag_number=2;
    while(number>=1){
      number/=10;
      ++mag_number;
    }
    while(number_max>=1){
      number_max/=10;
      ++mag_number_max;
    }
    n_zero = mag_number_max - mag_number;
    for(Int_t i=0; i<n_zero; ++i) name.Insert(0,"0"); 
    return name;
  }
  
  
  //================================================================================= addLeaf
  template<typename T> 
  void addLeaf(TChain *chain, TString name, vector<T> **pt){
    *pt=0;
    chain->SetBranchStatus(name + "*", 1);
    chain->SetBranchAddress(name, &(*pt));
    //skim_data->Branch(name, &(*pt));
  }
  

//   //================================================================================= addLeaf
//   template<typename T> 
//   void addLeaf(TChain *chain, TString name, vector<T> &pt){
//     //*pt=0;
//     chain->SetBranchStatus(name + "*", 1);
//     chain->SetBranchAddress(name, &pt);
//     //skim_data->Branch(name, pt);
//   }
  
  
  //================================================================================= addLeaf
  template<typename T> 
  void addLeaf(TChain *chain, TString name, T **pt){
    *pt=0;
    chain->SetBranchStatus(name + "*", 1);
    chain->SetBranchAddress(name, &(*pt));
    //skim_data->Branch(name, &(*pt));
  }
  
  
  //================================================================================= addLeaf
  template<typename T> 
  void addLeaf(TChain *chain, TString name, T &pt){
    //pt=0;
    chain->SetBranchStatus(name + "*", 1);
    chain->SetBranchAddress(name, &pt);
    //skim_data->Branch(name + "*", &pt);
    //skim_data->Branch(name, pt);
  }
  
  
  //================================================================================= addLeafString
  void addLeafString(TString name, TString &pt, Long64_t jentry=0){
    toolfChain->SetBranchStatus(name + "*", 1);
    toolfChain->GetEntry(jentry);
    TLeafC *l = dynamic_cast<TLeafC*>(toolfChain->GetLeaf(name));
    pt = l->GetValueString();
  }


  //================================================================================= addLeafString
  void addLeafString(TChain *chain, TString name, TString &pt, Long64_t jentry=0){
    chain->SetBranchStatus(name + "*", 1);
    chain->GetEntry(jentry);
    TLeafC *l = dynamic_cast<TLeafC*>(chain->GetLeaf(name));
    pt = l->GetValueString();
  }
  
  
  //================================================================================= splitToWords
  vector<TString> splitToWords(TString rawString, TString newWord){
    vector<TString> words;
    int pos_beg = 0;
    int pos_end = 0;
    while(pos_beg < rawString.Sizeof()){
      int i;
      for(i=pos_beg; i<rawString.Sizeof(); ++i){
        if(rawString(i,1) == newWord) break;
      }
      pos_end = i;
      words.push_back(rawString(pos_beg, pos_end-pos_beg));
      pos_beg = pos_end+1;
    }
    return words;
  }
  
  
  //================================================================================= splitToWords
  map<TString, TString> splitToWords(TString rawString, TString newWord, TString newValue){
    map<TString, TString> wordsAndValues;
    vector<TString> words;
    int pos_beg = 0;
    int pos_end = 0;
    while(pos_beg < rawString.Sizeof()){
      int i;
      for(i=pos_beg; i<rawString.Sizeof(); ++i){
        if(rawString(i,1) == newWord) break;
      }
      pos_end = i;
      words.push_back(rawString(pos_beg, pos_end-pos_beg));
      pos_beg = pos_end+1;
      vector<TString> temp_words = splitToWords(words.back(), newValue);
      if(temp_words.size()==2)
        wordsAndValues[temp_words[0]] = temp_words[1];
      else if(words[0]!=""){
        cout<<"ERROR: Something is wrong with the String: " << rawString << "  here: " << words.back() << endl; 
      }
    }
    return wordsAndValues;
  }
  
  
  //================================================================================= GetHistFromFile
  //Usage: TH1D* h = myplots.GetHistFromFile<TH1D*>("evaluation.root", "Multiplicity");
  template <typename T>
  T* GetHistFromFile(TString fileName, TString histName){
    T *hist = new T();
    
//     TFile f(fileName);
//     if (f.IsZombie()) {
//       cout << "Error opening file" << endl;
//       exit(-1);
//     }
    TFile *file = new TFile(fileName,"READ");
    if(file->FindObjectAny(histName)) hist = (T*) file->FindObjectAny(histName)->Clone();
    else cout<<"Histogram does not exist! Creating empty histogram: "<< histName << endl;
    //file->Close();
    //delete file;
    return hist;
  }
  
 
//  //================================================================================= GetHistFromFile
//  template <typename T>
//  T* GetHistFromFile(TString fileName, TString histName) {
//    TFile *file = new TFile(fileName,"READ");
//    T* histo = (T*) file->FindObjectAny(histName)->Clone();
//    return histo;
//  }
 
 
  //================================================================================= GetHistFromFile
  template <typename T>
  T* GetHistFromFile(TFile *file, TString histName){
    file->cd();
    T *hist = new T();
    if(file->FindObjectAny(histName)) hist = (T*) file->FindObjectAny(histName);
    else cout<<"Histogram does not exist! Creating empty histogram: "<< histName << endl;
    //file->Close();
    return hist;
  }
  

//   //================================================================================= GetHistFromFile
//   //Usage: TH1D* h = myplots.GetHistFromFile<TH1D*>("evaluation.root", "Multiplicity");
//   template <typename T>
//   T GetHistFromFile(TString fileName, TString histName){
//     TFile *file = new TFile(fileName,"READ");
//     T hist = (T) file->FindObjectAny(histName);
//     //file->Close();
//     return hist;
//   }
//   
//   
//   //================================================================================= GetHistFromFile
//   template <typename T>
//   T GetHistFromFile(TFile *f, TString histName){
//     f->cd();
//     T hist = (T) f->FindObjectAny(histName);
//     //file->Close();
//     return hist;
//   }
  
  
//   //================================================================================= GetValueFromLeaf
//   template <typename T>
//   void GetValueFromLeaf(TString fileName, TString branchName, TString leafName, vector<T> **v, Long64_t entry){
//     TFile *file = new TFile(fileName,"READ");
//     TTree *fChain = (TTree*)file->Get(branchName);
//     //fChain->AddFile(fileName);
//     fChain->SetBranchStatus("*",0);
//     fChain->SetBranchStatus(leafName, 1);
//     *v=0;
//     fChain->SetBranchAddress(leafName, &(*v));
//     fChain->GetEntry(entry);
//   }
  
  
//   //================================================================================= GetValueFromLeaf
//   template <typename T>
//   void GetValueFromLeaf(TString fileName, TString branchName, TString leafName, vector<T> &v, Long64_t entry){
//     TFile *file = new TFile(fileName,"READ");
//     TTree *fChain = (TTree*)file->Get(branchName);
//     //fChain->AddFile(fileName);
//     fChain->SetBranchStatus("*",0);
//     fChain->SetBranchStatus(leafName, 1);
//     vector<T> *pt=&v;
//     fChain->SetBranchAddress(leafName, &(pt));
//     fChain->GetEntry(entry);
//   }
  
  
//   //================================================================================= GetValueFromLeaf
//   template <typename T>
//   void GetValueFromLeaf(TString fileName, TString branchName, TString leafName, T &v, Long64_t entry){
//     cout<<"leafName = "<< leafName<<endl;
//     TFile *file = new TFile(fileName,"READ");
//     TTree *fChain = (TTree*)file->Get(branchName);
//     //fChain->AddFile(fileName);
//     fChain->SetBranchStatus("*",0);
//     fChain->SetBranchStatus(leafName, 1);
//     //T *pt=&v;
//     T *pt=0;
//     pt=&v;
//     
//     fChain->SetBranchAddress(leafName, &pt);
//     fChain->GetEntry(entry);
//   }
  
  
  //================================================================================= GetValueFromLeaf
  template <typename T>
  void GetValueFromLeaf(TString fileName, TString branchName, TString leafName, T &v, Long64_t entry){
    TFile *file = new TFile(fileName,"READ");
    TTree *fChain = (TTree*)file->Get(branchName);
    fChain->SetBranchStatus("*",0);
    fChain->SetBranchStatus(leafName, 1);
    fChain->SetBranchAddress(leafName, &v);
    fChain->GetEntry(entry);
  }
  
  //================================================================================= GetValueFromLeaf
  template <typename T>
  void GetValueFromLeaf(TString fileName, TString branchName, TString leafName, T **v, Long64_t entry){
    TFile *file = new TFile(fileName,"READ");
    TTree *fChain = (TTree*)file->Get(branchName);
    fChain->SetBranchStatus("*",0);
    fChain->SetBranchStatus(leafName, 1);
    //*v=0;
    fChain->SetBranchAddress(leafName, &(*v));
    fChain->GetEntry(entry); 
  }
  
  
  //================================================================================= GetValueFromLeaf
  template <typename T>
  void GetVectorFromLeaf(TString fileName, TString brName, TString leafName, T &v, Long64_t entry){
    TFile *file = new TFile(fileName,"READ");
    TTree *fChain = (TTree*)file->Get(brName);
    fChain->SetBranchStatus("*",0);
    fChain->SetBranchStatus(leafName, 1);
    T *pt=&v;
    fChain->SetBranchAddress(leafName, &pt);
    fChain->GetEntry(entry);
  }
  
  
  //================================================================================= GetValueFromLeaf
  template <typename T>
  void GetVectorFromLeaf(TString fileName, TString branchName, TString leafName, vector<T> **v, Long64_t entry){
    TFile *file = new TFile(fileName,"READ");
    TTree *fChain = (TTree*)file->Get(branchName);
    fChain->SetBranchStatus("*",0);
    fChain->SetBranchStatus(leafName, 1);
    *v=0;
    fChain->SetBranchAddress(leafName, &(*v));
    fChain->GetEntry(entry);
  }
  
  //================================================================================= GetValueFromLeaf
  template <typename T>
  void GetVectorFromLeaf(TFile* file, TString branchName, TString leafName, vector<T> **v, Long64_t entry){
    TTree *fChain = (TTree*)file->Get(branchName);
    fChain->SetBranchStatus("*",0);
    fChain->SetBranchStatus(leafName, 1);
    *v=0;
    fChain->SetBranchAddress(leafName, &(*v));
    fChain->GetEntry(entry);
  }
  
  
  //================================================================================= GetStringFromLeaf
  void GetStringFromLeaf(TString fileName, TString branchName, TString leafName, TString &s, Long64_t entry){
    TFile *file = new TFile(fileName,"READ");
    TTree *t = (TTree*)file->Get(branchName);
    t->GetEntry(entry);
    TLeafC *l = dynamic_cast<TLeafC*>(t->GetLeaf(leafName));
    s = (l->GetValueString());
  }
  
  
  //================================================================================= Swap
  template <typename T>
  void Swap(T &value1, T &value2){
    T dummy;
    dummy  = value1;
    value1 = value2;
    value2 = dummy;
  }
  
  
  //================================================================================= hist_maximum
  double hist_maximum(TH1* h){
    const int i = h->GetMaximumBin();   
    return h->GetBinContent(i) + h->GetBinError(i);
  }
  
  
  //================================================================================= removeDuplicates
  template <typename T>
  void removeDuplicates(vector<T> &v){
    for(UInt_t i=0; i<v.size(); ++i){
      for(UInt_t j=i+1; j<v.size(); ++j){
        if(v[j]==v[i]){
          v.erase(v.begin()+j);
          --j;
        }
      }
    }
  }
  
  
  //================================================================================= GetMinimum
  template <typename T>
  T GetMinimum(vector<T> &v){
    T min = 9999999;
    for(Int_t i=0,N=v.size(); i<N; ++i){
      if(min>v[i]) min = v[i];
    }
    return min;
  }
  
  
  //================================================================================= GetMinimum
  template <typename T1, typename T2>
  T1 GetMinimum(map<T1, T2> &m){
    T1 minkey=0;
    T2 min=9999999;
    for(typename map<T1, T2>::iterator it=m.begin();  it !=m.end(); ++it){
      if(min>it->second){
        minkey = it->first;
        min    = it->second;
      }
    }
    return minkey;
  }
  
  
  //================================================================================= GetMaximum
  template <typename T>
  T GetMaximum(vector<T> &v){
    T max = -9999999;
    for(Int_t i=0,N=v.size(); i<N; ++i){
      if(max<v[i]) max = v[i];
    }
    return max;
  }
  
  
  //================================================================================= GetMinimum
  template <typename T1, typename T2>
  T1 GetMaximum(map<T1, T2> &m){
    T1 maxkey=0;
    T2 max=-9999999;
    for(typename map<T1, T2>::iterator it=m.begin();  it !=m.end(); ++it){
      if(max<it->second){
        maxkey = it->first;
        max    = it->second;
      }
    }
    return maxkey;
  }
    
    
    //================================================================================= adjusth1d
    void adjusth1d(TH1D *h1, TH1D *h2){
      Double_t max1   = h1->GetMaximum();
      Double_t max2   = h2->GetMaximum();
      Double_t min1   = h1->GetMinimum();
      Double_t min2   = h2->GetMinimum();
      Double_t norm1  = h1->GetNormFactor();
      Double_t norm2  = h2->GetNormFactor();
      Double_t scale1 = 1.; //if the histo ist normed to some value, SetUserRange etc. depends on the normalization (which is, of course a root-bug)
      Double_t scale2 = 1.;
      
      if(norm1) scale1 = norm1/h1->Integral();
      if(norm2) scale2 = norm2/h2->Integral();
      max1 *= scale1;
      max2 *= scale2;
      Double_t maximum = max(max1, max2)*1.1;
      Double_t minimum = min(min1, min2)*1.1;
      h1->GetYaxis()->SetRangeUser(minimum/scale1, maximum/scale1);
      h2->GetYaxis()->SetRangeUser(minimum/scale2, maximum/scale2);
      
      //     cout<<"max1 = " << max1 << endl;
      //     cout<<"max2 = " << max2 << endl;
      //     cout<<"norm1 = " << norm1 << endl;
      //     cout<<"norm2 = " << norm2 << endl;
      //     cout<<"h1->GetName()          = " << h1->GetName() << endl;
      //     cout<<"h1->GetMaximum()       = " << h1->GetMaximum() << endl;
      //     cout<<"h1->GetNormFactor()    = " << h1->GetNormFactor() << endl;
      //     cout<<"h1->GetEntries()       = " << h1->GetEntries() << endl;
      //     cout<<"h1->GetMaximumStored() = " << h1->GetMaximumStored() << endl;
      //     cout<<"h1->Integral()         = " << h1->Integral() << endl;
      //     cout<<"hist_maximum(h1)       = " << hist_maximum(h1) << endl;
      //     cout<<"h2->GetName()          = " << h2->GetName() << endl;
      //     cout<<"h2->GetMaximum()       = " << h2->GetMaximum() << endl;
      //     cout<<"h2->GetNormFactor()    = " << h2->GetNormFactor() << endl;
      //     cout<<"h2->GetEntries()       = " << h2->GetEntries() << endl;
      //     cout<<"h2->GetMaximumStored() = " << h2->GetMaximumStored() << endl;
      //     cout<<"h2->Integral()         = " << h2->Integral() << endl;
      //     cout<<"hist_maximum(h2)       = " << hist_maximum(h2) << endl;
      //     cout<<"maximum                = " << maximum << endl;
      //     cout<<endl;
    }
    
    
    //================================================================================= adjusth1d
    void adjusth1d(vector<TH1D*> h){
      vector<Double_t> max, min, norm, scale;
      for(Int_t i=0,N=h.size(); i<N; ++i){
        max .push_back(h[i]->GetMaximum());
        min .push_back(h[i]->GetMinimum());
        norm.push_back(h[i]->GetNormFactor());
        scale.push_back(1.);
        if(norm[i]) scale[i] = norm[i]/h[i]->Integral();
        max[i] *= scale[i];
      }
      Double_t maximum = -99999999.;
      Double_t minimum = 99999999.;
      for(Int_t i=0,N=h.size(); i<N; ++i){
        if(maximum < max[i]) maximum = max[i];
        if(minimum > min[i]) minimum = min[i];
      }
      maximum*=1.1;
      minimum*=1.1;
      for(Int_t i=0,N=h.size(); i<N; ++i){
        h[i]->GetYaxis()->SetRangeUser(minimum/scale[i], maximum/scale[i]);
      }
    }
    
  
  //================================================================================= printMap
  template<typename T1, typename T2>
  void printMap(map<T1, T2> m){
    cout<<"size = " << m.size() << endl;
    for(typename map<T1, T2>::iterator it=m.begin();  it !=m.end(); ++it){
      cout<<it->first << " = " << it->second << endl;
    }
  }
  
  //================================================================================= printMap
  template<typename T1, typename T2, typename T3>
  void printMap(TString name, map<T1, map<T2, T3> > m, Int_t width1=10, Int_t width2=10){
    cout<<"size = " << m.size() << endl;
    for(typename map<T1, map<T2, T3> >::iterator it=m.begin();  it !=m.end(); ++it){
      for(typename map<T2, T3>::iterator it2=m[it->first].begin();  it2!=m[it->first].end(); ++it2){
        cout<<name<<"["
        <<setw(width1)<<it ->first << "][" 
        <<setw(width2)<<it2->first << "] = "
        <<it2->second 
        <<endl;
      }
    }
  }
  
  
  //================================================================================= printMap
  template<typename T1, typename T2>
  void printMap(map<T1, T2> m, Int_t setWidth){
    cout<<"size = " << m.size() << endl;
    for(typename map<T1, T2>::iterator it=m.begin();  it !=m.end(); ++it){
      cout<<setw(setWidth)<<it->first << " = " << it->second << endl;
    }
  }
 
 
 //================================================================================= FillVectorFromFile
 template<typename T>
 vector<T> FillVectorFromFile(TString fileName){
   vector<T> v;
   ifstream file(fileName);
   TString s;
   while(!file.eof()){
     file >> s;
     stringstream xmorph;
     xmorph << s;
     T my;
     xmorph >> my;
     v.push_back(my);
     //cout<<"myint = "<< my << endl;
   }
   return v;
 }
 
 
 //================================================================================= FillVectorFromFile
 template<typename T>
 vector<T> FillVectorFromLs(TString path, TString name){
   vector<T> v;
   TString command="";
   command="ls ";
   command+= path;
   command+=name;
   command+=" > tempLsCommand.txt";   
   system(command);
   //cout<<"command = " << command << endl;
   v = tools::FillVectorFromFile<TString>("tempLsCommand.txt");
   v.erase(v.end()-1);
   //------------------------------------ remove the path from file names
   for(Int_t i=0,N=v.size(); i<N; ++i) v[i].ReplaceAll(path, "");
//    system("rm tempLsCommand.txt");
   return v;
 }
 
 
 //================================================================================= save
 template<typename T>
 void save(map<TString, T> m, TString fileName, TString option="RECREATE"){
   TFile *file = new TFile(fileName, option);
   for(typename map<TString, T>::iterator it = m.begin(); it != m.end(); ++it){
     it->second->Write(it->second->GetName());
   }
   file->Close();
 }
 
 //================================================================================= createDir
 void createDir(TString folderName){
   Int_t dummy = system("mkdir " + folderName + " -p");
   dummy=1;
 }
 
 
 //================================================================================= createRatioPlot
 template <typename T>
 T* createRatioPlot(T* h1, T* h2, TString name="", TString yTitle=""){
   T* ratioPlot = (T*)h1->Clone();
   ratioPlot->Divide(h2);
   if(name !=""){
     ratioPlot->SetName(name);
     ratioPlot->SetTitle(name);
   }
   if(yTitle!=""){
     ratioPlot->GetYaxis()->SetTitle(yTitle);
   }
   return ratioPlot;
 }
 
 
 //================================================================================= isNew
 template <typename T>
 Bool_t isNew(TString name, map<TString, T> m){
   return (m.find(name) == m.end());
 }
 
 
 //================================================================================= isNew
 template <typename T1, typename T2>
 Bool_t isNew(TString name, map<TString, map<T1, T2> > m){
   return (m.find(name) == m.end());
 }
 
//  map<TString, map<TString, map<Int_t, Double_t> > > eventYield; 
 
 
 //================================================================================= isNew
 template <typename T>
 Bool_t isNew(TString name, TString label, map<TString,  map<TString, T> > m){
   return (m[name].find(label) == m[name].end());
 }
 
 
 //================================================================================= isNew
 template <typename T>
 Bool_t isNew(T find, vector<T> v){
   for(Int_t i=0,N=v.size(); i<N; ++i){
     if(v[i]==find) return false;
   }
   return true;
 }
 
 
 //================================================================================= GetValueFromTH1
 template <typename T>
 Double_t GetBinFromTH1(T *h, Double_t value){
   Double_t maxValue = h->GetXaxis()->GetXmax();
   Int_t xMaxBin     = h->GetNbinsX();
   Int_t xBin        = 0;
   if(value > maxValue) xBin = xMaxBin;
   else{while(value > h->GetXaxis()->GetBinLowEdge(xBin+1)) ++xBin;}
   
   for(Int_t i=0; i<xMaxBin; ++i){
     cout<<"bin[" <<i<< "] = " << h->GetBinContent(i)<< endl;
   }
   cout<<"xBin = " << endl;
   return xBin;
 }
 

//================================================================================= GetValueFromTH1
 template <typename T>
 Double_t GetValueFromTH1(T *h, Double_t value){
   Int_t bin = GetBinFromTH1<T>(h, value);
   return h->GetBinContent(bin);
 }
 
 
 //================================================================================= GetBinFromTH2
 template <typename T>
 void GetBinFromTH2(T *h, Int_t &xBin, Int_t &yBin, Double_t value1, Double_t value2){
   Double_t xMaxValue = h->GetXaxis()->GetXmax();
   Double_t yMaxValue = h->GetYaxis()->GetXmax();
   Int_t xMaxBin      = h->GetNbinsX();
   Int_t yMaxBin      = h->GetNbinsY();
   xBin               = 0;
   yBin               = 0;
   if(value1 > xMaxValue) xBin = xMaxBin;
   else{while(value1 > h->GetXaxis()->GetBinLowEdge(xBin+1)) ++xBin;}
   if(value2 > yMaxValue) yBin = yMaxBin;
   else{while(value2 > h->GetYaxis()->GetBinLowEdge(yBin+1)) ++yBin;}
 }
 
 
 //================================================================================= GetValueFromTH2
 template <typename T>
 Double_t GetValueFromTH2(T *h, Double_t value1, Double_t value2){
   Int_t xBin = 0;
   Int_t yBin = 0;
   GetBinFromTH2<T>(h, xBin, yBin, value1, value2);
   return h->GetBinContent(xBin, yBin);
 }


}


#endif


// //================================================================================= GetValueFromLeaf
// template <typename T>
// void GetValueFromLeafPtr(TString fileName, TString branchName, TString leafName, vector<T> **ptr, Long64_t entry){
  //   TFile *file = new TFile(fileName,"READ");
  //   TTree *fChain = (TTree*)file->Get(branchName);
  //   //fChain->AddFile(fileName);
  //   fChain->SetBranchStatus("*",0);
  //   fChain->SetBranchStatus(leafName, 1);
  //   //*ptr=0;
  //   fChain->SetBranchAddress(leafName, &(*ptr));
  //   fChain->GetEntry(entry);
  // }
  
  //   //================================================================================= GetValueFromLeaf
  //   template <typename T>
  //   vector<T> GetValueFromLeaf(TString fileName, TString branchName, TString leafName, Long64_t entry){
    //     TFile *file = new TFile(fileName,"READ");
    //     TTree *fChain = (TTree*)file->Get(branchName);
    //     vector<T> *value;
    //     //fChain->AddFile(fileName);
    //     fChain->SetBranchStatus("*",0);
    //     fChain->SetBranchStatus(leafName, 1);
    //     fChain->SetBranchAddress(leafName, &(*value));
    //     fChain->GetEntry(entry);
    //     return &(*value);
    //   }
    

Revision:	1.1
Committed:	Thu Nov 22 15:32:47 2012 UTC (12 years, 5 months ago) by mstein
Content type:	text/plain
Branch:	MAIN
CVS Tags:	v1
Log Message:	first skeleton