PWG2/FLOW/AliFlowCommon/AliFlowAnalysisWithCumulants.h

   1 /*
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.
   3  * See cxx source for full Copyright notice
   4  * $Id$
   5  */
   6
   7 /*************************************************
   8  * Flow analysis with cumulants. In this class   *
   9  * cumulants are calculated by making use of the *
  10  * formalism of generating functions proposed by *
  11  * Ollitrault et al.                             *
  12  *                                               *
  13  *      Author: Ante Bilandzic                   *
  14  *              (abilandzic@gmail.com)           *
  15  *************************************************/
  16
  17 #ifndef ALIFLOWANALYSISWITHCUMULANTS_H
  18 #define ALIFLOWANALYSISWITHCUMULANTS_H
  19
  20 #include "AliFlowCommonConstants.h"
  21 #include "TMatrixD.h"
  22
  23 class TList;
  24 class TFile;
  25
  26 class TH1D;
  27 class TH1F;
  28 class TProfile;
  29 class TProfile2D;
  30 class TProfile3D;
  31 class TDirectoryFile;
  32
  33 class AliFlowEventSimple;
  34 class AliFlowTrackSimple;
  35 class AliFlowCommonHist;
  36 class AliFlowCommonHistResults;
  37 class AliFlowVector;
  38
  39 //================================================================================================================
  40
  41 class AliFlowAnalysisWithCumulants{
  42  public:
  43   AliFlowAnalysisWithCumulants();
  44   virtual ~AliFlowAnalysisWithCumulants();
  45   // 0.) Methods called in the constructor:
  46     virtual void InitializeArrays();
  47   // 1.) Method Init() and methods called within Init():
  48   virtual void Init();
  49     virtual void CrossCheckSettings();
  50     virtual void AccessConstants();
  51     virtual void BookAndNestAllLists();
  52     virtual void BookProfileHoldingSettings();
  53     virtual void BookCommonHistograms();
  54     virtual void BookAndFillWeightsHistograms();
  55     virtual void BookEverythingForReferenceFlow();
  56     virtual void BookEverythingForDiffFlow();
  57     virtual void StoreReferenceFlowFlags();
  58     virtual void StoreDiffFlowFlags();
  59     virtual void BookEverythingForTuning();
  60   // 2.) Method Make() and methods called within Make():
  61   virtual void Make(AliFlowEventSimple* anEvent);
  62      virtual void CheckPointersUsedInMake();
  63      virtual void FillGeneratingFunctionForReferenceFlow(AliFlowEventSimple *anEvent);
  64      virtual void FillQvectorComponents(AliFlowEventSimple *anEvent);
  65      virtual void FillGeneratingFunctionForDiffFlow(AliFlowEventSimple *anEvent);
  66      virtual void FillGeneratingFunctionsForDifferentTuningParameters(AliFlowEventSimple *anEvent);
  67   // 3.) Method Finish() and methods called within Finish():
  68   virtual void Finish();
  69     virtual void CheckPointersUsedInFinish();
  70     virtual void AccessSettings();
  71     virtual void GetAvMultAndNoOfEvts();
  72     virtual void CalculateCumulantsForReferenceFlow();
  73     virtual void CalculateReferenceFlow();
  74     virtual void CalculateReferenceFlowError();
  75     virtual void FillCommonHistResultsForReferenceFlow();
  76     virtual void CalculateCumulantsForDiffFlow(TString rpPoi,TString ptEta);
  77     virtual void CalculateDifferentialFlow(TString rpPoi,TString ptEta);
  78     virtual void CalculateDifferentialFlowErrors(TString rpPoi,TString ptEta);
  79     virtual void FillCommonHistResultsForDifferentialFlow(TString rpPoi);
  80     virtual void CalculateIntegratedFlow(TString rpPoi); // to be improved (add also possibility to integrate over eta yield)
  81     virtual void PrintFinalResults(TString rpPoi);
  82     virtual void FinalizeTuning();
  83   // 4.) Method GetOutputHistograms() and method called within it:
  84   virtual void GetOutputHistograms(TList *outputListHistos);
  85     virtual void GetPointersForBaseHistograms();
  86     virtual void GetPointersForCommonControlHistograms();
  87     virtual void GetPointersForCommonResultsHistograms();
  88     virtual void GetPointersForParticleWeightsHistograms();
  89     virtual void GetPointersForReferenceFlowObjects();
  90     virtual void GetPointersForDiffFlowObjects();
  91   virtual void WriteHistograms(TString *outputFileName);
  92   virtual void WriteHistograms(TString outputFileName);
  93   virtual void WriteHistograms(TDirectoryFile *outputFileName);
  94   // 5.) Other methods:
  95   //     ...
  96   // 6.) Setters and getters:
  97   //  6.0.) base:
  98   void SetHistList(TList* const hl) {this->fHistList = hl;}
  99   TList* GetHistList() const {return this->fHistList;}
 100   void SetHistListName(const char *hln) {this->fHistListName->Append(*hln);};
 101   TString *GetHistListName() const {return this->fHistListName;};
 102   void SetAnalysisSettings(TProfile* const as) {this->fAnalysisSettings = as;};
 103   TProfile* GetAnalysisSettings() const {return this->fAnalysisSettings;};
 104   //  6.1.) common:
 105   void SetCommonHists(AliFlowCommonHist* const ch) {this->fCommonHists = ch;};
 106   AliFlowCommonHist* GetCommonHists() const {return this->fCommonHists;};
 107   void SetCommonHistsResults2nd(AliFlowCommonHistResults* const chr2nd) {this->fCommonHistsResults2nd = chr2nd;};
 108   AliFlowCommonHistResults* GetCommonHistsResults2nd() const {return this->fCommonHistsResults2nd;};
 109   void SetCommonHistsResults4th(AliFlowCommonHistResults* const chr4th) {this->fCommonHistsResults4th = chr4th;};
 110   AliFlowCommonHistResults* GetCommonHistsResults4th() const {return this->fCommonHistsResults4th;};
 111   void SetCommonHistsResults6th(AliFlowCommonHistResults* const chr6th) {this->fCommonHistsResults6th = chr6th;};
 112   AliFlowCommonHistResults* GetCommonHistsResults6th() const {return this->fCommonHistsResults6th;};
 113   void SetCommonHistsResults8th(AliFlowCommonHistResults* const chr8th) {this->fCommonHistsResults8th = chr8th;};
 114   AliFlowCommonHistResults* GetCommonHistsResults8th() const {return this->fCommonHistsResults8th;};
 115   void SetHarmonic(Int_t const harmonic) {this->fHarmonic = harmonic;};
 116   Int_t GetHarmonic() const {return this->fHarmonic;};
 117   void SetMultiple(Int_t const multiple) {this->fMultiple = multiple;};
 118   Int_t GetMultiple() const {return this->fMultiple;};
 119   void SetR0(Double_t const r0) {this->fR0 = r0;};
 120   Double_t GetR0() const {return this->fR0;};
 121   void SetPrintFinalResults(Bool_t const printOrNot, Int_t const i) {this->fPrintFinalResults[i] = printOrNot;};
 122   Bool_t GetPrintFinalResults(Int_t i) const {return this->fPrintFinalResults[i];};
 123   //  6.2.0.) particle weights:
 124   void SetWeightsList(TList* const wlist) {this->fWeightsList = (TList*)wlist->Clone();}
 125   TList* GetWeightsList() const {return this->fWeightsList;}
 126   void SetUsePhiWeights(Bool_t const uPhiW) {this->fUsePhiWeights = uPhiW;};
 127   Bool_t GetUsePhiWeights() const {return this->fUsePhiWeights;};
 128   void SetUsePtWeights(Bool_t const uPtW) {this->fUsePtWeights = uPtW;};
 129   Bool_t GetUsePtWeights() const {return this->fUsePtWeights;};
 130   void SetUseEtaWeights(Bool_t const uEtaW) {this->fUseEtaWeights = uEtaW;};
 131   Bool_t GetUseEtaWeights() const {return this->fUseEtaWeights;};
 132   void SetUseParticleWeights(TProfile* const uPW) {this->fUseParticleWeights = uPW;};
 133   TProfile* GetUseParticleWeights() const {return this->fUseParticleWeights;};
 134   void SetPhiWeights(TH1F* const histPhiWeights) {this->fPhiWeights = histPhiWeights;};
 135   TH1F* GetPhiWeights() const {return this->fPhiWeights;};
 136   void SetPtWeights(TH1D* const histPtWeights) {this->fPtWeights = histPtWeights;};
 137   TH1D* GetPtWeights() const {return this->fPtWeights;};
 138   void SetEtaWeights(TH1D* const histEtaWeights) {this->fEtaWeights = histEtaWeights;};
 139   TH1D* GetEtaWeights() const {return this->fEtaWeights;};
 140   //  6.2.1.) event weights:
 141   void SetMultiplicityWeight(const char *multiplicityWeight) {*this->fMultiplicityWeight = multiplicityWeight;};
 142   //  6.3.) reference flow:
 143   void SetReferenceFlowFlags(TProfile* const rff) {this->fReferenceFlowFlags = rff;};
 144   TProfile* GetReferenceFlowFlags() const {return this->fReferenceFlowFlags;};
 145   void SetnBinsMult(Int_t const nbm) {this->fnBinsMult = nbm;};
 146   Int_t GetnBinsMult() const {return this->fnBinsMult;};
 147   void SetMinMult(Double_t const minm) {this->fMinMult = minm;};
 148   Double_t GetMinMult() const {return this->fMinMult;};
 149   void SetMaxMult(Double_t const maxm) {this->fMaxMult = maxm;};
 150   Double_t GetMaxMult() const {return this->fMaxMult;};
 151   //  6.3.0.) profiles:
 152   void SetReferenceFlowGenFun(TProfile2D* const rfgf) {this->fReferenceFlowGenFun = rfgf;};
 153   TProfile2D* GetReferenceFlowGenFun() const {return this->fReferenceFlowGenFun;};
 154   void SetQvectorComponents(TProfile* const qvc) {this->fQvectorComponents = qvc;};
 155   TProfile* GetQvectorComponents() const {return this->fQvectorComponents;};
 156   void SetAverageOfSquaredWeight(TProfile* const aosw) {this->fAverageOfSquaredWeight = aosw;};
 157   TProfile* GetSumOfSquaredWeight() const {return this->fAverageOfSquaredWeight;};
 158   //  6.3.1.) results:
 159   void SetReferenceFlowCumulants(TH1D* const rfc) {this->fReferenceFlowCumulants = rfc;};
 160   TH1D* GetReferenceFlowCumulants() const {return this->fReferenceFlowCumulants;};
 161   void SetReferenceFlow(TH1D* const rf) {this->fReferenceFlow = rf;};
 162   TH1D* GetReferenceFlow() const {return this->fReferenceFlow;};
 163   void SetChi(TH1D* const c) {this->fChi = c;};
 164   TH1D* GetChi() const {return this->fChi;};
 165   // 6.4.) differential flow:
 166   void SetDiffFlowFlags(TProfile* const dff) {this->fDiffFlowFlags = dff;};
 167   TProfile* GetDiffFlowFlags() const {return this->fDiffFlowFlags;};
 168   //  6.4.0.) profiles:
 169   void SetDiffFlowGenFun(TProfile3D* const dfgf, Int_t const ri, Int_t const rp, Int_t const pe) {this->fDiffFlowGenFun[ri][rp][pe] = dfgf;};
 170   TProfile3D* GetDiffFlowGenFun(Int_t const ri, Int_t const rp, Int_t const pe) const {return this->fDiffFlowGenFun[ri][rp][pe];};
 171   void SetNoOfParticlesInBin(TProfile* const nopib, Int_t const rp, Int_t const pe) {this->fNoOfParticlesInBin[rp][pe] = nopib;};
 172   TProfile* GetNoOfParticlesInBin(Int_t const rp, Int_t const pe) const {return this->fNoOfParticlesInBin[rp][pe];};
 173   //  6.4.1.) results:
 174   void SetDiffFlowCumulants(TH1D* const dfc, Int_t const rp, Int_t const pe, Int_t const co) {this->fDiffFlowCumulants[rp][pe][co] = dfc;};
 175   TH1D* GetDiffFlowCumulants(Int_t const rp, Int_t const pe, Int_t const co) const {return this->fDiffFlowCumulants[rp][pe][co];};
 176   void SetDiffFlow(TH1D* const df, Int_t const rp, Int_t const pe, Int_t const co) {this->fDiffFlow[rp][pe][co] = df;};
 177   TH1D* GetDiffFlow(Int_t const rp, Int_t const pe, Int_t const co) const {return this->fDiffFlow[rp][pe][co];};
 178   // 6.x.) Tuning the interpolating parameter r0 and using cutoff at different order in series:
 179   void SetTuningFlags(TProfile* const tf) {this->fTuningFlags = tf;};
 180   TProfile* GetTuningFlags() const {return this->fTuningFlags;};
 181   void SetTuneParameters(Bool_t const tp) {this->fTuneParameters = tp;};
 182   Bool_t GetTuneParameters() const {return this->fTuneParameters;};
 183   void SetTuningR0(Double_t const tr0, Int_t const r) {this->fTuningR0[r] = tr0;};
 184   Double_t GetTuningR0(Int_t const r) const {return this->fTuningR0[r];};
 185   //  6.x.0.) profiles:
 186   void SetTuningGenFun(TProfile2D* const tgf, Int_t const r, Int_t const pq) {this->fTuningGenFun[r][pq] = tgf;};
 187   TProfile2D* GetTuningGenFun(Int_t const r, Int_t const pq) const {return this->fTuningGenFun[r][pq];};
 188   //  6.x.1.) results:
 189   void SetTuningCumulants(TH1D* const tc, Int_t const r, Int_t const pq) {this->fTuningCumulants[r][pq] = tc;};
 190   TH1D* GetTuningCumulants(Int_t const r, Int_t const pq) const {return this->fTuningCumulants[r][pq];};
 191   void SetTuningFlow(TH1D* const tf, Int_t const r, Int_t const pq) {this->fTuningFlow[r][pq] = tf;};
 192   TH1D* GetTuningFlow(Int_t const r, Int_t const pq) const {return this->fTuningFlow[r][pq];};
 193
 194  private:
 195   AliFlowAnalysisWithCumulants(const AliFlowAnalysisWithCumulants& afawc);
 196   AliFlowAnalysisWithCumulants& operator=(const AliFlowAnalysisWithCumulants& afawc);
 197   // 0.) Base:
 198   TList *fHistList; // base list to hold all output objects
 199   TString *fHistListName; // name of base list
 200   TProfile *fAnalysisSettings; // profile to hold analysis settings
 201   // 1.) Common:
 202   AliFlowCommonHist *fCommonHists; // common control histograms (filled only with events with 3 or more tracks for 3-p correlators)
 203   AliFlowCommonHistResults *fCommonHistsResults2nd; // common result histograms for 2nd order cumulant
 204   AliFlowCommonHistResults *fCommonHistsResults4th; // common result histograms for 4th order cumulant
 205   AliFlowCommonHistResults *fCommonHistsResults6th; // common result histograms for 6th order cumulant
 206   AliFlowCommonHistResults *fCommonHistsResults8th; // common result histograms for 8th order cumulant
 207   Int_t fnBinsPhi; // number of phi bins
 208   Double_t fPhiMin; // minimum phi
 209   Double_t fPhiMax; // maximum phi
 210   Double_t fPhiBinWidth; // bin width for phi histograms
 211   Int_t fnBinsPt; // number of pt bins
 212   Double_t fPtMin; // minimum pt
 213   Double_t fPtMax; // maximum pt
 214   Double_t fPtBinWidth; // bin width for pt histograms
 215   Int_t fnBinsEta; // number of eta bins
 216   Double_t fEtaMin; // minimum eta
 217   Double_t fEtaMax; // maximum eta
 218   Double_t fEtaBinWidth; // bin width for eta histograms
 219   Int_t fHarmonic; // harmonic
 220   Int_t fMultiple; // the multiple m in p=m*n, where n is harmonic (relevant for differential flow)
 221   Double_t fR0; // r_{0} parameter
 222   Bool_t fPrintFinalResults[3]; // print on the screen the final results [0=RF,1=RP,2=POI]
 223   // 2a.) Particle weights:
 224   TList *fWeightsList; // list to hold all histograms with particle weights: fUseParticleWeights, fPhiWeights, fPtWeights and fEtaWeights
 225   Bool_t fUsePhiWeights; // use phi weights
 226   Bool_t fUsePtWeights; // use pt weights
 227   Bool_t fUseEtaWeights; // use eta weights
 228   TProfile *fUseParticleWeights; // profile with three bins to hold values of fUsePhiWeights, fUsePtWeights and fUseEtaWeights
 229   TH1F *fPhiWeights; // histogram holding phi weights
 230   TH1D *fPtWeights; // histogram holding phi weights
 231   TH1D *fEtaWeights; // histogram holding phi weights
 232   // 2b.) Event weights:
 233   TString *fMultiplicityWeight; // event-by-event weight for reference flow generating function (can be "unit" or "multiplicity")
 234   // 3.) Reference flow:
 235   //  3a.) lists:
 236   TList *fReferenceFlowList; // list to hold all histograms and profiles relevant for reference flow
 237   TList *fReferenceFlowProfiles; // list to hold all profiles relevant for reference flow
 238   TList *fReferenceFlowResults; // list to hold all histograms with final results relevant for reference flow
 239   //  3b.) flags:
 240   TProfile *fReferenceFlowFlags; // profile to hold all flags for reference flow
 241   Int_t fnBinsMult; // number of multiplicity bins for flow analysis versus multiplicity
 242   Double_t fMinMult; // minimal multiplicity for flow analysis versus multiplicity
 243   Double_t fMaxMult; // maximal multiplicity for flow analysis versus multiplicity
 244   //  3c.) event-by-event quantities:
 245   TMatrixD *fGEBE; // reference flow generating function only for current event
 246   //  3d.) profiles:
 247   TProfile2D *fReferenceFlowGenFun; // all-event average of the generating function used to calculate reference flow
 248   TProfile *fQvectorComponents; // averages of Q-vector components (1st bin: <Q_x>, 2nd bin: <Q_y>, 3rd bin: <(Q_x)^2>, 4th bin: <(Q_y)^2>)
 249   TProfile *fAverageOfSquaredWeight; // <<w^2>>, where w = wPhi*wPt*wEta
 250   //  3e.) results:
 251   Double_t fAvM; // average multiplicity
 252   Int_t fnEvts; // number of events
 253   TH1D *fReferenceFlowCumulants; // final results for isotropic cumulants for reference flow
 254   TH1D *fReferenceFlow; // final results for reference flow
 255   TH1D *fChi; // final results for resolution
 256   // 4.) Differential flow:
 257   //  4a.) lists:
 258   TList *fDiffFlowList; // list to hold all histograms and profiles relevant for differential flow
 259   TList *fDiffFlowProfiles; // list to hold all profiles relevant for differential flow
 260   TList *fDiffFlowResults; // list to hold all histograms with final results relevant for differential flow
 261   //  4b.) flags:
 262   TProfile *fDiffFlowFlags; // profile to hold all flags for reference flow
 263   //  4c.) profiles:
 264   TProfile3D *fDiffFlowGenFun[2][2][2]; // all-event avarage of generating function used for differential flow [0=Re,1=Im][0=RP,1=POI][0=pt,1=eta]
 265   TProfile *fNoOfParticlesInBin[2][2]; // number of particles in pt/eta bin for RPs/POIs [0=RP,1=POI][0=pt,1=eta]
 266   //  4d.) results:
 267   TH1D *fDiffFlowCumulants[2][2][4]; // isotropic differential flow cumulants [0=RP,1=POI][0=pt,1=eta][cumulant order]
 268   TH1D *fDiffFlow[2][2][4]; // differential flow [0=RP,1=POI][0=pt,1=eta][cumulant order]
 269   // x.) Tuning the interpolating parameter r0 and using cutoff at different order in series:
 270   //  xa.) lists:
 271   TList *fTuningList; // list to hold all histograms and profiles relevant for tuning
 272   TList *fTuningProfiles; // list to hold all profiles relevant for tuning
 273   TList *fTuningResults; // list to hold all histograms with final results relevant for tuning
 274   //  xb.) flags:
 275   TProfile *fTuningFlags; // profile to hold all flags for tuning
 276   Bool_t fTuneParameters; // tune r0 and cut series at different order
 277   Double_t fTuningR0[10]; // different r0 values (at maximum 10 different values allowed)
 278   //  xc.) profiles:
 279   TProfile2D *fTuningGenFun[10][5]; // generating function G evaluated for 10 different r0s and 5 different sets of (pmax,qmax)
 280   //  xd.) results:
 281   TH1D *fTuningCumulants[10][5]; // isotropic cumulants for reference flow for 10 different r0s and 5 different sets of (pmax,qmax)
 282   TH1D *fTuningFlow[10][5]; // reference flow for 10 different r0s and 5 different sets of (pmax,qmax)
 283
 284   ClassDef(AliFlowAnalysisWithCumulants, 0);
 285
 286 };
 287
 288 //================================================================================================================
 289
 290 #endif
 291
 292
 293
 294
 295