1 /**************************************************************************
\r
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
\r
4 * Author: The ALICE Off-line Project. *
\r
5 * Contributors are mentioned in the code where appropriate. *
\r
7 * Permission to use, copy, modify and distribute this software and its *
\r
8 * documentation strictly for non-commercial purposes is hereby granted *
\r
9 * without fee, provided that the above copyright notice appears in all *
\r
10 * copies and that both the copyright notice and this permission notice *
\r
11 * appear in the supporting documentation. The authors make no claims *
\r
12 * about the suitability of this software for any purpose. It is *
\r
13 * provided "as is" without express or implied warranty. *
\r
14 **************************************************************************/
\r
16 // Flow task class for the ALICE HFE group
\r
19 #ifndef ALIANALYSISTASKFLOWTPCTOFEPSP_H
\r
20 #define ALIANALYSISTASKFLOWTPCTOFEPSP_H
\r
25 #include <AliAnalysisTaskSE.h>
\r
33 class AliFlowTrackCuts;
\r
34 class AliFlowCandidateTrack;
\r
43 class AliHFEpidQAmanager;
\r
45 class AliESDtrackCuts;
\r
46 class AliHFEVZEROEventPlane;
\r
48 class AliAODMCHeader;
\r
50 class AliHFENonPhotonicElectron;
\r
51 class TTreeSRedirector;
\r
53 class AliAnalysisTaskFlowTPCTOFEPSP: public AliAnalysisTaskSE {
\r
57 kElectronfromconversion = 0,
\r
58 kElectronfromconversionboth = 1,
\r
59 kElectronfrompi0 = 2,
\r
60 kElectronfrompi0both = 3,
\r
61 kElectronfrometa = 4,
\r
62 kElectronfrometaboth = 5,
\r
65 kElectronfromother = 8,
\r
77 AliAnalysisTaskFlowTPCTOFEPSP();
\r
78 AliAnalysisTaskFlowTPCTOFEPSP(const char *name);
\r
79 AliAnalysisTaskFlowTPCTOFEPSP(const AliAnalysisTaskFlowTPCTOFEPSP &ref);
\r
80 AliAnalysisTaskFlowTPCTOFEPSP& operator=(const AliAnalysisTaskFlowTPCTOFEPSP &ref);
\r
81 virtual void Copy(TObject &o) const;
\r
82 virtual ~AliAnalysisTaskFlowTPCTOFEPSP();
\r
84 virtual void UserExec(Option_t */*option*/);
\r
85 virtual void UserCreateOutputObjects();
\r
87 void SetAODAnalysis(Bool_t aodAnalysis) { fAODAnalysis = aodAnalysis; };
\r
88 void SetUseFilterAOD(Bool_t useFilterAOD) { fUseFilterAOD = useFilterAOD; }
\r
89 void SetApplyCut(Bool_t applyCut) { fApplyCut = applyCut; }
\r
90 void SetFilter(ULong_t filter) { fFilter = filter; }
\r
92 AliHFEpid *GetPID() const { return fPID; }
\r
93 AliHFEpid *GetPIDTOFOnly() const { return fPIDTOFOnly; }
\r
94 AliHFEpidQAmanager *GetPIDQAManager() const { return fPIDqa; }
\r
95 AliHFEpid *GetPIDBackground() const { return fPIDBackground; }
\r
96 AliHFEpidQAmanager *GetPIDBackgroundQAManager() const { return fPIDBackgroundqa; }
\r
97 AliHFENonPhotonicElectron *GetHFEBackgroundSubtraction() const { return fBackgroundSubtraction; }
\r
100 void SetContamination(TF1 * const function,Int_t k) { fContamination[k] = function; };
\r
101 void SetV2Contamination(TF1 * const function,Int_t k) { fv2contamination[k] = function; };
\r
102 void SetHFECuts(AliHFEcuts * const cuts) { fHFECuts = cuts; };
\r
103 void SetRejectKinkMother(Bool_t rejectKinkMother = kFALSE) { fRejectKinkMother = rejectKinkMother; };
\r
104 void SetHFEBackgroundSubtraction(AliHFENonPhotonicElectron * const backgroundSubtraction) { fBackgroundSubtraction = backgroundSubtraction; };
\r
105 void SetHFEBackgroundCuts(AliESDtrackCuts * const cuts) { fHFEBackgroundCuts = cuts; };
\r
106 void SetSubEtaGapTPC(Bool_t subEtaGapTPC) { fSubEtaGapTPC = subEtaGapTPC; };
\r
107 void SetEtaGap(Double_t etaGap) { fEtaGap = etaGap; };
\r
108 void SetVZEROEventPlane(Bool_t vzeroEventPlane) { fVZEROEventPlane = vzeroEventPlane; };
\r
109 void SetVZEROEventPlaneA(Bool_t vzeroEventPlaneA) { fVZEROEventPlaneA = vzeroEventPlaneA; };
\r
110 void SetVZEROEventPlaneC(Bool_t vzeroEventPlaneC) { fVZEROEventPlaneC = vzeroEventPlaneC; };
\r
111 void SetHFEVZEROEventPlane(AliHFEVZEROEventPlane *hfeVZEROEventPlane) { fHFEVZEROEventPlane = hfeVZEROEventPlane; };
\r
113 void SetNbBinsCentralityQCumulant(Int_t nbBinsCentralityQCumulant) { fNbBinsCentralityQCumulant = nbBinsCentralityQCumulant; };
\r
114 void SetBinCentralityLess(Int_t k, Float_t value) { fBinCentralityLess[k] = value; };
\r
115 void SetNbBinsPtQCumulant(Int_t nbBinsPtQCumulant) { fNbBinsPtQCumulant = nbBinsPtQCumulant; };
\r
116 void SetMinPtQCumulant(Double_t minPtQCumulant) { fMinPtQCumulant = minPtQCumulant; };
\r
117 void SetMaxPtQCumulant(Double_t maxPtQCumulant) { fMaxPtQCumulant = maxPtQCumulant; };
\r
119 void SetAfterBurnerOn(Bool_t afterBurnerOn) { fAfterBurnerOn = afterBurnerOn; };
\r
120 void SetNonFlowNumberOfTrackClones(Int_t nonFlowNumberOfTrackClones) { fNonFlowNumberOfTrackClones = nonFlowNumberOfTrackClones; };
\r
121 void SetV1V2V3V4V5(Double_t v1,Double_t v2,Double_t v3,Double_t v4,Double_t v5) {fV1 = v1; fV2 = v2; fV3 = v3; fV4 = v4; fV5 = v5; };
\r
122 void SetMaxNumberOfIterations(Int_t maxNumberOfIterations) { fMaxNumberOfIterations = maxNumberOfIterations; };
\r
123 void SetPrecisionPhi(Double_t precisionPhi) { fPrecisionPhi = precisionPhi;};
\r
124 void SetUseMCReactionPlane(Bool_t useMCReactionPlane) { fUseMCReactionPlane = useMCReactionPlane;};
\r
125 void SetUseSP(Bool_t useSP) { fSP = useSP;}
\r
126 void SetMCPID(Bool_t mcPID) { fMCPID = mcPID;};
\r
127 void SetNoPID(Bool_t noPID) { fNoPID = noPID;};
\r
129 void SetDebugLevel(Int_t debugLevel) { fDebugLevel = debugLevel;};
\r
130 void SetMonitorEventPlane(Bool_t monitorEventPlane) { fMonitorEventPlane = monitorEventPlane;};
\r
131 void SetMonitorContamination(Bool_t monitorContamination) { fMonitorContamination = monitorContamination;};
\r
132 void SetMonitorPhotonic(Bool_t monitorPhotonic) { fMonitorPhotonic = monitorPhotonic;};
\r
133 void SetMonitorWithoutPID(Bool_t monitorWithoutPID) { fMonitorWithoutPID = monitorWithoutPID;};
\r
134 void SetMonitorTrackCuts(Bool_t monitorTrackCuts) { fMonitorTrackCuts = monitorTrackCuts;};
\r
135 void SetMonitorQCumulant(Bool_t monitorQCumulant) { fMonitorQCumulant = monitorQCumulant;};
\r
137 Int_t GetNbBinsCentralityQCumulant() const { return fNbBinsCentralityQCumulant; };
\r
138 Double_t GetBinCentralityLess(Int_t k) const { return fBinCentralityLess[k]; };
\r
140 AliFlowCandidateTrack *MakeTrack( Double_t mass, Double_t pt, Double_t phi, Double_t eta) ;
\r
141 Double_t GetPhiAfterAddV2(Double_t phi,Double_t reactionPlaneAngle) const;
\r
143 void SetMaxInvmass(Double_t maxInvmass) { fMaxInvmass = maxInvmass; };
\r
144 void SetMaxopening3D(Double_t maxOpening3D) { fMaxopening3D = maxOpening3D; };
\r
145 void SetMaxopeningtheta(Double_t maxOpeningtheta) { fMaxopeningtheta = maxOpeningtheta; };
\r
146 void SetMaxopeningphi(Double_t maxOpeningphi) { fMaxopeningphi = maxOpeningphi; };
\r
147 void SetAlgorithmMA(Bool_t algorithmMA) { fAlgorithmMA = algorithmMA; };
\r
148 void SetMassConstraint(Bool_t massConstraint) { fSetMassConstraint = massConstraint; };
\r
149 void SetPileUpCut(Bool_t cut=kTRUE) { fPileUpCut=cut; }
\r
151 Int_t LookAtNonHFE(Int_t iTrack1, AliVTrack *track1, AliVEvent *fESD, AliMCEvent *mcEvent,Int_t binct,Double_t deltaphi,Int_t source,Int_t indexmother);
\r
154 TList *fListHist; //! TH list
\r
155 Bool_t fAODAnalysis; // AOD analysis
\r
156 Bool_t fUseFilterAOD; // Use the preselected AOD track
\r
157 Bool_t fApplyCut; // Apply the analysis cut for AOD tracks
\r
158 ULong_t fFilter; // reconstruction AOD status flags
\r
159 AliAODMCHeader *fAODMCHeader; // ! MC info AOD
\r
160 TClonesArray *fAODArrayMCInfo; // ! MC info particle AOD
\r
161 AliHFENonPhotonicElectron *fBackgroundSubtraction; // Background subtraction
\r
163 Bool_t fVZEROEventPlane; // Use Event Planes from VZERO
\r
164 Bool_t fVZEROEventPlaneA; // Use Event Planes from VZERO A
\r
165 Bool_t fVZEROEventPlaneC; // Use Event Planes from VZERO C
\r
167 Bool_t fSubEtaGapTPC; // bool to fill with eta gap
\r
168 Double_t fEtaGap; // Value of the eta gap
\r
170 Int_t fNbBinsCentralityQCumulant; // Number of Bins Q Cumulant
\r
171 Double_t fBinCentralityLess[10]; // Centrality Bin lower value
\r
172 Int_t fNbBinsPtQCumulant; // Nbbinspt QCumulant method
\r
173 Double_t fMinPtQCumulant; // Min pt QCumulant method
\r
174 Double_t fMaxPtQCumulant; // Max pt QCumulant method
\r
175 Bool_t fAfterBurnerOn; // Add flow to all tracks
\r
176 Int_t fNonFlowNumberOfTrackClones; // number of times to clone the particles (nonflow)
\r
177 Double_t fV1; // Add Flow. Must be in range [0,0.5].
\r
178 Double_t fV2; // Add Flow. Must be in range [0,0.5].
\r
179 Double_t fV3; // Add Flow. Must be in range [0,0.5].
\r
180 Double_t fV4; // Add Flow. Must be in range [0,0.5].
\r
181 Double_t fV5; // Add Flow. Must be in range [0,0.5].
\r
182 Int_t fMaxNumberOfIterations; // Max number of iteration for adding v2
\r
183 Double_t fPrecisionPhi; // precision phi for adding v2
\r
184 Bool_t fUseMCReactionPlane; // use MC reaction plane
\r
185 Bool_t fSP; // calculate using scalar product method (instead of event plane method)
\r
187 Bool_t fMCPID; // MC PID for electrons
\r
188 Bool_t fNoPID; // No PID for checks
\r
190 Double_t fChi2OverNDFCut; // Limit chi2
\r
191 Double_t fMaxdca; // Limit dca
\r
192 Double_t fMaxopeningtheta; // Limit opening angle in theta
\r
193 Double_t fMaxopeningphi; // Limit opening angle in phi
\r
194 Double_t fMaxopening3D; // Limit opening 3D
\r
195 Double_t fMaxInvmass; // Limit invariant mass
\r
196 Bool_t fSetMassConstraint; // Set mass constraint
\r
199 Int_t fDebugLevel; // Debug Level
\r
200 Bool_t fMonitorEventPlane; // Monitor event plane
\r
201 Bool_t fMonitorContamination; // Monitor contamination
\r
202 Bool_t fMonitorPhotonic;// Monitor photonic
\r
203 Bool_t fMonitorWithoutPID;// Monitor without PID
\r
204 Bool_t fMonitorTrackCuts;// Monitor track cuts
\r
205 Bool_t fMonitorQCumulant;// Monitor Q cumulant
\r
207 // Cuts for FLOW PWG2
\r
208 AliFlowTrackCuts* fcutsRP; //! Reference particle cut
\r
209 AliFlowTrackCuts* fcutsPOI; //! Particle Of Interest cut
\r
212 AliHFEcuts *fHFECuts; // HFE cuts
\r
213 Bool_t fRejectKinkMother; // Reject Kink Mother
\r
214 AliHFEpid *fPID; // PID cuts
\r
215 AliHFEpid *fPIDTOFOnly; // PID cuts TOF only
\r
216 AliHFEpidQAmanager *fPIDqa; // QA Manager
\r
217 AliFlowEvent *fflowEvent; //! Flow event
\r
219 // Hadron Contamination
\r
220 TF1 *fContamination[11]; // Parametrization of the contamination (0-5,5-10,10-20,20-30,30-40,40-50,50-60,60-70,70-80,80-90,90-100)
\r
221 TF1 *fv2contamination[11]; // Parametrization of the v2 of charged pions (0-5,5-10,10-20,20-30,30-40,40-50,50-60,60-70,70-80,80-90,90-100)
\r
223 // Cuts for background study
\r
224 AliESDtrackCuts *fHFEBackgroundCuts; // HFE background cuts
\r
225 AliHFEpid *fPIDBackground; // PID background cuts
\r
226 AliHFEpidQAmanager *fPIDBackgroundqa; // QA Manager Background
\r
227 Bool_t fAlgorithmMA; // algorithm MA
\r
230 TArrayI *fArraytrack; //! list of tracks
\r
231 Int_t fCounterPoolBackground; // number of tracks
\r
233 // VZERO Event plane after calibration 2010
\r
234 AliHFEVZEROEventPlane *fHFEVZEROEventPlane; // VZERO event plane calibrated
\r
237 TH2D *fHistEV; //! Number of events
\r
238 THnSparseF *fHistPileUp; //! Pile up histogram
\r
241 // A Event plane as function of phiepa, phiepb, phiepc, phiepd centrality
\r
242 // a V0A, b V0C, c TPC,
\r
243 THnSparseF *fEventPlane; //! Event plane
\r
245 // B Event Plane after subtraction as function of phiep, centrality
\r
246 THnSparseF *fEventPlaneaftersubtraction; //! Event plane
\r
249 THnSparseF *fFractionContamination; //! Fraction of contamination as function of pt
\r
250 TProfile2D *fContaminationv2; //! v2 of contamination
\r
252 // Monitoring Event plane: cos2phi, sin2phi, centrality
\r
253 THnSparseF *fCosSin2phiep; //! Cos(2phi), Sin(2phi)
\r
255 // E Monitoring Event plane after subtraction of the track: cos, centrality, pt, eta
\r
256 THnSparseF *fCos2phie; //! Monitoring
\r
257 THnSparseF *fSin2phie; //! Monitoring
\r
258 THnSparseF *fCos2phiep; //! Monitoring
\r
259 THnSparseF *fSin2phiep; //! Monitoring
\r
260 THnSparseF *fSin2phiephiep; //! Monitoring
\r
262 // Fbis Resolution as function of cosres, cosres, cosres, centrality for three subevents (V0)
\r
263 // a V0A, b V0C, c TPC
\r
264 THnSparseF *fCosResabc; //! Res
\r
265 THnSparseF *fSinResabc; //! Res
\r
266 TProfile *fProfileCosResab; //! Profile Res_a_b
\r
267 TProfile *fProfileCosResac; //! Profile Res_a_c
\r
268 TProfile *fProfileCosResbc; //! Profile Res_b_c
\r
270 // F Resolution as function of cosres, centrality for two subevents (TPC)
\r
271 THnSparseF *fCosRes; //! Res
\r
272 THnSparseF *fSinRes; //! Res
\r
273 TProfile *fProfileCosRes; //! Profile Res
\r
275 // Debuging Cuts step by step all centrality together: pt, step (6)
\r
276 THnSparseF *fTrackingCuts; //! Tracking Cuts
\r
279 // G Maps delta phi as function of deltaphi, centrality, pt
\r
280 THnSparseF *fDeltaPhiMapsBeforePID; //! Delta phi
\r
281 // H Maps cos phi : cos, centrality, pt
\r
282 THnSparseF *fCosPhiMapsBeforePID; //! Cos
\r
284 // G Maps delta phi as function of deltaphi, centrality, pt
\r
285 THnSparseF *fDeltaPhiMaps; //! Delta phi
\r
286 THnSparseF *fDeltaPhiMapsContamination; //! Delta phi for contamination substraction
\r
287 // H Maps cos phi : cos, centrality, pt
\r
288 THnSparseF *fCosPhiMaps; //! Cos
\r
289 TProfile2D *fProfileCosPhiMaps; //! Profile Cos
\r
291 // Background study: not statistic but tagged
\r
292 THnSparseF *fDeltaPhiMapsTaggedPhotonic; //! Delta phi
\r
293 //THnSparseF *fCosPhiMapsTaggedPhotonic; //! Cos
\r
294 THnSparseF *fDeltaPhiMapsTaggedNonPhotonic; //! Delta phi
\r
295 //THnSparseF *fCosPhiMapsTaggedNonPhotonic; //! Cos
\r
296 THnSparseF *fDeltaPhiMapsTaggedPhotonicLS; //! Delta phi
\r
297 //THnSparseF *fCosPhiMapsTaggedPhotonicLS; //! Cos
\r
299 // Background study: centrality, pt, source
\r
300 THnSparseF *fMCSourceDeltaPhiMaps; //! Source MC
\r
301 // Background study: deltaphi, centrality, pt, minv, source
\r
302 THnSparseF *fOppSignDeltaPhiMaps; //! Delta phi
\r
303 THnSparseF *fSameSignDeltaPhiMaps; //! Delta phi
\r
304 // Background study: angle, centrality, source
\r
305 THnSparseF *fOppSignAngle; // ! Opening Angles
\r
306 THnSparseF *fSameSignAngle; // ! Opening Angles
\r
308 TTreeSRedirector *fDebugStreamer; //!Debug streamer
\r
310 Int_t FindMother(Int_t tr, AliMCEvent *mcEvent, Int_t &indexmother);
\r
311 Int_t CheckPdg(Int_t tr, AliMCEvent* mcEvent);
\r
312 Int_t IsMotherGamma(Int_t tr, AliMCEvent* mcEvent);
\r
313 Int_t IsMotherPi0(Int_t tr, AliMCEvent* mcEvent);
\r
314 Int_t IsMotherC(Int_t tr, AliMCEvent* mcEvent);
\r
315 Int_t IsMotherB(Int_t tr, AliMCEvent* mcEvent);
\r
316 Int_t IsMotherEta(Int_t tr, AliMCEvent* mcEvent);
\r
319 ClassDef(AliAnalysisTaskFlowTPCTOFEPSP, 1); // analysisclass
\r