ROOT logo
#ifndef ALIBALANCEEVENTMIXING_H
#define ALIBALANCEEVENTMIXING_H
/*  See cxx source for full Copyright notice */


//-------------------------------------------------------------------------
//                          Class AliBalanceEventMixing
//   This is the class for the Balance Function analysis
//
//    Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
//    Modified: Michael Weber, m.weber@cern.ch
//-------------------------------------------------------------------------

#include <vector>
#include <TObject.h>
#include "TString.h"

using std::vector;

#define ANALYSIS_TYPES	7
#define MAXIMUM_NUMBER_OF_STEPS	1024

class TGraphErrors;
class TH1D;
class TH2D;

class AliBalanceEventMixing : public TObject {
 public:
  enum EAnalysisType {
    kRapidity = 0, 
    kEta      = 1, 
    kQlong    = 2, 
    kQout     = 3, 
    kQside    = 4, 
    kQinv     = 5, 
    kPhi      = 6 
  };

  AliBalanceEventMixing();
  AliBalanceEventMixing(const AliBalanceEventMixing& balance);
  ~AliBalanceEventMixing();

  void SetCentralityIdentifier(const char* centralityId) {
    fCentralityId = centralityId;}
  
  void SetAnalysisLevel(const char* analysisLevel) {
    fAnalysisLevel = analysisLevel;}
  void SetShuffle(Bool_t shuffle) {fShuffle = shuffle;}
  void SetHBTcut(Bool_t HBTcut) {fHBTcut = HBTcut;}
  void SetConversionCut(Bool_t ConversionCut) {fConversionCut = ConversionCut;}
  void SetInterval(Int_t iAnalysisType, Double_t p1Start, Double_t p1Stop,
		   Int_t ibins, Double_t p2Start, Double_t p2Stop);
  void SetCentralityInterval(Double_t cStart, Double_t cStop)  { fCentStart = cStart; fCentStop = cStop;};
  void SetNp(Int_t analysisType, Double_t NpSet)   { fNp[analysisType] = NpSet; }
  void SetNn(Int_t analysisType, Double_t NnSet)   { fNn[analysisType] = NnSet; }
  void SetNpp(Int_t analysisType, Int_t ibin, Double_t NppSet) { if(ibin > -1 && ibin < MAXIMUM_NUMBER_OF_STEPS) fNpp[analysisType][ibin] = NppSet; }
  void SetNpn(Int_t analysisType, Int_t ibin, Double_t NpnSet) { if(ibin > -1 && ibin < MAXIMUM_NUMBER_OF_STEPS) fNpn[analysisType][ibin] = NpnSet; }
  void SetNnp(Int_t analysisType, Int_t ibin, Double_t NnpSet) { if(ibin > -1 && ibin < MAXIMUM_NUMBER_OF_STEPS) fNnp[analysisType][ibin] = NnpSet; }
  void SetNnn(Int_t analysisType, Int_t ibin, Double_t NnnSet) { if(ibin > -1 && ibin < MAXIMUM_NUMBER_OF_STEPS) fNnn[analysisType][ibin] = NnnSet; }

  void InitHistograms(void);

  const char* GetAnalysisLevel() {return fAnalysisLevel.Data();}
  Int_t GetNumberOfAnalyzedEvent()  const {return fAnalyzedEvents;}

  Int_t GetNumberOfBins(Int_t ibin) const {return fNumberOfBins[ibin];}
  Double_t GetP1Start(Int_t ibin)   const {return fP1Start[ibin];}
  Double_t GetP1Stop(Int_t ibin)    const {return fP1Stop[ibin];}   
  Double_t GetP2Start(Int_t ibin)   const {return fP2Start[ibin];}
  Double_t GetP2Stop(Int_t ibin)    const {return fP2Stop[ibin];}    
 
  Double_t GetNp(Int_t analysisType) const { return 1.0*fNp[analysisType]; }
  Double_t GetNn(Int_t analysisType) const { return 1.0*fNn[analysisType]; }
  Double_t GetNnn(Int_t analysisType, Int_t p2) const { 
    return 1.0*fNnn[analysisType][p2]; }
  Double_t GetNpp(Int_t analysisType, Int_t p2) const { 
    return 1.0*fNpp[analysisType][p2]; }
  Double_t GetNpn(Int_t analysisType, Int_t p2) const { 
    return 1.0*fNpn[analysisType][p2]; }  
  Double_t GetNnp(Int_t analysisType, Int_t p2) const { 
    return 1.0*fNnp[analysisType][p2]; }

  void CalculateBalance(Float_t fCentrality, vector<Double_t> **chargeVector,Int_t iMainTrack = -1,Float_t bSign = 0.);
  
