PWGLF/SPECTRA/ChargedHadrons/dNdPt/AlidNdPtAnalysisPbPbAOD.h

   1 #ifndef AlidNdPtAnalysisPbPbAOD_H
   2 #define AlidNdPtAnalysisPbPbAOD_H
   3
   4
   5 //------------------------------------------------------------------------------
   6 // AlidNdPtAnalysisPbPbAOD class used for dNdPt analysis in PbPb collision
   7 // via AODs
   8 //
   9 // Author: P. Luettig, 15.05.2013
  10 // last modified: 10.06.2014
  11 //------------------------------------------------------------------------------
  12
  13
  14
  15 class iostream;
  16
  17 #include "AliAnalysisTaskSE.h"
  18 #include "TObject.h"
  19 #include "TList.h"
  20 #include "TFile.h"
  21 #include "TH1.h"
  22 #include "TH2.h"
  23 #include "TH3.h"
  24 #include "THnSparse.h"
  25 #include "THn.h"
  26 #include "TClonesArray.h"
  27 #include "TString.h"
  28 #include "TProfile.h"
  29 #include "TVector2.h"
  30
  31 #include "TParticlePDG.h"
  32 #include "TDatabasePDG.h"
  33
  34 #include "AliLog.h"
  35 #include "AliCentrality.h"
  36 #include "AliAODEvent.h"
  37 #include "AliVEvent.h"
  38
  39 #include "AliInputEventHandler.h"
  40 #include "AliAODInputHandler.h"
  41 #include "AliAnalysisManager.h"
  42 #include "AliMCEventHandler.h"
  43 #include "AliAODMCHeader.h"
  44 #include "AliAODMCParticle.h"
  45 #include "AliGenHijingEventHeader.h"
  46 #include "AliGenPythiaEventHeader.h"
  47 #include "AliExternalTrackParam.h"
  48 #include "AliESDtrack.h"
  49 #include "AliEventplane.h"
  50
  51 #include "TSystem.h"
  52 #include "TROOT.h"
  53
  54 class AlidNdPtAnalysisPbPbAOD : public AliAnalysisTaskSE {
  55   public :
  56     enum CheckQuantity { cqCrossedRows = 0, cqNcluster = 1, cqChi = 2, cqLength = 3, cqRowsOverFindable = 4 };
  57     enum KinematicQuantity { kqPt = 0, kqEta = 1, kqPhi = 2 };
  58     enum MaxCheckQuantity { cqMax = 5 };
  59     enum MaxKinematicQuantity { kqMax = 3 };
  60
  61     AlidNdPtAnalysisPbPbAOD(const char *name = "dNdPtPbPbAOD");
  62     ~AlidNdPtAnalysisPbPbAOD();
  63
  64     virtual void UserCreateOutputObjects();
  65     virtual void UserExec(Option_t *option);
  66     virtual void Terminate(Option_t *);
  67
  68     // Set binning for Histograms (if not set default binning is used)
  69     void SetBinsMult(Int_t nbins, Double_t* edges)                      { Printf("[I] Setting Mult Bins"); fMultNbins = nbins; fBinsMult = GetArrayClone(nbins,edges); }
  70     void SetBinsPt(Int_t nbins, Double_t* edges)                        { Printf("[I] Setting pT Bins"); fPtNbins = nbins; fBinsPt = GetArrayClone(nbins,edges); }
  71     void SetBinsPtCorr(Int_t nbins, Double_t* edges)            { Printf("[I] Setting pTcorr Bins"); fPtCorrNbins = nbins; fBinsPtCorr = GetArrayClone(nbins,edges); }
  72     void SetBinsPtCheck(Int_t nbins, Double_t* edges)           { Printf("[I] Setting pTcheck Bins"); fPtCheckNbins = nbins; fBinsPtCheck = GetArrayClone(nbins,edges); }
  73     void SetBinsEta(Int_t nbins, Double_t* edges)                       { Printf("[I] Setting Eta Bins"); fEtaNbins = nbins; fBinsEta = GetArrayClone(nbins,edges); }
  74     void SetBinsEtaCheck(Int_t nbins, Double_t* edges)          { Printf("[I] Setting EtaCheck Bins"); fEtaCheckNbins = nbins; fBinsEtaCheck = GetArrayClone(nbins,edges); }
  75     void SetBinsZv(Int_t nbins, Double_t* edges)                        { Printf("[I] Setting Zv Bins"); fZvNbins = nbins; fBinsZv= GetArrayClone(nbins,edges); }
  76     void SetBinsCentrality(Int_t nbins, Double_t* edges)        { Printf("[I] Setting Cent Bins"); fCentralityNbins = nbins; fBinsCentrality = GetArrayClone(nbins,edges); }
  77     void SetBinsPhi(Int_t nbins, Double_t* edges)                       { Printf("[I] Setting Phi Bins"); fPhiNbins = nbins; fBinsPhi = GetArrayClone(nbins,edges); }
  78     void SetBinsDeltaphi(Int_t nbins, Double_t* edges)          { Printf("[I] Setting Deltaphi Bins"); fDeltaphiNbins = nbins; fBinsDeltaphi = GetArrayClone(nbins,edges); }
  79     void SetBinsRunNumber(Int_t nbins, Double_t* edges)         { Printf("[I] Setting RunNumber Bins"); fRunNumberNbins = nbins; fBinsRunNumber = GetArrayClone(nbins,edges); }
  80
  81     // set event cut variables
  82     void SetCutMaxZVertex( Double_t d)                                      { fCutMaxZVertex = d; }
  83     Double_t GetCutMaxZVertex()                                                 { return fCutMaxZVertex; }
  84
  85     // set track kinematic cut parameters
  86     void SetCutPtRange(Double_t ptmin, Double_t ptmax)          { fCutPtMin = ptmin; fCutPtMax = ptmax; }
  87     Double_t GetCutPtMin()                                                          { return fCutPtMin; }
  88     Double_t GetCutPtMax()                                                          { return fCutPtMax; }
  89
  90     void SetCutEtaRange(Double_t etamin, Double_t etamax)       { fCutEtaMin = etamin; fCutEtaMax = etamax; }
  91     Double_t GetCutEtaMin()                                                         { return fCutEtaMin; }
  92     Double_t GetCutEtaMax()                                                         { return fCutEtaMax; }
  93
  94     void EnableRelativeCuts()                                                           { Printf("[I] Relative Cuts enabled"); fUseRelativeCuts = kTRUE; }
  95     Bool_t AreRelativeCutsEnabled()                                                     { return fUseRelativeCuts; }
  96
  97     // setter and getter track quality cut parameters
  98     void SetFilterBit(Int_t b)                                                          { fFilterBit = b; };
  99     Int_t GetFilterBit()                                                                        { return fFilterBit; }
 100
 101     void SetCutRequireTPCRefit(Bool_t *b)                                       { fCutRequireTPCRefit = b; }
 102     Bool_t IsTPCRefitRequired()                                                         { return fCutRequireTPCRefit; }
 103
 104     void SetCutRequireITSRefit(Bool_t *b)                                       { fCutRequireITSRefit = b; }
 105     Bool_t IsITSRefitRequired()                                                         { return fCutRequireITSRefit; }
 106
 107     void SetCutMinNClustersTPC(Double_t d)                                      { fCutMinNumberOfClusters = d; }
 108     Double_t GetCutMinNClustersTPC()                                            { return fCutMinNumberOfClusters; }
 109
 110     void SetCutPercMinNClustersTPC(Double_t d)                          { Printf("[I] Take only %.2f%% tracks with most clusters", d*100.); fCutPercMinNumberOfClusters = d; }
 111     Double_t GetCutPercMinNClustersTPC()                                        { return fCutPercMinNumberOfClusters; }
 112
 113     void SetCutMinNCrossedRowsTPC(Double_t d)                           { fCutMinNumberOfCrossedRows = d; }
 114     Double_t GetCutMinNCrossedRowsTPC()                                         { return fCutMinNumberOfCrossedRows; }
 115
 116     void SetCutPercMinNCrossedRowsTPC(Double_t d)                       { Printf("[I] Take only %.2f%% tracks with most crossedRows", d*100.); fCutPercMinNumberOfCrossedRows = d; }
 117     Double_t GetCutPercMinNCrossedRowsTPC()                                     { return fCutPercMinNumberOfCrossedRows; }
 118
 119     void SetCutMinRatioCrossedRowsOverFindableClustersTPC(Double_t d)   { fCutMinRatioCrossedRowsOverFindableClustersTPC = d; }
 120     Double_t GetCutMinRatioCrossedRowsOverFindableClustersTPC()                 { return fCutMinRatioCrossedRowsOverFindableClustersTPC; }
 121
 122     void SetCutLengthInTPCPtDependent(Bool_t b)                         { fCutLengthInTPCPtDependent = b; }
 123     Bool_t DoCutLengthInTPCPtDependent()                                        { return fCutLengthInTPCPtDependent; }
 124
 125     void SetPrefactorLengthInTPCPtDependent(Double_t d)         { fPrefactorLengthInTPCPtDependent = d; }
 126     Double_t GetPrefactorLengthInTPCPtDependent()                       { return fPrefactorLengthInTPCPtDependent; }
 127
 128     void SetCutMaxChi2PerClusterTPC(Double_t d)                         { fCutMaxChi2PerClusterTPC = d; }
 129     void SetCutMaxFractionSharedTPCClusters(Double_t d)         { fCutMaxFractionSharedTPCClusters = d; }
 130     void SetCutMaxDCAToVertexZ(Double_t d)                                      { fCutMaxDCAToVertexZ = d; }
 131     void SetCutMaxDCAToVertexXY(Double_t d)                             { fCutMaxDCAToVertexXY = d; }
 132     void SetCutMaxChi2PerClusterITS(Double_t d)                         { fCutMaxChi2PerClusterITS = d; }
 133     void SetCutDCAToVertex2D(Bool_t *b)                                         { fCutDCAToVertex2D = b; }
 134     void SetCutRequireSigmaToVertex(Bool_t *b)                          { fCutRequireSigmaToVertex = b; }
 135     void SetCutMaxDCAToVertexXYPtDep(Double_t d0, Double_t d1, Double_t d2)
 136     {
 137       fCutMaxDCAToVertexXYPtDepPar0 = d0;
 138       fCutMaxDCAToVertexXYPtDepPar1 = d1;
 139       fCutMaxDCAToVertexXYPtDepPar2 = d2;
 140     }
 141     void SetCutAcceptKinkDaughters(Bool_t *b)                           { fCutAcceptKinkDaughters = b; }
 142     void SetCutMaxChi2TPCConstrainedGlobal(Double_t d)          { fCutMaxChi2TPCConstrainedGlobal = d; }
 143
 144     // fill function for cross check histos
 145     Bool_t FillDebugHisto(Double_t *dCrossCheckVar, Double_t *dKineVar, Double_t dCentrality, Bool_t bIsAccepted);
 146
 147     // fill function for cut settings
 148     void StoreCutSettingsToHistogram();
 149
 150     // getter for DCA
 151     Bool_t GetDCA(const AliAODTrack *track, AliAODEvent *evt, Double_t d0z0[2]);
 152
 153     THnSparseF * GetHistZvPtEtaCent() const { return fZvPtEtaCent; }
 154     TH1F * GetHistEventStatistics() const { return fEventStatistics; }
 155
 156     const char * GetParticleName(Int_t pdg);
 157
 158     AliGenHijingEventHeader* GetHijingEventHeader(AliAODMCHeader *header);
 159     AliGenPythiaEventHeader* GetPythiaEventHeader(AliAODMCHeader *header);
 160
 161         Double_t RotatePhi(Double_t phiTrack, Double_t phiEP, Double_t dMaxDeltaPhi);
 162 //      Double_t MoveEventplane(Double_t dMCEP);
 163
 164     Bool_t SetRelativeCuts(AliAODEvent *event);
 165
 166     Bool_t IsTrackAccepted(AliAODTrack *tr, Double_t dCentrality, Double_t bMagZ);
 167     Bool_t IsMCTrackAccepted(AliAODMCParticle *part);
 168
 169     Bool_t IsHijingParticle(const AliAODMCParticle *part, AliGenHijingEventHeader* hijingGenHeader);
 170     Bool_t IsPythiaParticle(const AliAODMCParticle *part, AliGenPythiaEventHeader* pythiaGenHeader);
 171
 172     static Double_t* GetArrayClone(Int_t n, Double_t* source);
 173
 174         void SetEventplaneSelector(char *c) { fEPselector = c; }
 175         TString GetEventplaneSelector() { return fEPselector; }
 176
 177   private :
 178
 179     // Output List
 180     TList               *fOutputList;
 181
 182     // Histograms
 183     TH1F            *fPt; // simple pT histogramm
 184     TH1F            *fMCPt; // simple pT truth histogramm
 185     THnSparseF  *fZvPtEtaCent; //-> Zv:Pt:Eta:Cent
 186     THnSparseF  *fDeltaphiPtEtaPhiCent; //-> DeltaPhi:Pt:Eta:Phi:Cent, was fDeltaphiPtEtaCent
 187     THnSparseF  *fPtResptCent; //-> 1/pt:ResolutionPt:Cent
 188     THnSparseF  *fMCRecPrimZvPtEtaCent; //-> MC Zv:Pt:Eta:Cent
 189     THnSparseF  *fMCGenZvPtEtaCent; //-> MC Zv:Pt:Eta:Cent
 190     THnSparseF  *fMCRecSecZvPtEtaCent; //-> MC Zv:Pt:Eta:Cent, only secondaries
 191     THnSparseF  *fMCRecPrimDeltaphiPtEtaPhiCent; //-> MC Phi:Pt:Eta:Phi:Cent, was fMCRecPrimDeltaphiPtEtaCent
 192     THnSparseF  *fMCGenDeltaphiPtEtaPhiCent; //-> MC Phi:Pt:Eta:Phi:Cent, was fMCGenDeltaphiPtEtaCent
 193     THnSparseF  *fMCRecSecDeltaphiPtEtaPhiCent; //-> MC Phi:Pt:Eta:Phi:Cent, only secondaries, was fMCRecSecDeltaphiPtEtaCent
 194     TH1F            *fEventStatistics; // contains statistics of number of events after each cut
 195     TH1F        *fEventStatisticsCentrality; // contains number of events vs centrality, events need to have a track in kinematic range
 196     TH1F            *fMCEventStatisticsCentrality; // contains MC number of events vs centrality, events need to have a track in kinematic range
 197     TH1F            *fAllEventStatisticsCentrality; // contains number of events vs centrality, events need to be triggered
 198     TH2F            *fEventStatisticsCentralityTrigger; // contains number of events vs centrality in 1% bins vs trigger
 199     THnSparseF  *fZvMultCent; // Zv:Mult:Cent
 200     TH1F            *fTriggerStatistics; // contains number of events per trigger
 201     TH1F            *fCharge; // charge distribution in data
 202     TH1F            *fMCCharge; // charge distribution in MC
 203     THnSparseF  *fDCAPtAll; //control histo: DCAz:DCAxy:pT:eta:phi for all reconstructed tracks
 204     THnSparseF  *fDCAPtAccepted; //control histo: DCAz:DCAxy:pT:eta:phi for all accepted reco tracks
 205     THnSparseF  *fMCDCAPtSecondary; //control histo: DCAz:DCAxy:pT:eta:phi for all accepted reco track, which are secondaries (using MC info)
 206     THnSparseF  *fMCDCAPtPrimary; //control histo: DCAz:DCAxy:pT:eta:phi for all accepted reco track, which are primaries (using MC info)
 207     THnF            *fCrossCheckAll[5]; //control histo: {CrossedRows,Ncluster,Chi,Length,CrossedRows/Findable} vs pT,eta,phi,Centrality for all tracks
 208     THnF            *fCrossCheckAcc[5]; //control histo: {CrossedRows,Ncluster,Chi,Length,CrossedRows/Findable} vs pT,eta,phi,Centrality after cuts
 209     TH1F            *fCutPercClusters; // control histo: number of clusters, where the relative cut has been set e-by-e
 210     TH1F            *fCutPercCrossed; // control histo: number of crossed rows, where the relative cut has been set e-by-e
 211     TH2F            *fCrossCheckRowsLength; // control histo: number of crossed rows vs length in TPC
 212     TH2F            *fCrossCheckClusterLength; // control histo: number of clusters vs length in TPC
 213     TH2F            *fCrossCheckRowsLengthAcc; // control histo: number of crossed rows vs length in TPC for all accepted tracks
 214     TH2F            *fCrossCheckClusterLengthAcc; // control histo: number of clusters vs length in TPC for all accepted tracks
 215     TH2F                *fCrossCheckPtresLength; // control histo: relative pt resolution in 1/pt vs lenght in TPC
 216     TH2F                *fCrossCheckPtresRows; // control histo: relative pt resolution in 1/pt vs number of crossed rows in TPC
 217     TH1F        *fCutSettings; // control histo: cut settings
 218
 219     TH1F                *fEventplaneDist; // event plane distribution in phi
 220     TH2F                *fEventplaneRunDist; // event plane distribution in phi
 221     TH1F                *fMCEventplaneDist; // MC event plane distribution in phi
 222     TH2F                *fCorrelEventplaneMCDATA; // correlation between data and MC eventplane
 223     THnSparseF  *fCorrelEventplaneDefaultCorrected; // correlation between default and corrected (== subtraction of current track) eventplane
 224     TH2F                *fEventplaneSubtractedPercentage; // percentage of subtracted tracks
 225
 226         // cross check for event plane resolution
 227         TH2F            *fEPDistCent; // event plane distribution vs centrality
 228         TH2F            *fPhiCent;      // particle phi distribution vs centrality
 229         TProfile        *fPcosEPCent; // < cos 2 psi_ep > vs centrality
 230         TProfile        *fPsinEPCent; // < sin 2 psi_ep > vs centrality
 231         TProfile        *fPcosPhiCent; // < cos 2 phi > vs centrality
 232         TProfile        *fPsinPhiCent; // < sin 2 phi > vs centrality
 233
 234         // cross check for event plane determination
 235         TH2F            *fDeltaPhiCent; // DeltaPhi:Cent - DeltaPhi in the range from -pi to pi
 236
 237         THnSparseF      *fCrossCheckFilterBitPhiCent; // FilterBit:Phi:Centrality
 238
 239         // global variables
 240     Bool_t fIsMonteCarlo;
 241
 242         TString fEPselector;
 243
 244     // event cut variables
 245     Double_t fCutMaxZVertex;
 246
 247     // track kinematic cut variables
 248     Double_t fCutPtMin;
 249     Double_t fCutPtMax;
 250     Double_t fCutEtaMin;
 251     Double_t fCutEtaMax;
 252
 253     // track quality cut variables
 254     Int_t           fFilterBit;
 255     Bool_t          fUseRelativeCuts;
 256     Bool_t      fCutRequireTPCRefit;
 257     Bool_t          fCutRequireITSRefit;
 258     Double_t    fCutMinNumberOfClusters;
 259     Double_t    fCutPercMinNumberOfClusters;
 260     Double_t    fCutMinNumberOfCrossedRows;
 261     Double_t    fCutPercMinNumberOfCrossedRows;
 262     Double_t    fCutMinRatioCrossedRowsOverFindableClustersTPC;
 263     Double_t    fCutMaxChi2PerClusterTPC;
 264     Double_t    fCutMaxFractionSharedTPCClusters;
 265     Double_t    fCutMaxDCAToVertexZ;
 266     Double_t    fCutMaxDCAToVertexXY;
 267     Double_t    fCutMaxChi2PerClusterITS;
 268     Bool_t      fCutDCAToVertex2D;
 269     Bool_t          fCutRequireSigmaToVertex;
 270     Double_t    fCutMaxDCAToVertexXYPtDepPar0;
 271     Double_t    fCutMaxDCAToVertexXYPtDepPar1;
 272     Double_t    fCutMaxDCAToVertexXYPtDepPar2;
 273     Bool_t          fCutAcceptKinkDaughters;
 274     Double_t    fCutMaxChi2TPCConstrainedGlobal;
 275     Bool_t          fCutLengthInTPCPtDependent;
 276     Double_t    fPrefactorLengthInTPCPtDependent;
 277
 278     //binning for THNsparse
 279     Int_t       fMultNbins;
 280     Int_t       fPtNbins;
 281     Int_t       fPtCorrNbins;
 282     Int_t       fPtCheckNbins;
 283     Int_t       fEtaNbins;
 284     Int_t       fEtaCheckNbins;
 285     Int_t       fZvNbins;
 286     Int_t       fCentralityNbins;
 287     Int_t       fPhiNbins;
 288         Int_t       fDeltaphiNbins;
 289         Int_t           fRunNumberNbins;
 290     Double_t*   fBinsMult; //[fMultNbins]
 291     Double_t*   fBinsPt; //[fPtNbins]
 292     Double_t*   fBinsPtCorr; //[fPtCorrNbins]
 293     Double_t*   fBinsPtCheck; //[fPtCheckNbins]
 294     Double_t*   fBinsEta; //[fEtaNbins]
 295     Double_t*   fBinsEtaCheck; //[fEtaCheckNbins]
 296     Double_t*   fBinsZv; //[fZvNbins]
 297     Double_t*   fBinsCentrality; //[fCentralityNbins]
 298     Double_t*   fBinsPhi; //[fPhiNbins]
 299     Double_t*   fBinsDeltaphi; //[fPhiNbins]
 300     Double_t*   fBinsRunNumber; //[fRunNumberNbins]
 301
 302     AlidNdPtAnalysisPbPbAOD(const AlidNdPtAnalysisPbPbAOD&); // not implemented
 303     AlidNdPtAnalysisPbPbAOD& operator=(const AlidNdPtAnalysisPbPbAOD&); // not implemented
 304
 305     ClassDef(AlidNdPtAnalysisPbPbAOD,13); // has to be at least 1, otherwise not streamable...
 306 };
 307
 308 #endif