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