  Double_t GetBalance(Int_t a, Int_t p2);
  Double_t GetError(Int_t a, Int_t p2);

  TH2D *GetHistNp(Int_t iAnalysisType)  const { return fHistP[iAnalysisType];}
  TH2D *GetHistNn(Int_t iAnalysisType)  const { return fHistN[iAnalysisType];}
  TH2D *GetHistNpn(Int_t iAnalysisType) const { return fHistPN[iAnalysisType];}
  TH2D *GetHistNnp(Int_t iAnalysisType) const { return fHistNP[iAnalysisType];}
  TH2D *GetHistNpp(Int_t iAnalysisType) const { return fHistPP[iAnalysisType];}
  TH2D *GetHistNnn(Int_t iAnalysisType) const { return fHistNN[iAnalysisType];}

  void PrintAnalysisSettings();
  TGraphErrors *DrawBalance(Int_t fAnalysisType);

  void SetHistNp(Int_t iAnalysisType, TH2D *gHist) { 
    fHistP[iAnalysisType] = gHist;}
  void SetHistNn(Int_t iAnalysisType, TH2D *gHist) { 
    fHistN[iAnalysisType] = gHist;}
  void SetHistNpn(Int_t iAnalysisType, TH2D *gHist) { 
    fHistPN[iAnalysisType] = gHist;}
  void SetHistNnp(Int_t iAnalysisType, TH2D *gHist) { 
    fHistNP[iAnalysisType] = gHist;}
  void SetHistNpp(Int_t iAnalysisType, TH2D *gHist) { 
    fHistPP[iAnalysisType] = gHist;}
  void SetHistNnn(Int_t iAnalysisType, TH2D *gHist) { 
    fHistNN[iAnalysisType] = gHist;}

  TH1D *GetBalanceFunctionHistogram(Int_t iAnalysisType,Double_t centrMin, Double_t centrMax, Double_t etaWindow = -1);
  void PrintResults(Int_t iAnalysisType, TH1D *gHist);

 private:
  inline Float_t GetDPhiStar(Float_t phi1, Float_t pt1, Float_t charge1, Float_t phi2, Float_t pt2, Float_t charge2, Float_t radius, Float_t bSign); 

  Bool_t fShuffle; //shuffled balance function object
  Bool_t fHBTcut;  // apply HBT like cuts
  Bool_t fConversionCut;  // apply conversion cuts

  TString fAnalysisLevel; //ESD, AOD or MC
  Int_t fAnalyzedEvents; //number of events that have been analyzed

  TString fCentralityId;//Centrality identifier to be used for the histo naming

  Int_t fNumberOfBins[ANALYSIS_TYPES];//number of bins of the analyzed interval
  Double_t fP1Start[ANALYSIS_TYPES];//lower boundaries for single particle histograms 
  Double_t fP1Stop[ANALYSIS_TYPES];//upper boundaries for single particle histograms 
  Double_t fP2Start[ANALYSIS_TYPES];//lower boundaries for pair histograms 
  Double_t fP2Stop[ANALYSIS_TYPES];//upper boundaries for pair histograms 
  Double_t fP2Step[ANALYSIS_TYPES];//bin size for pair histograms 
  Double_t fCentStart;//lower boundary for centrality
  Double_t fCentStop;//upper boundary for centrality

 	
  Double_t fNnn[ANALYSIS_TYPES][MAXIMUM_NUMBER_OF_STEPS]; //N(--)
  Double_t fNpp[ANALYSIS_TYPES][MAXIMUM_NUMBER_OF_STEPS]; //N(++)
  Double_t fNpn[ANALYSIS_TYPES][MAXIMUM_NUMBER_OF_STEPS]; //N(+-)
  Double_t fNnp[ANALYSIS_TYPES][MAXIMUM_NUMBER_OF_STEPS]; //N(-+)
  Double_t fNn[ANALYSIS_TYPES], fNp[ANALYSIS_TYPES]; //number of pos./neg. inside the analyzed interval
  
  Double_t fB[ANALYSIS_TYPES][MAXIMUM_NUMBER_OF_STEPS]; //BF matrix
  Double_t ferror[ANALYSIS_TYPES][MAXIMUM_NUMBER_OF_STEPS]; //error of the BF
  
  TH2D *fHistP[ANALYSIS_TYPES]; //N+
  TH2D *fHistN[ANALYSIS_TYPES]; //N-
  TH2D *fHistPN[ANALYSIS_TYPES]; //N+-
  TH2D *fHistNP[ANALYSIS_TYPES]; //N-+
  TH2D *fHistPP[ANALYSIS_TYPES]; //N++
  TH2D *fHistNN[ANALYSIS_TYPES]; //N--

  AliBalanceEventMixing & operator=(const AliBalanceEventMixing & ) {return *this;}

  ClassDef(AliBalanceEventMixing, 1)
};

Float_t AliBalanceEventMixing::GetDPhiStar(Float_t phi1, Float_t pt1, Float_t charge1, Float_t phi2, Float_t pt2, Float_t charge2, Float_t radius, Float_t bSign)
{ 
  //
  // calculates dphistar
  //
  
  Float_t dphistar = phi1 - phi2 - charge1 * bSign * TMath::ASin(0.075 * radius / pt1) + charge2 * bSign * TMath::ASin(0.075 * radius / pt2);
  
  static const Double_t kPi = TMath::Pi();
  
  // circularity
//   if (dphistar > 2 * kPi)
//     dphistar -= 2 * kPi;
//   if (dphistar < -2 * kPi)
//     dphistar += 2 * kPi;
  
  if (dphistar > kPi)
    dphistar = kPi * 2 - dphistar;
  if (dphistar < -kPi)
    dphistar = -kPi * 2 - dphistar;
  if (dphistar > kPi) // might look funny but is needed
    dphistar = kPi * 2 - dphistar;
  
  return dphistar;
}

#endif
 AliBalanceEventMixing.h:1
 AliBalanceEventMixing.h:2
 AliBalanceEventMixing.h:3
 AliBalanceEventMixing.h:4
 AliBalanceEventMixing.h:5
 AliBalanceEventMixing.h:6
 AliBalanceEventMixing.h:7
 AliBalanceEventMixing.h:8
 AliBalanceEventMixing.h:9
 AliBalanceEventMixing.h:10
 AliBalanceEventMixing.h:11
 AliBalanceEventMixing.h:12
 AliBalanceEventMixing.h:13
 AliBalanceEventMixing.h:14
 AliBalanceEventMixing.h:15
 AliBalanceEventMixing.h:16
 AliBalanceEventMixing.h:17
 AliBalanceEventMixing.h:18
 AliBalanceEventMixing.h:19
 AliBalanceEventMixing.h:20
 AliBalanceEventMixing.h:21
 AliBalanceEventMixing.h:22
 AliBalanceEventMixing.h:23
 AliBalanceEventMixing.h:24
 AliBalanceEventMixing.h:25
 AliBalanceEventMixing.h:26
 AliBalanceEventMixing.h:27
 AliBalanceEventMixing.h:28
 AliBalanceEventMixing.h:29
 AliBalanceEventMixing.h:30
 AliBalanceEventMixing.h:31
 AliBalanceEventMixing.h:32
 AliBalanceEventMixing.h:33
 AliBalanceEventMixing.h:34
 AliBalanceEventMixing.h:35
 AliBalanceEventMixing.h:36
 AliBalanceEventMixing.h:37
 AliBalanceEventMixing.h:38
 AliBalanceEventMixing.h:39
 AliBalanceEventMixing.h:40
 AliBalanceEventMixing.h:41
 AliBalanceEventMixing.h:42
 AliBalanceEventMixing.h:43
 AliBalanceEventMixing.h:44
 AliBalanceEventMixing.h:45
 AliBalanceEventMixing.h:46
 AliBalanceEventMixing.h:47
 AliBalanceEventMixing.h:48
 AliBalanceEventMixing.h:49
 AliBalanceEventMixing.h:50
 AliBalanceEventMixing.h:51
 AliBalanceEventMixing.h:52
 AliBalanceEventMixing.h:53
 AliBalanceEventMixing.h:54
 AliBalanceEventMixing.h:55
 AliBalanceEventMixing.h:56
 AliBalanceEventMixing.h:57
 AliBalanceEventMixing.h:58
 AliBalanceEventMixing.h:59
 AliBalanceEventMixing.h:60
 AliBalanceEventMixing.h:61
 AliBalanceEventMixing.h:62
 AliBalanceEventMixing.h:63
 AliBalanceEventMixing.h:64
 AliBalanceEventMixing.h:65
 AliBalanceEventMixing.h:66
 AliBalanceEventMixing.h:67
 AliBalanceEventMixing.h:68
 AliBalanceEventMixing.h:69
 AliBalanceEventMixing.h:70
 AliBalanceEventMixing.h:71
 AliBalanceEventMixing.h:72
 AliBalanceEventMixing.h:73
 AliBalanceEventMixing.h:74
 AliBalanceEventMixing.h:75
 AliBalanceEventMixing.h:76
 AliBalanceEventMixing.h:77
 AliBalanceEventMixing.h:78
 AliBalanceEventMixing.h:79
 AliBalanceEventMixing.h:80
 AliBalanceEventMixing.h:81
 AliBalanceEventMixing.h:82
 AliBalanceEventMixing.h:83
 AliBalanceEventMixing.h:84
 AliBalanceEventMixing.h:85
 AliBalanceEventMixing.h:86
 AliBalanceEventMixing.h:87
 AliBalanceEventMixing.h:88
 AliBalanceEventMixing.h:89
 AliBalanceEventMixing.h:90
 AliBalanceEventMixing.h:91
 AliBalanceEventMixing.h:92
 AliBalanceEventMixing.h:93
 AliBalanceEventMixing.h:94
 AliBalanceEventMixing.h:95
 AliBalanceEventMixing.h:96
 AliBalanceEventMixing.h:97
 AliBalanceEventMixing.h:98
 AliBalanceEventMixing.h:99
 AliBalanceEventMixing.h:100
 AliBalanceEventMixing.h:101
 AliBalanceEventMixing.h:102
 AliBalanceEventMixing.h:103
 AliBalanceEventMixing.h:104
 AliBalanceEventMixing.h:105
 AliBalanceEventMixing.h:106
 AliBalanceEventMixing.h:107
 AliBalanceEventMixing.h:108
 AliBalanceEventMixing.h:109
 AliBalanceEventMixing.h:110
 AliBalanceEventMixing.h:111
 AliBalanceEventMixing.h:112
 AliBalanceEventMixing.h:113
 AliBalanceEventMixing.h:114
 AliBalanceEventMixing.h:115
 AliBalanceEventMixing.h:116
 AliBalanceEventMixing.h:117
 AliBalanceEventMixing.h:118
 AliBalanceEventMixing.h:119
 AliBalanceEventMixing.h:120
 AliBalanceEventMixing.h:121
 AliBalanceEventMixing.h:122
 AliBalanceEventMixing.h:123
 AliBalanceEventMixing.h:124
 AliBalanceEventMixing.h:125
 AliBalanceEventMixing.h:126
 AliBalanceEventMixing.h:127
 AliBalanceEventMixing.h:128
 AliBalanceEventMixing.h:129
 AliBalanceEventMixing.h:130
 AliBalanceEventMixing.h:131
 AliBalanceEventMixing.h:132
 AliBalanceEventMixing.h:133
 AliBalanceEventMixing.h:134
 AliBalanceEventMixing.h:135
 AliBalanceEventMixing.h:136
 AliBalanceEventMixing.h:137
 AliBalanceEventMixing.h:138
 AliBalanceEventMixing.h:139
 AliBalanceEventMixing.h:140
 AliBalanceEventMixing.h:141
 AliBalanceEventMixing.h:142
 AliBalanceEventMixing.h:143
 AliBalanceEventMixing.h:144
 AliBalanceEventMixing.h:145
 AliBalanceEventMixing.h:146
 AliBalanceEventMixing.h:147
 AliBalanceEventMixing.h:148
 AliBalanceEventMixing.h:149
 AliBalanceEventMixing.h:150
 AliBalanceEventMixing.h:151
 AliBalanceEventMixing.h:152
 AliBalanceEventMixing.h:153
 AliBalanceEventMixing.h:154
 AliBalanceEventMixing.h:155
 AliBalanceEventMixing.h:156
 AliBalanceEventMixing.h:157
 AliBalanceEventMixing.h:158
 AliBalanceEventMixing.h:159
 AliBalanceEventMixing.h:160
 AliBalanceEventMixing.h:161
 AliBalanceEventMixing.h:162
 AliBalanceEventMixing.h:163
 AliBalanceEventMixing.h:164
 AliBalanceEventMixing.h:165
 AliBalanceEventMixing.h:166
 AliBalanceEventMixing.h:167
 AliBalanceEventMixing.h:168
 AliBalanceEventMixing.h:169
 AliBalanceEventMixing.h:170
 AliBalanceEventMixing.h:171
 AliBalanceEventMixing.h:172
 AliBalanceEventMixing.h:173
 AliBalanceEventMixing.h:174
 AliBalanceEventMixing.h:175
 AliBalanceEventMixing.h:176
 AliBalanceEventMixing.h:177
 AliBalanceEventMixing.h:178
 AliBalanceEventMixing.h:179
 AliBalanceEventMixing.h:180
 AliBalanceEventMixing.h:181
 AliBalanceEventMixing.h:182
 AliBalanceEventMixing.h:183