]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGHF/hfe/AliAnalysisTaskFlowTPCTOFEPSP.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Event Cut update + outlier centrality for flow
[u/mrichter/AliRoot.git] / PWGHF / hfe / AliAnalysisTaskFlowTPCTOFEPSP.cxx
CommitLineData
8c1c76e9 1/**************************************************************************\r
2* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
3* *\r
4* Author: The ALICE Off-line Project. *\r
5* Contributors are mentioned in the code where appropriate. *\r
6* *\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
15//\r
16// Flow task\r
17// \r
18// Authors:\r
19// Raphaelle Bailhache <R.Bailhache@gsi.de>\r
709ba9e7 20// Theodor Rascanu <trascanu@stud.uni-frankfurt.de>\r
8c1c76e9 21//\r
22#include "TROOT.h"\r
23#include "TH1D.h"\r
24#include "TH2D.h"\r
25#include "TChain.h"\r
26#include "TVector2.h"\r
27#include "THnSparse.h"\r
28#include "TMath.h"\r
29#include "TRandom3.h"\r
e17c1f86 30#include "TProfile.h"\r
31#include "TProfile2D.h"\r
0e30407a 32#include "TLorentzVector.h"\r
33#include "TParticle.h"\r
6733d981 34#include "TF1.h"\r
8c1c76e9 35\r
959ea9d8 36#include <TDirectory.h>\r
37#include <TTreeStream.h>\r
38\r
4102d1cc 39#include "AliVEventHandler.h"\r
8c1c76e9 40#include "AliAnalysisTaskSE.h"\r
4102d1cc 41#include "AliAnalysisManager.h"\r
8c1c76e9 42\r
11ff28c5 43#include "AliVEvent.h"\r
8c1c76e9 44#include "AliESDInputHandler.h"\r
45#include "AliMCEvent.h"\r
46#include "AliESD.h"\r
47#include "AliESDEvent.h"\r
5cd679b7 48#include "AliPID.h"\r
8c1c76e9 49#include "AliPIDResponse.h"\r
50#include "AliESDVZERO.h"\r
51#include "AliESDUtils.h"\r
52#include "AliMCParticle.h"\r
0e30407a 53#include "AliAODMCParticle.h"\r
54#include "AliAODEvent.h"\r
55#include "AliAODVertex.h"\r
56#include "AliAODTrack.h"\r
11ff28c5 57#include "AliVTrack.h"\r
0e30407a 58#include "AliESDtrack.h"\r
59#include "AliESDtrackCuts.h"\r
4102d1cc 60#include "AliAODTrack.h"\r
0e30407a 61#include "AliStack.h"\r
62#include "AliMCEvent.h"\r
8c1c76e9 63\r
64#include "AliFlowCandidateTrack.h"\r
65#include "AliFlowEvent.h"\r
66#include "AliFlowTrackCuts.h"\r
67#include "AliFlowVector.h"\r
68#include "AliFlowCommonConstants.h"\r
0e30407a 69#include "AliKFParticle.h"\r
7b4c9210 70#include "AliKFVertex.h"\r
8c1c76e9 71\r
8c1c76e9 72#include "AliHFEcuts.h"\r
73#include "AliHFEpid.h"\r
74#include "AliHFEpidQAmanager.h"\r
75#include "AliHFEtools.h"\r
a8ef1999 76#include "AliHFEVZEROEventPlane.h"\r
8c1c76e9 77\r
78#include "AliCentrality.h"\r
79#include "AliEventplane.h"\r
914042c2 80#include "AliAnalysisTaskFlowTPCTOFEPSP.h"\r
2747660f 81#include "AliAODMCHeader.h"\r
82#include "TClonesArray.h"\r
83#include "AliHFENonPhotonicElectron.h"\r
8c1c76e9 84\r
85\r
86//____________________________________________________________________\r
914042c2 87AliAnalysisTaskFlowTPCTOFEPSP::AliAnalysisTaskFlowTPCTOFEPSP() :\r
8c1c76e9 88 AliAnalysisTaskSE(),\r
a8ef1999 89 fListHist(0x0), \r
11ff28c5 90 fAODAnalysis(kFALSE),\r
2747660f 91 fUseFilterAOD(kFALSE),\r
4102d1cc 92 fApplyCut(kTRUE),\r
2747660f 93 fFilter(1<<4),\r
94 fAODMCHeader(NULL),\r
95 fAODArrayMCInfo(NULL),\r
96 fBackgroundSubtraction(NULL),\r
e17c1f86 97 fVZEROEventPlane(kFALSE),\r
98 fVZEROEventPlaneA(kFALSE),\r
99 fVZEROEventPlaneC(kFALSE),\r
8c1c76e9 100 fSubEtaGapTPC(kFALSE),\r
101 fEtaGap(0.0),\r
e17c1f86 102 fNbBinsCentralityQCumulant(4),\r
11ff28c5 103 fNbBinsPtQCumulant(12),\r
104 fMinPtQCumulant(0.2),\r
8c1c76e9 105 fMaxPtQCumulant(6.0),\r
106 fAfterBurnerOn(kFALSE),\r
107 fNonFlowNumberOfTrackClones(0),\r
108 fV1(0.),\r
109 fV2(0.),\r
110 fV3(0.),\r
111 fV4(0.),\r
112 fV5(0.),\r
113 fMaxNumberOfIterations(100),\r
114 fPrecisionPhi(0.001),\r
115 fUseMCReactionPlane(kFALSE),\r
959ea9d8 116 fSP(kFALSE),\r
8c1c76e9 117 fMCPID(kFALSE),\r
a8ef1999 118 fNoPID(kFALSE),\r
7b4c9210 119 fChi2OverNDFCut(3.0),\r
0e30407a 120 fMaxdca(3.0),\r
121 fMaxopeningtheta(0.02),\r
122 fMaxopeningphi(0.1),\r
123 fMaxopening3D(0.1),\r
124 fMaxInvmass(0.1),\r
7b4c9210 125 fSetMassConstraint(kFALSE),\r
e17c1f86 126 fDebugLevel(0),\r
7b5936fc 127 fMonitorEventPlane(kFALSE),\r
128 fMonitorContamination(kFALSE),\r
129 fMonitorPhotonic(kFALSE),\r
130 fMonitorWithoutPID(kFALSE),\r
131 fMonitorTrackCuts(kFALSE),\r
132 fMonitorQCumulant(kFALSE),\r
8c1c76e9 133 fcutsRP(0),\r
134 fcutsPOI(0),\r
135 fHFECuts(0),\r
2747660f 136 fRejectKinkMother(kFALSE),\r
8c1c76e9 137 fPID(0),\r
5cd679b7 138 fPIDTOFOnly(0),\r
8c1c76e9 139 fPIDqa(0),\r
0e30407a 140 fflowEvent(NULL),\r
141 fHFEBackgroundCuts(0),\r
142 fPIDBackground(0),\r
143 fPIDBackgroundqa(0),\r
144 fAlgorithmMA(kTRUE),\r
145 fArraytrack(NULL),\r
146 fCounterPoolBackground(0),\r
a8ef1999 147 fHFEVZEROEventPlane(0x0),\r
2747660f 148 fHistEV(0),\r
a70c9e97 149 fHistPileUp(0),\r
d87a9d29 150 fPileUpCut(kFALSE),\r
8c1c76e9 151 fEventPlane(0x0),\r
152 fEventPlaneaftersubtraction(0x0),\r
6733d981 153 fFractionContamination(0x0),\r
6b2521a4 154 fContaminationv2(0x0),\r
e17c1f86 155 fCosSin2phiep(0x0),\r
8c1c76e9 156 fCos2phie(0x0),\r
157 fSin2phie(0x0),\r
158 fCos2phiep(0x0),\r
159 fSin2phiep(0x0),\r
160 fSin2phiephiep(0x0),\r
e17c1f86 161 fCosResabc(0x0),\r
a8ef1999 162 fSinResabc(0x0),\r
e17c1f86 163 fProfileCosResab(0x0),\r
164 fProfileCosResac(0x0),\r
165 fProfileCosResbc(0x0),\r
8c1c76e9 166 fCosRes(0x0),\r
a8ef1999 167 fSinRes(0x0),\r
e17c1f86 168 fProfileCosRes(0x0),\r
0e30407a 169 fTrackingCuts(0x0),\r
170 fDeltaPhiMapsBeforePID(0x0),\r
171 fCosPhiMapsBeforePID(0x0),\r
8c1c76e9 172 fDeltaPhiMaps(0x0),\r
5cd679b7 173 fDeltaPhiMapsContamination(0x0),\r
e17c1f86 174 fCosPhiMaps(0x0),\r
0e30407a 175 fProfileCosPhiMaps(0x0),\r
2747660f 176 fDeltaPhiMapsTaggedPhotonic(0x0),\r
6733d981 177 //fCosPhiMapsTaggedPhotonic(0x0),\r
2747660f 178 fDeltaPhiMapsTaggedNonPhotonic(0x0),\r
6733d981 179 //fCosPhiMapsTaggedNonPhotonic(0x0),\r
2747660f 180 fDeltaPhiMapsTaggedPhotonicLS(0x0),\r
6733d981 181 //fCosPhiMapsTaggedPhotonicLS(0x0),\r
0e30407a 182 fMCSourceDeltaPhiMaps(0x0),\r
183 fOppSignDeltaPhiMaps(0x0),\r
184 fSameSignDeltaPhiMaps(0x0),\r
185 fOppSignAngle(0x0),\r
959ea9d8 186 fSameSignAngle(0x0),\r
187 fDebugStreamer(0)\r
8c1c76e9 188{\r
189 // Constructor\r
190\r
e17c1f86 191 for(Int_t k = 0; k < 10; k++) {\r
192 fBinCentralityLess[k] = 0.0;\r
193 }\r
6733d981 194 for(Int_t k = 0; k < 11; k++) {\r
195 fContamination[k] = NULL;\r
6b2521a4 196 fv2contamination[k] = NULL;\r
6733d981 197 }\r
198 \r
8c1c76e9 199}\r
200//______________________________________________________________________________\r
914042c2 201AliAnalysisTaskFlowTPCTOFEPSP:: AliAnalysisTaskFlowTPCTOFEPSP(const char *name) :\r
8c1c76e9 202 AliAnalysisTaskSE(name),\r
11ff28c5 203 fListHist(0x0),\r
4102d1cc 204 fAODAnalysis(kFALSE),\r
2747660f 205 fUseFilterAOD(kFALSE),\r
4102d1cc 206 fApplyCut(kTRUE),\r
2747660f 207 fFilter(1<<4), \r
208 fAODMCHeader(NULL),\r
209 fAODArrayMCInfo(NULL),\r
210 fBackgroundSubtraction(NULL),\r
e17c1f86 211 fVZEROEventPlane(kFALSE),\r
212 fVZEROEventPlaneA(kFALSE),\r
213 fVZEROEventPlaneC(kFALSE),\r
8c1c76e9 214 fSubEtaGapTPC(kFALSE),\r
215 fEtaGap(0.0),\r
e17c1f86 216 fNbBinsCentralityQCumulant(4),\r
8c1c76e9 217 fNbBinsPtQCumulant(15),\r
218 fMinPtQCumulant(0.0),\r
219 fMaxPtQCumulant(6.0),\r
220 fAfterBurnerOn(kFALSE),\r
221 fNonFlowNumberOfTrackClones(0),\r
222 fV1(0.),\r
223 fV2(0.),\r
224 fV3(0.),\r
225 fV4(0.),\r
226 fV5(0.),\r
227 fMaxNumberOfIterations(100),\r
228 fPrecisionPhi(0.001),\r
229 fUseMCReactionPlane(kFALSE),\r
959ea9d8 230 fSP(kFALSE),\r
8c1c76e9 231 fMCPID(kFALSE),\r
a8ef1999 232 fNoPID(kFALSE),\r
7b4c9210 233 fChi2OverNDFCut(3.0),\r
0e30407a 234 fMaxdca(3.0),\r
235 fMaxopeningtheta(0.02),\r
236 fMaxopeningphi(0.1),\r
237 fMaxopening3D(0.1),\r
238 fMaxInvmass(0.1),\r
7b4c9210 239 fSetMassConstraint(kFALSE),\r
e17c1f86 240 fDebugLevel(0),\r
7b5936fc 241 fMonitorEventPlane(kFALSE),\r
242 fMonitorContamination(kFALSE),\r
243 fMonitorPhotonic(kFALSE),\r
244 fMonitorWithoutPID(kFALSE),\r
245 fMonitorTrackCuts(kFALSE),\r
246 fMonitorQCumulant(kFALSE),\r
8c1c76e9 247 fcutsRP(0),\r
248 fcutsPOI(0),\r
249 fHFECuts(0),\r
2747660f 250 fRejectKinkMother(kFALSE),\r
8c1c76e9 251 fPID(0),\r
5cd679b7 252 fPIDTOFOnly(0),\r
8c1c76e9 253 fPIDqa(0),\r
0e30407a 254 fflowEvent(NULL),\r
255 fHFEBackgroundCuts(0),\r
256 fPIDBackground(0),\r
257 fPIDBackgroundqa(0),\r
258 fAlgorithmMA(kTRUE), \r
259 fArraytrack(NULL),\r
260 fCounterPoolBackground(0),\r
a8ef1999 261 fHFEVZEROEventPlane(0x0),\r
2747660f 262 fHistEV(0),\r
a70c9e97 263 fHistPileUp(0),\r
d87a9d29 264 fPileUpCut(kFALSE),\r
8c1c76e9 265 fEventPlane(0x0),\r
266 fEventPlaneaftersubtraction(0x0),\r
6733d981 267 fFractionContamination(0x0),\r
6b2521a4 268 fContaminationv2(0x0),\r
e17c1f86 269 fCosSin2phiep(0x0),\r
8c1c76e9 270 fCos2phie(0x0),\r
271 fSin2phie(0x0),\r
272 fCos2phiep(0x0),\r
273 fSin2phiep(0x0),\r
274 fSin2phiephiep(0x0),\r
e17c1f86 275 fCosResabc(0x0),\r
a8ef1999 276 fSinResabc(0x0),\r
e17c1f86 277 fProfileCosResab(0x0),\r
278 fProfileCosResac(0x0),\r
279 fProfileCosResbc(0x0),\r
8c1c76e9 280 fCosRes(0x0),\r
a8ef1999 281 fSinRes(0x0),\r
e17c1f86 282 fProfileCosRes(0x0),\r
0e30407a 283 fTrackingCuts(0x0),\r
284 fDeltaPhiMapsBeforePID(0x0),\r
285 fCosPhiMapsBeforePID(0x0),\r
8c1c76e9 286 fDeltaPhiMaps(0x0),\r
5cd679b7 287 fDeltaPhiMapsContamination(0x0),\r
e17c1f86 288 fCosPhiMaps(0x0),\r
0e30407a 289 fProfileCosPhiMaps(0x0),\r
2747660f 290 fDeltaPhiMapsTaggedPhotonic(0x0),\r
6733d981 291 //fCosPhiMapsTaggedPhotonic(0x0),\r
2747660f 292 fDeltaPhiMapsTaggedNonPhotonic(0x0),\r
6733d981 293 //fCosPhiMapsTaggedNonPhotonic(0x0),\r
2747660f 294 fDeltaPhiMapsTaggedPhotonicLS(0x0),\r
6733d981 295 //fCosPhiMapsTaggedPhotonicLS(0x0),\r
0e30407a 296 fMCSourceDeltaPhiMaps(0x0),\r
297 fOppSignDeltaPhiMaps(0x0),\r
298 fSameSignDeltaPhiMaps(0x0),\r
299 fOppSignAngle(0x0),\r
959ea9d8 300 fSameSignAngle(0x0),\r
301 fDebugStreamer(0)\r
8c1c76e9 302{\r
303 //\r
304 // named ctor\r
305 //\r
e17c1f86 306 \r
307 for(Int_t k = 0; k < 10; k++) {\r
308 fBinCentralityLess[k] = 0.0;\r
309 }\r
310 fBinCentralityLess[0] = 0.0;\r
311 fBinCentralityLess[1] = 20.0;\r
312 fBinCentralityLess[2] = 40.0;\r
313 fBinCentralityLess[3] = 60.0;\r
314 fBinCentralityLess[4] = 80.0;\r
6733d981 315\r
316 for(Int_t k = 0; k < 11; k++) {\r
317 fContamination[k] = NULL;\r
6b2521a4 318 fv2contamination[k] = NULL;\r
6733d981 319 }\r
e17c1f86 320 \r
8c1c76e9 321 fPID = new AliHFEpid("hfePid");\r
322 fPIDqa = new AliHFEpidQAmanager;\r
323\r
0e30407a 324 fPIDBackground = new AliHFEpid("hfePidBackground");\r
325 fPIDBackgroundqa = new AliHFEpidQAmanager;\r
326\r
5cd679b7 327 fPIDTOFOnly = new AliHFEpid("hfePidTOFOnly");\r
328\r
8c1c76e9 329 DefineInput(0,TChain::Class());\r
330 DefineOutput(1, TList::Class());\r
7f695a7b 331 //for(Int_t bincless = 0; bincless < fNbBinsCentralityQCumulant; bincless++) {\r
332 // DefineOutput(bincless+2,AliFlowEventSimple::Class()); \r
333 //}\r
8c1c76e9 334 \r
a8ef1999 335}\r
336//____________________________________________________________\r
914042c2 337AliAnalysisTaskFlowTPCTOFEPSP::AliAnalysisTaskFlowTPCTOFEPSP(const AliAnalysisTaskFlowTPCTOFEPSP &ref):\r
a8ef1999 338 AliAnalysisTaskSE(ref),\r
7c4ec6e7 339 fListHist(NULL),\r
11ff28c5 340 fAODAnalysis(ref.fAODAnalysis), \r
2747660f 341 fUseFilterAOD(ref.fUseFilterAOD),\r
4102d1cc 342 fApplyCut(ref.fApplyCut),\r
2747660f 343 fFilter(ref.fFilter),\r
344 fAODMCHeader(ref.fAODMCHeader),\r
345 fAODArrayMCInfo(ref.fAODArrayMCInfo),\r
346 fBackgroundSubtraction(ref.fBackgroundSubtraction),\r
a8ef1999 347 fVZEROEventPlane(ref.fVZEROEventPlane),\r
348 fVZEROEventPlaneA(ref.fVZEROEventPlaneA),\r
349 fVZEROEventPlaneC(ref.fVZEROEventPlaneC),\r
350 fSubEtaGapTPC(ref.fSubEtaGapTPC),\r
351 fEtaGap(ref.fEtaGap),\r
352 fNbBinsCentralityQCumulant(ref.fNbBinsCentralityQCumulant),\r
353 fNbBinsPtQCumulant(ref.fNbBinsPtQCumulant),\r
354 fMinPtQCumulant(ref.fMinPtQCumulant),\r
355 fMaxPtQCumulant(ref.fMaxPtQCumulant),\r
356 fAfterBurnerOn(ref.fAfterBurnerOn),\r
357 fNonFlowNumberOfTrackClones(ref.fNonFlowNumberOfTrackClones),\r
358 fV1(ref.fV1),\r
359 fV2(ref.fV2),\r
360 fV3(ref.fV3),\r
361 fV4(ref.fV4),\r
362 fV5(ref.fV5),\r
363 fMaxNumberOfIterations(ref.fMaxNumberOfIterations),\r
364 fPrecisionPhi(ref.fPrecisionPhi),\r
365 fUseMCReactionPlane(ref.fUseMCReactionPlane),\r
959ea9d8 366 fSP(ref.fSP),\r
a8ef1999 367 fMCPID(ref.fMCPID),\r
368 fNoPID(ref.fNoPID),\r
0e30407a 369 fChi2OverNDFCut(ref.fChi2OverNDFCut),\r
370 fMaxdca(ref.fMaxdca),\r
371 fMaxopeningtheta(ref.fMaxopeningtheta),\r
372 fMaxopeningphi(ref.fMaxopeningphi),\r
373 fMaxopening3D(ref.fMaxopening3D),\r
374 fMaxInvmass(ref.fMaxInvmass),\r
7b4c9210 375 fSetMassConstraint(ref.fSetMassConstraint),\r
a8ef1999 376 fDebugLevel(ref.fDebugLevel),\r
7b5936fc 377 fMonitorEventPlane(ref.fMonitorEventPlane),\r
378 fMonitorContamination(ref.fMonitorContamination),\r
379 fMonitorPhotonic(ref.fMonitorPhotonic),\r
380 fMonitorWithoutPID(ref.fMonitorWithoutPID),\r
381 fMonitorTrackCuts(ref.fMonitorTrackCuts),\r
382 fMonitorQCumulant(ref.fMonitorQCumulant),\r
7c4ec6e7 383 fcutsRP(NULL),\r
384 fcutsPOI(NULL),\r
385 fHFECuts(NULL),\r
2747660f 386 fRejectKinkMother(ref.fRejectKinkMother),\r
7c4ec6e7 387 fPID(NULL),\r
5cd679b7 388 fPIDTOFOnly(NULL),\r
7c4ec6e7 389 fPIDqa(NULL),\r
0e30407a 390 fflowEvent(NULL),\r
7c4ec6e7 391 fHFEBackgroundCuts(NULL),\r
392 fPIDBackground(NULL),\r
393 fPIDBackgroundqa(NULL),\r
394 fAlgorithmMA(ref.fAlgorithmMA),\r
0e30407a 395 fArraytrack(NULL),\r
7c4ec6e7 396 fCounterPoolBackground(ref.fCounterPoolBackground),\r
397 fHFEVZEROEventPlane(NULL),\r
2747660f 398 fHistEV(NULL),\r
a70c9e97 399 fHistPileUp(NULL),\r
d87a9d29 400 fPileUpCut(kFALSE),\r
7c4ec6e7 401 fEventPlane(NULL),\r
402 fEventPlaneaftersubtraction(NULL),\r
6733d981 403 fFractionContamination(NULL),\r
6b2521a4 404 fContaminationv2(NULL),\r
7c4ec6e7 405 fCosSin2phiep(NULL),\r
406 fCos2phie(NULL),\r
407 fSin2phie(NULL),\r
408 fCos2phiep(NULL),\r
409 fSin2phiep(NULL),\r
410 fSin2phiephiep(NULL),\r
411 fCosResabc(NULL),\r
412 fSinResabc(NULL),\r
413 fProfileCosResab(NULL),\r
414 fProfileCosResac(NULL),\r
415 fProfileCosResbc(NULL),\r
416 fCosRes(NULL),\r
417 fSinRes(NULL),\r
418 fProfileCosRes(NULL),\r
419 fTrackingCuts(NULL),\r
420 fDeltaPhiMapsBeforePID(NULL),\r
421 fCosPhiMapsBeforePID(NULL),\r
422 fDeltaPhiMaps(NULL),\r
5cd679b7 423 fDeltaPhiMapsContamination(NULL),\r
7c4ec6e7 424 fCosPhiMaps(NULL),\r
425 fProfileCosPhiMaps(NULL),\r
2747660f 426 fDeltaPhiMapsTaggedPhotonic(NULL),\r
6733d981 427 //fCosPhiMapsTaggedPhotonic(NULL),\r
2747660f 428 fDeltaPhiMapsTaggedNonPhotonic(NULL),\r
6733d981 429 //fCosPhiMapsTaggedNonPhotonic(NULL),\r
2747660f 430 fDeltaPhiMapsTaggedPhotonicLS(NULL),\r
6733d981 431 //fCosPhiMapsTaggedPhotonicLS(NULL),\r
7c4ec6e7 432 fMCSourceDeltaPhiMaps(NULL),\r
433 fOppSignDeltaPhiMaps(NULL),\r
434 fSameSignDeltaPhiMaps(NULL),\r
435 fOppSignAngle(NULL),\r
959ea9d8 436 fSameSignAngle(NULL),\r
437 fDebugStreamer(0)\r
a8ef1999 438{\r
439 //\r
440 // Copy Constructor\r
441 //\r
442 ref.Copy(*this);\r
443}\r
444\r
445//____________________________________________________________\r
914042c2 446AliAnalysisTaskFlowTPCTOFEPSP &AliAnalysisTaskFlowTPCTOFEPSP::operator=(const AliAnalysisTaskFlowTPCTOFEPSP &ref){\r
a8ef1999 447 //\r
448 // Assignment operator\r
449 //\r
450 if(this == &ref) \r
451 ref.Copy(*this);\r
452 return *this;\r
453}\r
454\r
455//____________________________________________________________\r
914042c2 456void AliAnalysisTaskFlowTPCTOFEPSP::Copy(TObject &o) const {\r
a8ef1999 457 // \r
458 // Copy into object o\r
459 //\r
914042c2 460 AliAnalysisTaskFlowTPCTOFEPSP &target = dynamic_cast<AliAnalysisTaskFlowTPCTOFEPSP &>(o);\r
11ff28c5 461 target.fAODAnalysis = fAODAnalysis;\r
2747660f 462 target.fUseFilterAOD = fUseFilterAOD;\r
4102d1cc 463 target.fApplyCut = fApplyCut;\r
2747660f 464 target.fFilter = fFilter;\r
465 target.fAODMCHeader = fAODMCHeader;\r
466 target.fAODArrayMCInfo = fAODArrayMCInfo;\r
467 target.fBackgroundSubtraction = fBackgroundSubtraction;\r
a8ef1999 468 target.fVZEROEventPlane = fVZEROEventPlane;\r
469 target.fVZEROEventPlaneA = fVZEROEventPlaneA;\r
470 target.fVZEROEventPlaneC = fVZEROEventPlaneC;\r
471 target.fSubEtaGapTPC = fSubEtaGapTPC;\r
472 target.fEtaGap = fEtaGap;\r
473 target.fNbBinsCentralityQCumulant = fNbBinsCentralityQCumulant;\r
474 target.fNbBinsPtQCumulant = fNbBinsPtQCumulant;\r
475 target.fMinPtQCumulant = fMinPtQCumulant;\r
476 target.fMaxPtQCumulant = fMaxPtQCumulant;\r
477 target.fAfterBurnerOn = fAfterBurnerOn;\r
478 target.fNonFlowNumberOfTrackClones = fNonFlowNumberOfTrackClones;\r
479 target.fV1 = fV1;\r
480 target.fV2 = fV2;\r
481 target.fV3 = fV3;\r
482 target.fV4 = fV4;\r
483 target.fV5 = fV5;\r
484 target.fMaxNumberOfIterations = fMaxNumberOfIterations;\r
485 target.fPrecisionPhi = fPrecisionPhi;\r
486 target.fUseMCReactionPlane = fUseMCReactionPlane;\r
959ea9d8 487 target.fSP = fSP;\r
a8ef1999 488 target.fMCPID = fMCPID;\r
489 target.fNoPID = fNoPID;\r
0e30407a 490 target.fChi2OverNDFCut = fChi2OverNDFCut;\r
491 target.fMaxdca = fMaxdca;\r
492 target.fMaxopeningtheta = fMaxopeningtheta;\r
493 target.fMaxopeningphi = fMaxopeningphi;\r
494 target.fMaxopening3D = fMaxopening3D;\r
495 target.fMaxInvmass = fMaxInvmass;\r
7b4c9210 496 target.fSetMassConstraint = fSetMassConstraint;\r
d87a9d29 497 target.fAlgorithmMA = fAlgorithmMA;\r
0e30407a 498 target.fCounterPoolBackground = fCounterPoolBackground;\r
a8ef1999 499 target.fDebugLevel = fDebugLevel;\r
7b5936fc 500 target.fMonitorEventPlane = fMonitorEventPlane;\r
501 target.fMonitorContamination = fMonitorContamination;\r
502 target.fMonitorPhotonic = fMonitorPhotonic;\r
503 target.fMonitorWithoutPID = fMonitorWithoutPID;\r
504 target.fMonitorTrackCuts = fMonitorTrackCuts;\r
505 target.fMonitorQCumulant = fMonitorQCumulant;\r
a8ef1999 506 target.fcutsRP = fcutsRP;\r
507 target.fcutsPOI = fcutsPOI;\r
508 target.fHFECuts = fHFECuts;\r
2747660f 509 target.fRejectKinkMother = fRejectKinkMother;\r
a8ef1999 510 target.fPID = fPID;\r
511 target.fPIDqa = fPIDqa;\r
512 target.fHFEVZEROEventPlane = fHFEVZEROEventPlane;\r
6733d981 513 for(Int_t k = 0; k < 11; k++) {\r
514 target.fContamination[k] = fContamination[k];\r
6b2521a4 515 target.fv2contamination[k] = fv2contamination[k];\r
6733d981 516 }\r
959ea9d8 517 target.fDebugStreamer=fDebugStreamer;\r
a8ef1999 518}\r
519//____________________________________________________________\r
914042c2 520AliAnalysisTaskFlowTPCTOFEPSP::~AliAnalysisTaskFlowTPCTOFEPSP(){\r
a8ef1999 521 //\r
522 // Destructor\r
523 //\r
0e30407a 524 if(fArraytrack) delete fArraytrack;\r
a8ef1999 525 if(fListHist) delete fListHist;\r
526 if(fcutsRP) delete fcutsRP;\r
527 if(fcutsPOI) delete fcutsPOI;\r
528 if(fHFECuts) delete fHFECuts;\r
529 if(fPID) delete fPID;\r
5cd679b7 530 if(fPIDTOFOnly) delete fPIDTOFOnly;\r
f20c8eba 531 //if(fPIDqa) delete fPIDqa;\r
a8ef1999 532 if(fflowEvent) delete fflowEvent;\r
0e30407a 533 if(fHFEBackgroundCuts) delete fHFEBackgroundCuts;\r
534 if(fPIDBackground) delete fPIDBackground;\r
2747660f 535 if(fBackgroundSubtraction) delete fBackgroundSubtraction;\r
f20c8eba 536 //if(fPIDBackgroundqa) delete fPIDBackgroundqa;\r
0e30407a 537 //if(fHFEVZEROEventPlane) delete fHFEVZEROEventPlane;\r
959ea9d8 538 if ( fDebugStreamer ) delete fDebugStreamer;\r
a8ef1999 539\r
8c1c76e9 540}\r
541//________________________________________________________________________\r
914042c2 542void AliAnalysisTaskFlowTPCTOFEPSP::UserCreateOutputObjects()\r
8c1c76e9 543{\r
544\r
545 //********************\r
546 // Create histograms\r
547 //********************\r
548\r
549 //**************\r
550 // Cuts\r
551 //**************\r
552\r
553 //---------Data selection----------\r
554 //kMC, kGlobal, kTPCstandalone, kSPDtracklet, kPMD\r
555 //AliFlowTrackCuts::trackParameterType rptype = AliFlowTrackCuts::kGlobal;\r
556 //AliFlowTrackCuts::trackParameterType poitype = AliFlowTrackCuts::kGlobal;\r
557\r
558 //---------Parameter mixing--------\r
559 //kPure - no mixing, kTrackWithMCkine, kTrackWithMCPID, kTrackWithMCpt\r
560 //AliFlowTrackCuts::trackParameterMix rpmix = AliFlowTrackCuts::kPure;\r
561 //AliFlowTrackCuts::trackParameterMix poimix = AliFlowTrackCuts::kPure;\r
90aa28e9 562\r
7f695a7b 563 AliDebug(2,"test");\r
564\r
914042c2 565 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: User create output objects");\r
4102d1cc 566 \r
567 // AOD or ESD\r
568 AliVEventHandler *inputHandler = dynamic_cast<AliVEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
569 if(!TString(inputHandler->IsA()->GetName()).CompareTo("AliAODInputHandler")){\r
570 SetAODAnalysis(kTRUE);\r
7f695a7b 571 AliDebug(2,"Put AOD analysis on");\r
4102d1cc 572 } else {\r
573 SetAODAnalysis(kFALSE);\r
574 }\r
575\r
914042c2 576 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: AOD ESD");\r
8c1c76e9 577\r
578 // RP TRACK CUTS:\r
579 fcutsRP = AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts2010();\r
580 fcutsRP->SetName("StandartTPC");\r
581 fcutsRP->SetEtaRange(-0.9,0.9);\r
582 fcutsRP->SetQA(kTRUE);\r
11ff28c5 583 //TList *qaCutsRP = fcutsRP->GetQA();\r
584 //qaCutsRP->SetName("QA_StandartTPC_RP");\r
8c1c76e9 585\r
914042c2 586 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cutsRP");\r
90aa28e9 587\r
8c1c76e9 588 //POI TRACK CUTS:\r
589 fcutsPOI = new AliFlowTrackCuts("dummy");\r
590 fcutsPOI->SetParamType(AliFlowTrackCuts::kGlobal);\r
591 fcutsPOI->SetPtRange(+1,-1); // select nothing QUICK\r
592 fcutsPOI->SetEtaRange(+1,-1); // select nothing VZERO\r
593\r
7f695a7b 594 if( fflowEvent ){ \r
595 fflowEvent->~AliFlowEvent();\r
596 new(fflowEvent) AliFlowEvent(fcutsRP,fcutsPOI);\r
597 }\r
598 else fflowEvent = new AliFlowEvent(fcutsRP,fcutsPOI);\r
599 \r
914042c2 600 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cutsPOI");\r
90aa28e9 601\r
8c1c76e9 602 // Flow\r
603 AliFlowCommonConstants* cc = AliFlowCommonConstants::GetMaster();\r
604 cc->SetNbinsMult(10000);\r
605 cc->SetMultMin(0);\r
606 cc->SetMultMax(10000.);\r
607 cc->SetNbinsPt(fNbBinsPtQCumulant);\r
608 cc->SetPtMin(fMinPtQCumulant);\r
609 cc->SetPtMax(fMaxPtQCumulant);\r
610 cc->SetNbinsPhi(180);\r
611 cc->SetPhiMin(0.0);\r
612 cc->SetPhiMax(TMath::TwoPi());\r
613 cc->SetNbinsEta(200);\r
614 cc->SetEtaMin(-0.9);\r
615 cc->SetEtaMax(+0.9);\r
616 cc->SetNbinsQ(500);\r
617 cc->SetQMin(0.0);\r
618 cc->SetQMax(3.0);\r
619\r
914042c2 620 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: common constants");\r
90aa28e9 621\r
8c1c76e9 622 \r
623 // HFE cuts\r
624\r
625 if(!fHFECuts){\r
626 fHFECuts = new AliHFEcuts;\r
627 fHFECuts->CreateStandardCuts();\r
628 }\r
629 fHFECuts->Initialize();\r
11ff28c5 630 if(fAODAnalysis) fHFECuts->SetAOD(); \r
631\r
914042c2 632 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: HFE cuts");\r
90aa28e9 633\r
634\r
8c1c76e9 635 // PID HFE\r
636 //fPID->SetHasMCData(HasMCData());\r
7f695a7b 637 if(!fPID) {\r
638 fPID =new AliHFEpid("hfePid");\r
914042c2 639 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: pid init 0");\r
7f695a7b 640 }\r
914042c2 641 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: pid init 1");\r
8c1c76e9 642 if(!fPID->GetNumberOfPIDdetectors()) fPID->AddDetector("TPC", 0);\r
914042c2 643 AliDebug(2,Form("AliAnalysisTaskFlowTPCTOFEPSP: GetNumber of PID detectors %d",fPID->GetNumberOfPIDdetectors()));\r
8c1c76e9 644 fPID->InitializePID();\r
7f695a7b 645 AliDebug(2,"Init ");\r
8c1c76e9 646 fPIDqa->Initialize(fPID);\r
7f695a7b 647 AliDebug(2,"Init qa");\r
8c1c76e9 648 fPID->SortDetectors();\r
7f695a7b 649 AliDebug(2,"Sort detectors");\r
0e30407a 650\r
914042c2 651 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: pid and pidqa");\r
90aa28e9 652\r
5cd679b7 653 if(!fPIDTOFOnly->GetNumberOfPIDdetectors()) fPIDTOFOnly->AddDetector("TPC", 0);\r
654 fPIDTOFOnly->InitializePID();\r
655 fPIDTOFOnly->SortDetectors();\r
656\r
914042c2 657 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: pidtof");\r
90aa28e9 658\r
0e30407a 659 // HFE Background cuts\r
660\r
661 if(!fHFEBackgroundCuts){\r
662 fHFEBackgroundCuts = new AliESDtrackCuts();\r
663 fHFEBackgroundCuts->SetName("nackgroundcuts");\r
664 //Configure Default Track Cuts\r
665 fHFEBackgroundCuts->SetAcceptKinkDaughters(kFALSE);\r
666 fHFEBackgroundCuts->SetRequireTPCRefit(kTRUE);\r
667 fHFEBackgroundCuts->SetEtaRange(-0.9,0.9);\r
668 fHFEBackgroundCuts->SetRequireSigmaToVertex(kTRUE);\r
669 fHFEBackgroundCuts->SetMaxChi2PerClusterTPC(4.0);\r
670 fHFEBackgroundCuts->SetMinNClustersTPC(50);\r
671 fHFEBackgroundCuts->SetPtRange(0.3,1e10);\r
672 }\r
8c1c76e9 673 \r
914042c2 674 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: hfe background");\r
90aa28e9 675\r
0e30407a 676 // PID background HFE\r
677 if(!fPIDBackground->GetNumberOfPIDdetectors()) fPIDBackground->AddDetector("TPC", 0);\r
678 fPIDBackground->InitializePID();\r
679 fPIDBackgroundqa->Initialize(fPIDBackground);\r
680 fPIDBackground->SortDetectors();\r
90aa28e9 681\r
914042c2 682 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: pid background");\r
2747660f 683\r
684 if (fMonitorPhotonic) {\r
685 if(!fBackgroundSubtraction) fBackgroundSubtraction = new AliHFENonPhotonicElectron();\r
686 fBackgroundSubtraction->Init();\r
687 }\r
0e30407a 688 \r
689\r
690\r
8c1c76e9 691 //**************************\r
692 // Bins for the THnSparse\r
693 //**************************\r
694\r
5cd679b7 695 /*\r
11ff28c5 696 Int_t nBinsPt = 44;\r
697 Double_t minPt = 0.1;\r
698 Double_t maxPt = 20.0;\r
8c1c76e9 699 Double_t binLimLogPt[nBinsPt+1];\r
700 Double_t binLimPt[nBinsPt+1];\r
701 for(Int_t i=0; i<=nBinsPt; i++) binLimLogPt[i]=(Double_t)TMath::Log10(minPt) + (TMath::Log10(maxPt)-TMath::Log10(minPt))/nBinsPt*(Double_t)i ;\r
702 for(Int_t i=0; i<=nBinsPt; i++) binLimPt[i]=(Double_t)TMath::Power(10,binLimLogPt[i]);\r
5cd679b7 703 */\r
704\r
2747660f 705 Int_t nBinsPt = 24;\r
706 Double_t binLimPt[25] = {0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2,\r
707 1.3, 1.4, 1.5, 1.75, 2., 2.25, 2.5, 3., 3.5, 4., 5.,\r
708 6.};\r
5cd679b7 709\r
8c1c76e9 710\r
11ff28c5 711 Int_t nBinsPtPlus = fNbBinsPtQCumulant;\r
712 Double_t minPtPlus = fMinPtQCumulant;\r
713 Double_t maxPtPlus = fMaxPtQCumulant;\r
e17c1f86 714 Double_t binLimPtPlus[nBinsPtPlus+1];\r
715 for(Int_t i=0; i<=nBinsPtPlus; i++) binLimPtPlus[i]=(Double_t)minPtPlus + (maxPtPlus-minPtPlus)/nBinsPtPlus*(Double_t)i ;\r
716\r
8c1c76e9 717 Int_t nBinsEta = 8;\r
718 Double_t minEta = -0.8;\r
719 Double_t maxEta = 0.8;\r
720 Double_t binLimEta[nBinsEta+1];\r
721 for(Int_t i=0; i<=nBinsEta; i++) binLimEta[i]=(Double_t)minEta + (maxEta-minEta)/nBinsEta*(Double_t)i ;\r
11ff28c5 722\r
4317a065 723 Int_t nBinsStep = 7;\r
0e30407a 724 Double_t minStep = 0.;\r
4317a065 725 Double_t maxStep = 7.;\r
0e30407a 726 Double_t binLimStep[nBinsStep+1];\r
727 for(Int_t i=0; i<=nBinsStep; i++) binLimStep[i]=(Double_t)minStep + (maxStep-minStep)/nBinsStep*(Double_t)i ;\r
728\r
11ff28c5 729 Int_t nBinsEtaLess = 2;\r
730 Double_t binLimEtaLess[nBinsEtaLess+1];\r
731 for(Int_t i=0; i<=nBinsEtaLess; i++) binLimEtaLess[i]=(Double_t)minEta + (maxEta-minEta)/nBinsEtaLess*(Double_t)i ;\r
8c1c76e9 732 \r
733 Int_t nBinsCos = 50;\r
734 Double_t minCos = -1.0;\r
735 Double_t maxCos = 1.0;\r
736 Double_t binLimCos[nBinsCos+1];\r
737 for(Int_t i=0; i<=nBinsCos; i++) binLimCos[i]=(Double_t)minCos + (maxCos-minCos)/nBinsCos*(Double_t)i ;\r
959ea9d8 738\r
739 // Int_t nBinsCosSP = 50;\r
740 // Double_t minCosSP = -100.0;\r
741 // Double_t maxCosSP = 100.0;\r
742 // Double_t binLimCosSP[nBinsCosSP+1];\r
743 // for(Int_t i=0; i<=nBinsCosSP; i++) binLimCosSP[i]=(Double_t)minCosSP + (maxCosSP-minCosSP)/nBinsCosSP*(Double_t)i ;\r
8c1c76e9 744 \r
8c1c76e9 745 Int_t nBinsC = 11;\r
746 Double_t minC = 0.0;\r
747 Double_t maxC = 11.0;\r
748 Double_t binLimC[nBinsC+1];\r
749 for(Int_t i=0; i<=nBinsC; i++) binLimC[i]=(Double_t)minC + (maxC-minC)/nBinsC*(Double_t)i ;\r
e17c1f86 750\r
751 Int_t nBinsCMore = 20;\r
752 Double_t minCMore = 0.0;\r
753 Double_t maxCMore = 20.0;\r
754 Double_t binLimCMore[nBinsCMore+1];\r
755 for(Int_t i=0; i<=nBinsCMore; i++) binLimCMore[i]=(Double_t)minCMore + (maxCMore-minCMore)/nBinsCMore*(Double_t)i ;\r
756\r
d87a9d29 757 Int_t nBinsCEvenMore = 100;\r
758 Double_t minCEvenMore = 0.0;\r
759 Double_t maxCEvenMore = 100.0;\r
760 Double_t binLimCEvenMore[nBinsCEvenMore+1];\r
761 for(Int_t i=0; i<=nBinsCEvenMore; i++) binLimCEvenMore[i]=(Double_t)minCEvenMore + (maxCEvenMore-minCEvenMore)/nBinsCEvenMore*(Double_t)i ;\r
762\r
7b5936fc 763 Int_t nBinsPhi = 8;\r
8c1c76e9 764 Double_t minPhi = 0.0;\r
765 Double_t maxPhi = TMath::Pi();\r
766 Double_t binLimPhi[nBinsPhi+1];\r
767 for(Int_t i=0; i<=nBinsPhi; i++) {\r
768 binLimPhi[i]=(Double_t)minPhi + (maxPhi-minPhi)/nBinsPhi*(Double_t)i ;\r
7f695a7b 769 AliDebug(2,Form("bin phi is %f for %d",binLimPhi[i],i));\r
8c1c76e9 770 }\r
11ff28c5 771\r
5cd679b7 772 Int_t nBinsPhiLess = 2.0;\r
773 Double_t minPhiLess = 0.0;\r
774 Double_t maxPhiLess = 2.0;\r
775 Double_t binLimPhiLess[nBinsPhiLess+1];\r
776 for(Int_t i=0; i<=nBinsPhiLess; i++) {\r
777 binLimPhiLess[i]=(Double_t)minPhiLess + (maxPhiLess-minPhiLess)/nBinsPhiLess*(Double_t)i ;\r
778 }\r
779\r
780 Int_t nBinsTPCdEdx = 140;\r
781 Double_t minTPCdEdx = -12.0;\r
782 Double_t maxTPCdEdx = 12.0;\r
783 Double_t binLimTPCdEdx[nBinsTPCdEdx+1];\r
784 for(Int_t i=0; i<=nBinsTPCdEdx; i++) {\r
785 binLimTPCdEdx[i]=(Double_t)minTPCdEdx + (maxTPCdEdx-minTPCdEdx)/nBinsTPCdEdx*(Double_t)i ;\r
786 }\r
787\r
0e30407a 788 Int_t nBinsAngle = 40;\r
789 Double_t minAngle = 0.0;\r
790 Double_t maxAngle = 1.0;\r
791 Double_t binLimAngle[nBinsAngle+1];\r
792 for(Int_t i=0; i<=nBinsAngle; i++) {\r
793 binLimAngle[i]=(Double_t)minAngle + (maxAngle-minAngle)/nBinsAngle*(Double_t)i ;\r
7f695a7b 794 AliDebug(2,Form("bin phi is %f for %d",binLimPhi[i],i));\r
0e30407a 795 }\r
796\r
11ff28c5 797 Int_t nBinsCharge = 2;\r
798 Double_t minCharge = -1.0;\r
799 Double_t maxCharge = 1.0;\r
800 Double_t binLimCharge[nBinsCharge+1];\r
801 for(Int_t i=0; i<=nBinsCharge; i++) binLimCharge[i]=(Double_t)minCharge + (maxCharge-minCharge)/nBinsCharge*(Double_t)i ;\r
0e30407a 802\r
7b4c9210 803 Int_t nBinsSource = 10;\r
0e30407a 804 Double_t minSource = 0.;\r
7b4c9210 805 Double_t maxSource = 10.;\r
0e30407a 806 Double_t binLimSource[nBinsSource+1];\r
807 for(Int_t i=0; i<=nBinsSource; i++) binLimSource[i]=(Double_t)minSource + (maxSource-minSource)/nBinsSource*(Double_t)i ;\r
808\r
809 Int_t nBinsInvMass = 50;\r
810 Double_t minInvMass = 0.;\r
811 Double_t maxInvMass = 0.3;\r
812 Double_t binLimInvMass[nBinsInvMass+1];\r
813 for(Int_t i=0; i<=nBinsInvMass; i++) binLimInvMass[i]=(Double_t)minInvMass + (maxInvMass-minInvMass)/nBinsInvMass*(Double_t)i ;\r
90aa28e9 814\r
3112b3a5 815 Int_t nBinsMult = 100;\r
a70c9e97 816 Double_t minMult = 0.;\r
d87a9d29 817 Double_t maxMult = 3000;\r
a70c9e97 818 Double_t binLimMult[nBinsMult+1];\r
819 //for(Int_t i=0; i<=nBinsMult; i++) binLimMult[i]=TMath::Power((Double_t)minMult + (TMath::Sqrt(maxMult)-TMath::Sqrt(minMult))/nBinsMult*(Double_t)i,2);\r
820 for(Int_t i=0; i<=nBinsMult; i++) binLimMult[i]=(Double_t)minMult + (maxMult-minMult)/nBinsMult*(Double_t)i;\r
821\r
914042c2 822 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: variables");\r
8c1c76e9 823 \r
8c1c76e9 824 //******************\r
825 // Histograms\r
826 //******************\r
827 \r
828 fListHist = new TList();\r
0e30407a 829 fListHist->SetOwner();\r
8c1c76e9 830\r
914042c2 831 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: list");\r
90aa28e9 832\r
7b5936fc 833 // Minimum histos\r
834\r
8c1c76e9 835 // Histos\r
2747660f 836 fHistEV = new TH2D("fHistEV", "events", 3, 0, 3, 3, 0,3);\r
8c1c76e9 837 \r
914042c2 838 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: histev");\r
90aa28e9 839\r
a70c9e97 840 // V0 multiplicity vs # of tracks vs centraliy\r
d87a9d29 841 const Int_t nDimPU=4;\r
842 Int_t nBinPU[nDimPU] = {nBinsCEvenMore,nBinsCEvenMore,nBinsMult,nBinsMult};\r
a70c9e97 843 fHistPileUp = new THnSparseF("PileUp","PileUp",nDimPU,nBinPU);\r
d87a9d29 844 fHistPileUp->SetBinEdges(0,binLimCEvenMore);\r
845 fHistPileUp->SetBinEdges(1,binLimCEvenMore);\r
846 fHistPileUp->SetBinEdges(2,binLimMult);\r
847 fHistPileUp->SetBinEdges(3,binLimMult);\r
a70c9e97 848 fHistPileUp->Sumw2();\r
849 \r
850 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: eventplane");\r
851 \r
8c1c76e9 852 // Event plane as function of phiep, centrality\r
6733d981 853 const Int_t nDima=4;\r
854 Int_t nBina[nDima] = {nBinsPhi,nBinsPhi,nBinsPhi,nBinsC};\r
8c1c76e9 855 fEventPlane = new THnSparseF("EventPlane","EventPlane",nDima,nBina);\r
856 fEventPlane->SetBinEdges(0,binLimPhi);\r
e17c1f86 857 fEventPlane->SetBinEdges(1,binLimPhi);\r
858 fEventPlane->SetBinEdges(2,binLimPhi);\r
6733d981 859 fEventPlane->SetBinEdges(3,binLimC);\r
e17c1f86 860 fEventPlane->Sumw2();\r
e17c1f86 861\r
914042c2 862 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: eventplane");\r
90aa28e9 863\r
6733d981 864 // Fraction of contamination, centrality\r
865 const Int_t nDimcont=2;\r
866 Int_t nBincont[nDimcont] = {nBinsPt,nBinsC};\r
867 fFractionContamination = new THnSparseF("Contamination","Contamination",nDimcont,nBincont);\r
868 fFractionContamination->SetBinEdges(0,binLimPt);\r
869 fFractionContamination->SetBinEdges(1,binLimC);\r
870 fFractionContamination->Sumw2();\r
6b2521a4 871 // \r
872 fContaminationv2 = new TProfile2D("Contaminationv2","",nBinsC,binLimC,nBinsPt,binLimPt);\r
873 fContaminationv2->Sumw2();\r
6733d981 874\r
914042c2 875 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: fraction of contamination");\r
6733d981 876\r
e17c1f86 877 // Resolution cosres_abc centrality\r
878 const Int_t nDimfbis=4;\r
879 Int_t nBinfbis[nDimfbis] = {nBinsCos,nBinsCos,nBinsCos,nBinsCMore};\r
880 fCosResabc = new THnSparseF("CosRes_abc","CosRes_abc",nDimfbis,nBinfbis);\r
881 fCosResabc->SetBinEdges(0,binLimCos);\r
882 fCosResabc->SetBinEdges(1,binLimCos);\r
883 fCosResabc->SetBinEdges(2,binLimCos);\r
884 fCosResabc->SetBinEdges(3,binLimCMore);\r
885 fCosResabc->Sumw2();\r
886\r
914042c2 887 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosresabc");\r
90aa28e9 888\r
8c1c76e9 889 // Resolution cosres centrality\r
890 const Int_t nDimf=2;\r
e17c1f86 891 Int_t nBinf[nDimf] = {nBinsCos, nBinsCMore};\r
8c1c76e9 892 fCosRes = new THnSparseF("CosRes","CosRes",nDimf,nBinf);\r
893 fCosRes->SetBinEdges(0,binLimCos);\r
e17c1f86 894 fCosRes->SetBinEdges(1,binLimCMore);\r
895 fCosRes->Sumw2();\r
896\r
914042c2 897 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosres");\r
90aa28e9 898\r
8c1c76e9 899 // Maps delta phi\r
11ff28c5 900 const Int_t nDimg=5;\r
901 Int_t nBing[nDimg] = {nBinsPhi,nBinsC,nBinsPt, nBinsCharge,nBinsEtaLess};\r
8c1c76e9 902 fDeltaPhiMaps = new THnSparseF("DeltaPhiMaps","DeltaPhiMaps",nDimg,nBing);\r
903 fDeltaPhiMaps->SetBinEdges(0,binLimPhi);\r
904 fDeltaPhiMaps->SetBinEdges(1,binLimC);\r
905 fDeltaPhiMaps->SetBinEdges(2,binLimPt);\r
11ff28c5 906 fDeltaPhiMaps->SetBinEdges(3,binLimCharge);\r
907 fDeltaPhiMaps->SetBinEdges(4,binLimEtaLess);\r
e17c1f86 908 fDeltaPhiMaps->Sumw2(); \r
909\r
914042c2 910 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimaps");\r
90aa28e9 911\r
8c1c76e9 912 // Maps cos phi\r
11ff28c5 913 const Int_t nDimh=5;\r
914 Int_t nBinh[nDimh] = {nBinsCos,nBinsC,nBinsPt,nBinsCharge,nBinsEtaLess};\r
8c1c76e9 915 fCosPhiMaps = new THnSparseF("CosPhiMaps","CosPhiMaps",nDimh,nBinh);\r
916 fCosPhiMaps->SetBinEdges(0,binLimCos);\r
917 fCosPhiMaps->SetBinEdges(1,binLimC);\r
918 fCosPhiMaps->SetBinEdges(2,binLimPt);\r
11ff28c5 919 fCosPhiMaps->SetBinEdges(3,binLimCharge);\r
920 fCosPhiMaps->SetBinEdges(4,binLimEtaLess);\r
e17c1f86 921 fCosPhiMaps->Sumw2();\r
922\r
914042c2 923 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosphimaps");\r
90aa28e9 924\r
7b5936fc 925 //\r
926 // fMonitorEventPlane\r
927 //\r
928 //\r
0e30407a 929\r
7b5936fc 930 if(fMonitorEventPlane) { \r
931 // Event Plane after subtraction as function of phiep, centrality, pt, eta\r
932 const Int_t nDimb=2;\r
933 Int_t nBinb[nDimb] = {nBinsPhi, nBinsC};\r
934 fEventPlaneaftersubtraction = new THnSparseF("EventPlane_aftersubtraction","EventPlane_aftersubtraction",nDimb,nBinb);\r
935 fEventPlaneaftersubtraction->SetBinEdges(0,binLimPhi);\r
936 fEventPlaneaftersubtraction->SetBinEdges(1,binLimC);\r
937 fEventPlaneaftersubtraction->Sumw2();\r
90aa28e9 938\r
914042c2 939 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: eventplane after sub");\r
7b5936fc 940 \r
941 // Monitoring of the event Plane cos(2phi) sin(2phi) centrality\r
942 const Int_t nDimi=3;\r
943 Int_t nBini[nDimi] = {nBinsCos, nBinsCos, nBinsCMore};\r
944 fCosSin2phiep = new THnSparseF("CosSin2phiep","CosSin2phiep",nDimi,nBini);\r
945 fCosSin2phiep->SetBinEdges(0,binLimCos);\r
946 fCosSin2phiep->SetBinEdges(1,binLimCos);\r
947 fCosSin2phiep->SetBinEdges(2,binLimCMore);\r
948 fCosSin2phiep->Sumw2();\r
90aa28e9 949\r
914042c2 950 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cossin2phiep");\r
7b5936fc 951 \r
952 // Monitoring Event plane after subtraction of the track\r
953 const Int_t nDime=4;\r
954 Int_t nBine[nDime] = {nBinsCos, nBinsC, nBinsPt, nBinsEta};\r
955 fCos2phie = new THnSparseF("cos2phie","cos2phie",nDime,nBine);\r
956 fCos2phie->SetBinEdges(2,binLimPt);\r
957 fCos2phie->SetBinEdges(3,binLimEta);\r
958 fCos2phie->SetBinEdges(0,binLimCos);\r
959 fCos2phie->SetBinEdges(1,binLimC);\r
960 fCos2phie->Sumw2();\r
914042c2 961 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cos2phie");\r
7b5936fc 962 fSin2phie = new THnSparseF("sin2phie","sin2phie",nDime,nBine);\r
963 fSin2phie->SetBinEdges(2,binLimPt);\r
964 fSin2phie->SetBinEdges(3,binLimEta);\r
965 fSin2phie->SetBinEdges(0,binLimCos);\r
966 fSin2phie->SetBinEdges(1,binLimC);\r
967 fSin2phie->Sumw2();\r
914042c2 968 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: sin2phie");\r
7b5936fc 969 fCos2phiep = new THnSparseF("cos2phiep","cos2phiep",nDime,nBine);\r
970 fCos2phiep->SetBinEdges(2,binLimPt);\r
971 fCos2phiep->SetBinEdges(3,binLimEta);\r
972 fCos2phiep->SetBinEdges(0,binLimCos);\r
973 fCos2phiep->SetBinEdges(1,binLimC);\r
974 fCos2phiep->Sumw2();\r
914042c2 975 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cos2phiep");\r
7b5936fc 976 fSin2phiep = new THnSparseF("sin2phiep","sin2phiep",nDime,nBine);\r
977 fSin2phiep->SetBinEdges(2,binLimPt);\r
978 fSin2phiep->SetBinEdges(3,binLimEta);\r
979 fSin2phiep->SetBinEdges(0,binLimCos);\r
980 fSin2phiep->SetBinEdges(1,binLimC);\r
981 fSin2phiep->Sumw2();\r
914042c2 982 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: sin2phiep");\r
7b5936fc 983 fSin2phiephiep = new THnSparseF("sin2phie_phiep","sin2phie_phiep",nDime,nBine);\r
984 fSin2phiephiep->SetBinEdges(2,binLimPt);\r
985 fSin2phiephiep->SetBinEdges(3,binLimEta);\r
986 fSin2phiephiep->SetBinEdges(0,binLimCos);\r
987 fSin2phiephiep->SetBinEdges(1,binLimC);\r
988 fSin2phiephiep->Sumw2(); \r
914042c2 989 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: sin2phiephiep");\r
7b5936fc 990 \r
991 const Int_t nDimfbiss=4;\r
992 Int_t nBinfbiss[nDimfbiss] = {nBinsCos,nBinsCos,nBinsCos,nBinsC};\r
993 fSinResabc = new THnSparseF("SinRes_abc","SinRes_abc",nDimfbiss,nBinfbiss);\r
994 fSinResabc->SetBinEdges(0,binLimCos);\r
995 fSinResabc->SetBinEdges(1,binLimCos);\r
996 fSinResabc->SetBinEdges(2,binLimCos);\r
997 fSinResabc->SetBinEdges(3,binLimC);\r
998 fSinResabc->Sumw2();\r
914042c2 999 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: sinresabc");\r
7b5936fc 1000 \r
1001 // Profile cosres centrality with 3 subevents\r
1002 fProfileCosResab = new TProfile("ProfileCosRes_a_b","ProfileCosRes_a_b",nBinsCMore,binLimCMore);\r
1003 fProfileCosResab->Sumw2();\r
1004 fProfileCosResac = new TProfile("ProfileCosRes_a_c","ProfileCosRes_a_c",nBinsCMore,binLimCMore);\r
1005 fProfileCosResac->Sumw2();\r
1006 fProfileCosResbc = new TProfile("ProfileCosRes_b_c","ProfileCosRes_b_c",nBinsCMore,binLimCMore);\r
1007 fProfileCosResbc->Sumw2();\r
914042c2 1008 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: profilecosresbc");\r
7b5936fc 1009 \r
1010 //\r
1011 const Int_t nDimff=2;\r
1012 Int_t nBinff[nDimff] = {nBinsCos, nBinsC};\r
1013 fSinRes = new THnSparseF("SinRes","SinRes",nDimff,nBinff);\r
1014 fSinRes->SetBinEdges(0,binLimCos);\r
1015 fSinRes->SetBinEdges(1,binLimC);\r
1016 fSinRes->Sumw2();\r
914042c2 1017 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: sinres");\r
7b5936fc 1018 \r
1019 // Profile cosres centrality\r
1020 fProfileCosRes = new TProfile("ProfileCosRes","ProfileCosRes",nBinsCMore,binLimCMore);\r
1021 fProfileCosRes->Sumw2();\r
914042c2 1022 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: profilecosres");\r
7b5936fc 1023 \r
1024 // Profile Maps cos phi\r
1025 fProfileCosPhiMaps = new TProfile2D("ProfileCosPhiMaps","ProfileCosPhiMaps",nBinsC,binLimC,nBinsPt,binLimPt);\r
1026 fProfileCosPhiMaps->Sumw2();\r
914042c2 1027 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: profilecosphimaps");\r
7b5936fc 1028\r
1029 }\r
1030 //\r
1031 // fMonitorTrackCuts\r
1032 //\r
1033\r
1034 if(fMonitorTrackCuts) {\r
1035 // Debugging tracking steps\r
1036 const Int_t nDimTrStep=2;\r
1037 Int_t nBinTrStep[nDimTrStep] = {nBinsPt,nBinsStep};\r
1038 fTrackingCuts = new THnSparseF("TrackingCuts","TrackingCuts",nDimTrStep,nBinTrStep);\r
1039 fTrackingCuts->SetBinEdges(0,binLimPt);\r
1040 fTrackingCuts->SetBinEdges(1,binLimStep);\r
1041 fTrackingCuts->Sumw2();\r
914042c2 1042 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: trackingcuts");\r
7b5936fc 1043 }\r
1044\r
1045 //\r
1046 // fMonitorContamination\r
1047 //\r
1048\r
1049 if(fMonitorContamination) { \r
1050 // Maps delta phi contamination\r
1051 const Int_t nDimgcont=4;\r
1052 Int_t nBingcont[nDimgcont] = {nBinsPhiLess,nBinsC,nBinsPt, nBinsTPCdEdx};\r
1053 fDeltaPhiMapsContamination = new THnSparseF("DeltaPhiMapsContamination","DeltaPhiMapsContamination",nDimgcont,nBingcont);\r
1054 fDeltaPhiMapsContamination->SetBinEdges(0,binLimPhiLess);\r
1055 fDeltaPhiMapsContamination->SetBinEdges(1,binLimC);\r
1056 fDeltaPhiMapsContamination->SetBinEdges(2,binLimPt);\r
1057 fDeltaPhiMapsContamination->SetBinEdges(3,binLimTPCdEdx);\r
1058 fDeltaPhiMapsContamination->Sumw2(); \r
914042c2 1059 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimapscontamination");\r
6b2521a4 1060\r
7b5936fc 1061 }\r
1062 //\r
1063 // fMonitorWithoutPID\r
1064 //\r
1065\r
1066 if(fMonitorWithoutPID) {\r
1067 //\r
1068 const Int_t nDimgb=3;\r
1069 Int_t nBingb[nDimgb] = {nBinsPhi,nBinsC,nBinsPt};\r
1070 \r
1071 fDeltaPhiMapsBeforePID = new THnSparseF("DeltaPhiMapsBeforePID","DeltaPhiMapsBeforePID",nDimgb,nBingb);\r
1072 fDeltaPhiMapsBeforePID->SetBinEdges(0,binLimPhi);\r
1073 fDeltaPhiMapsBeforePID->SetBinEdges(1,binLimC);\r
1074 fDeltaPhiMapsBeforePID->SetBinEdges(2,binLimPt);\r
1075 fDeltaPhiMapsBeforePID->Sumw2(); \r
914042c2 1076 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimapsbeforepid");\r
7b5936fc 1077 \r
1078 const Int_t nDimhb=3;\r
1079 Int_t nBinhb[nDimhb] = {nBinsCos,nBinsC,nBinsPt};\r
1080 \r
1081 fCosPhiMapsBeforePID = new THnSparseF("CosPhiMapsBeforePID","CosPhiMapsBeforePID",nDimhb,nBinhb);\r
1082 fCosPhiMapsBeforePID->SetBinEdges(0,binLimCos);\r
1083 fCosPhiMapsBeforePID->SetBinEdges(1,binLimC);\r
1084 fCosPhiMapsBeforePID->SetBinEdges(2,binLimPt);\r
1085 fCosPhiMapsBeforePID->Sumw2();\r
914042c2 1086 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosphimapsbeforepid");\r
7b5936fc 1087 }\r
1088 //\r
1089 // fMonitorPhotonic\r
1090 //\r
1091\r
1092 if(fMonitorPhotonic) {\r
2747660f 1093 \r
7b5936fc 1094 const Int_t nDimgbp=3;\r
1095 Int_t nBingbp[nDimgbp] = {nBinsPhi,nBinsC,nBinsPt};\r
1096 \r
1097 fDeltaPhiMapsTaggedPhotonic = new THnSparseF("DeltaPhiMapsTaggedPhotonic","DeltaPhiMapsTaggedPhotonic",nDimgbp,nBingbp);\r
1098 fDeltaPhiMapsTaggedPhotonic->SetBinEdges(0,binLimPhi);\r
1099 fDeltaPhiMapsTaggedPhotonic->SetBinEdges(1,binLimC);\r
1100 fDeltaPhiMapsTaggedPhotonic->SetBinEdges(2,binLimPt);\r
1101 fDeltaPhiMapsTaggedPhotonic->Sumw2(); \r
914042c2 1102 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimapstaggedphotonic");\r
7b5936fc 1103 \r
1104 fDeltaPhiMapsTaggedNonPhotonic = new THnSparseF("DeltaPhiMapsTaggedNonPhotonic","DeltaPhiMapsTaggedNonPhotonic",nDimgbp,nBingbp);\r
1105 fDeltaPhiMapsTaggedNonPhotonic->SetBinEdges(0,binLimPhi);\r
1106 fDeltaPhiMapsTaggedNonPhotonic->SetBinEdges(1,binLimC);\r
1107 fDeltaPhiMapsTaggedNonPhotonic->SetBinEdges(2,binLimPt);\r
1108 fDeltaPhiMapsTaggedNonPhotonic->Sumw2(); \r
914042c2 1109 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimapstaggednonphotonic");\r
7b5936fc 1110 \r
1111 fDeltaPhiMapsTaggedPhotonicLS = new THnSparseF("DeltaPhiMapsTaggedPhotonicLS","DeltaPhiMapsTaggedPhotonicLS",nDimgbp,nBingbp);\r
1112 fDeltaPhiMapsTaggedPhotonicLS->SetBinEdges(0,binLimPhi);\r
1113 fDeltaPhiMapsTaggedPhotonicLS->SetBinEdges(1,binLimC);\r
1114 fDeltaPhiMapsTaggedPhotonicLS->SetBinEdges(2,binLimPt);\r
1115 fDeltaPhiMapsTaggedPhotonicLS->Sumw2(); \r
914042c2 1116 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: deltaphimapstaggedphotonicls"); \r
90aa28e9 1117\r
2747660f 1118 /*\r
7b5936fc 1119 const Int_t nDimhbp=3;\r
1120 Int_t nBinhbp[nDimhbp] = {nBinsCos,nBinsC,nBinsPt};\r
1121 \r
1122 fCosPhiMapsTaggedPhotonic = new THnSparseF("CosPhiMapsTaggedPhotonic","CosPhiMapsTaggedPhotonic",nDimhbp,nBinhbp);\r
1123 fCosPhiMapsTaggedPhotonic->SetBinEdges(0,binLimCos);\r
1124 fCosPhiMapsTaggedPhotonic->SetBinEdges(1,binLimC);\r
1125 fCosPhiMapsTaggedPhotonic->SetBinEdges(2,binLimPt);\r
1126 fCosPhiMapsTaggedPhotonic->Sumw2();\r
914042c2 1127 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosphimapstaggedphotonic");\r
7b5936fc 1128 \r
1129 fCosPhiMapsTaggedNonPhotonic = new THnSparseF("CosPhiMapsTaggedNonPhotonic","CosPhiMapsTaggedNonPhotonic",nDimhbp,nBinhbp);\r
1130 fCosPhiMapsTaggedNonPhotonic->SetBinEdges(0,binLimCos);\r
1131 fCosPhiMapsTaggedNonPhotonic->SetBinEdges(1,binLimC);\r
1132 fCosPhiMapsTaggedNonPhotonic->SetBinEdges(2,binLimPt);\r
1133 fCosPhiMapsTaggedNonPhotonic->Sumw2();\r
914042c2 1134 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosphimapstaggednonphotonic");\r
7b5936fc 1135 \r
1136 fCosPhiMapsTaggedPhotonicLS = new THnSparseF("CosPhiMapsTaggedPhotonicLS","CosPhiMapsTaggedPhotonicLS",nDimhbp,nBinhbp);\r
1137 fCosPhiMapsTaggedPhotonicLS->SetBinEdges(0,binLimCos);\r
1138 fCosPhiMapsTaggedPhotonicLS->SetBinEdges(1,binLimC);\r
1139 fCosPhiMapsTaggedPhotonicLS->SetBinEdges(2,binLimPt);\r
1140 fCosPhiMapsTaggedPhotonicLS->Sumw2();\r
914042c2 1141 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: cosphimapstaggedphotonicls");\r
6733d981 1142 */\r
7b5936fc 1143 const Int_t nDimMCSource=3;\r
1144 Int_t nBinMCSource[nDimMCSource] = {nBinsC,nBinsPt,nBinsSource};\r
1145 fMCSourceDeltaPhiMaps = new THnSparseF("MCSourceDeltaPhiMaps","MCSourceDeltaPhiMaps",nDimMCSource,nBinMCSource);\r
1146 fMCSourceDeltaPhiMaps->SetBinEdges(0,binLimC);\r
1147 fMCSourceDeltaPhiMaps->SetBinEdges(1,binLimPt);\r
1148 fMCSourceDeltaPhiMaps->SetBinEdges(2,binLimSource);\r
1149 fMCSourceDeltaPhiMaps->Sumw2();\r
914042c2 1150 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: mcsourcedeltaphimaps");\r
7b5936fc 1151 \r
1152 // Maps invmass opposite\r
1153 const Int_t nDimOppSign=5;\r
1154 Int_t nBinOppSign[nDimOppSign] = {nBinsPhi,nBinsC,nBinsPt,nBinsInvMass,nBinsSource};\r
1155 fOppSignDeltaPhiMaps = new THnSparseF("OppSignDeltaPhiMaps","OppSignDeltaPhiMaps",nDimOppSign,nBinOppSign);\r
1156 fOppSignDeltaPhiMaps->SetBinEdges(0,binLimPhi);\r
1157 fOppSignDeltaPhiMaps->SetBinEdges(1,binLimC);\r
1158 fOppSignDeltaPhiMaps->SetBinEdges(2,binLimPt);\r
1159 fOppSignDeltaPhiMaps->SetBinEdges(3,binLimInvMass);\r
1160 fOppSignDeltaPhiMaps->SetBinEdges(4,binLimSource);\r
1161 fOppSignDeltaPhiMaps->Sumw2();\r
914042c2 1162 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: oppsigndeltaphimaps");\r
7b5936fc 1163 \r
1164 // Maps invmass same sign\r
1165 const Int_t nDimSameSign=5;\r
1166 Int_t nBinSameSign[nDimSameSign] = {nBinsPhi,nBinsC,nBinsPt,nBinsInvMass,nBinsSource};\r
1167 fSameSignDeltaPhiMaps = new THnSparseF("SameSignDeltaPhiMaps","SameSignDeltaPhiMaps",nDimSameSign,nBinSameSign);\r
1168 fSameSignDeltaPhiMaps->SetBinEdges(0,binLimPhi);\r
1169 fSameSignDeltaPhiMaps->SetBinEdges(1,binLimC);\r
1170 fSameSignDeltaPhiMaps->SetBinEdges(2,binLimPt);\r
1171 fSameSignDeltaPhiMaps->SetBinEdges(3,binLimInvMass);\r
1172 fSameSignDeltaPhiMaps->SetBinEdges(4,binLimSource);\r
1173 fSameSignDeltaPhiMaps->Sumw2();\r
914042c2 1174 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: samesigndeltaphimaps");\r
7b5936fc 1175 \r
1176 // Maps angle same sign\r
1177 const Int_t nDimAngleSameSign=3;\r
1178 Int_t nBinAngleSameSign[nDimAngleSameSign] = {nBinsAngle,nBinsC,nBinsSource};\r
1179 fSameSignAngle = new THnSparseF("SameSignAngleMaps","SameSignAngleMaps",nDimAngleSameSign,nBinAngleSameSign);\r
1180 fSameSignAngle->SetBinEdges(0,binLimAngle);\r
1181 fSameSignAngle->SetBinEdges(1,binLimC);\r
1182 fSameSignAngle->SetBinEdges(2,binLimSource);\r
1183 fSameSignAngle->Sumw2();\r
914042c2 1184 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: samesignangle");\r
7b5936fc 1185 \r
1186 // Maps angle opp sign\r
1187 const Int_t nDimAngleOppSign=3;\r
1188 Int_t nBinAngleOppSign[nDimAngleOppSign] = {nBinsAngle,nBinsC,nBinsSource};\r
1189 fOppSignAngle = new THnSparseF("OppSignAngleMaps","OppSignAngleMaps",nDimAngleOppSign,nBinAngleOppSign);\r
1190 fOppSignAngle->SetBinEdges(0,binLimAngle);\r
1191 fOppSignAngle->SetBinEdges(1,binLimC);\r
1192 fOppSignAngle->SetBinEdges(2,binLimSource);\r
1193 fOppSignAngle->Sumw2();\r
914042c2 1194 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: oppsignangle");\r
90aa28e9 1195\r
7b5936fc 1196 }\r
e17c1f86 1197\r
8c1c76e9 1198 //**************************\r
1199 // Add to the list\r
1200 //******************************\r
1201\r
2747660f 1202 fListHist->Add(fHistEV);\r
a70c9e97 1203 fListHist->Add(fHistPileUp);\r
8c1c76e9 1204 fListHist->Add(fEventPlane);\r
6733d981 1205 fListHist->Add(fFractionContamination);\r
8c1c76e9 1206 fListHist->Add(fCosRes);\r
e17c1f86 1207 fListHist->Add(fCosResabc);\r
8c1c76e9 1208 fListHist->Add(fCosPhiMaps);\r
7b5936fc 1209 fListHist->Add(fDeltaPhiMaps);\r
1210 fListHist->Add(fPIDqa->MakeList("HFEpidQA"));\r
6b2521a4 1211 fListHist->Add(fContaminationv2);\r
914042c2 1212 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add default");\r
7b5936fc 1213\r
1214 if(fMonitorEventPlane) {\r
1215 fListHist->Add(fProfileCosRes);\r
1216 fListHist->Add(fProfileCosResab);\r
1217 fListHist->Add(fProfileCosResac);\r
1218 fListHist->Add(fProfileCosResbc);\r
1219 fListHist->Add(fCosSin2phiep);\r
1220 fListHist->Add(fCos2phie);\r
1221 fListHist->Add(fSin2phie);\r
1222 fListHist->Add(fCos2phiep);\r
1223 fListHist->Add(fSin2phiep);\r
1224 fListHist->Add(fSin2phiephiep);\r
1225 fListHist->Add(fSinRes);\r
1226 fListHist->Add(fSinResabc);\r
1227 fListHist->Add(fProfileCosPhiMaps);\r
1228 }\r
914042c2 1229 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add monitor");\r
7b5936fc 1230\r
1231 if(fMonitorTrackCuts) fListHist->Add(fTrackingCuts);\r
1232\r
914042c2 1233 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add monitortrackcuts");\r
90aa28e9 1234\r
6b2521a4 1235 if(fMonitorContamination) {\r
1236 fListHist->Add(fDeltaPhiMapsContamination);\r
1237 }\r
7b5936fc 1238 \r
914042c2 1239 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add deltaphimapscontamination");\r
90aa28e9 1240\r
7b5936fc 1241 if(fMonitorWithoutPID) {\r
1242 fListHist->Add(fDeltaPhiMapsBeforePID);\r
1243 fListHist->Add(fCosPhiMapsBeforePID);\r
1244 }\r
1245\r
914042c2 1246 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add without pid");\r
90aa28e9 1247\r
7b5936fc 1248 if(fMonitorPhotonic) {\r
1249 fListHist->Add(fPIDBackgroundqa->MakeList("HFEpidBackgroundQA"));\r
2747660f 1250 fListHist->Add(fDeltaPhiMapsTaggedPhotonic);\r
6733d981 1251 //fListHist->Add(fCosPhiMapsTaggedPhotonic);\r
2747660f 1252 fListHist->Add(fDeltaPhiMapsTaggedNonPhotonic);\r
6733d981 1253 //fListHist->Add(fCosPhiMapsTaggedNonPhotonic);\r
2747660f 1254 fListHist->Add(fDeltaPhiMapsTaggedPhotonicLS);\r
6733d981 1255 //fListHist->Add(fCosPhiMapsTaggedPhotonicLS);\r
0e30407a 1256 fListHist->Add(fMCSourceDeltaPhiMaps);\r
1257 fListHist->Add(fOppSignDeltaPhiMaps);\r
1258 fListHist->Add(fSameSignDeltaPhiMaps);\r
1259 fListHist->Add(fSameSignAngle);\r
1260 fListHist->Add(fOppSignAngle);\r
2747660f 1261 fListHist->Add(fBackgroundSubtraction->GetListOutput());\r
7b5936fc 1262 }\r
0e30407a 1263\r
914042c2 1264 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add photonic");\r
90aa28e9 1265\r
7b5936fc 1266 if(fHFEVZEROEventPlane && fMonitorEventPlane) fListHist->Add(fHFEVZEROEventPlane->GetOutputList());\r
8c1c76e9 1267 \r
914042c2 1268 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: add event plane");\r
8c1c76e9 1269\r
1270 PostData(1, fListHist);\r
7f695a7b 1271 //for(Int_t bincless = 0; bincless < fNbBinsCentralityQCumulant; bincless++) {\r
1272 // PostData(bincless+2,fflowEvent); \r
1273 //}\r
8c1c76e9 1274\r
914042c2 1275 AliDebug(2,"AliAnalysisTaskFlowTPCTOFEPSP: post");\r
90aa28e9 1276\r
8c1c76e9 1277\r
1278}\r
1279 \r
1280//________________________________________________________________________\r
914042c2 1281void AliAnalysisTaskFlowTPCTOFEPSP::UserExec(Option_t */*option*/)\r
8c1c76e9 1282{\r
1283 //\r
1284 // Loop over event\r
1285 //\r
1286 \r
1287 Double_t massElectron = 0.000511;\r
1288 Double_t mcReactionPlane = 0.0;\r
1289\r
1290 Float_t cntr = 0.0;\r
1291 Double_t binct = 11.5;\r
e17c1f86 1292 Double_t binctMore = 20.5;\r
1293 Double_t binctLess = -0.5;\r
8c1c76e9 1294 Float_t binctt = -1.0;\r
1295 \r
e17c1f86 1296 Double_t valuecossinephiep[3];\r
6733d981 1297 Double_t valuensparsea[4];\r
e17c1f86 1298 Double_t valuensparseabis[5];\r
8c1c76e9 1299 Double_t valuensparsee[4];\r
1300 Double_t valuensparsef[2];\r
a8ef1999 1301 Double_t valuensparsefsin[2];\r
e17c1f86 1302 Double_t valuensparsefbis[4];\r
a8ef1999 1303 Double_t valuensparsefbissin[4];\r
11ff28c5 1304 Double_t valuensparseg[5];\r
1305 Double_t valuensparseh[5];\r
e17c1f86 1306 Double_t valuensparsehprofile[3];\r
0e30407a 1307 Double_t valuensparseMCSourceDeltaPhiMaps[3];\r
1308 Double_t valuetrackingcuts[2];\r
5cd679b7 1309 Double_t valuedeltaphicontamination[4];\r
6733d981 1310 Double_t valuefractioncont[2];\r
0e30407a 1311 \r
8c1c76e9 1312 AliMCEvent *mcEvent = MCEvent();\r
1313 AliMCParticle *mctrack = NULL;\r
2747660f 1314\r
1315 // MC info\r
1316 Bool_t mcthere = kTRUE;\r
1317 if(fAODAnalysis) {\r
1318 AliAODEvent *aodE = dynamic_cast<AliAODEvent *>(fInputEvent);\r
b22c4fc4 1319 if(!aodE){\r
2747660f 1320 // printf("testd\n");\r
1321 AliError("No AOD Event");\r
1322 return;\r
1323 }\r
1324 fAODMCHeader = dynamic_cast<AliAODMCHeader *>(fInputEvent->FindListObject(AliAODMCHeader::StdBranchName()));\r
1325 if(!fAODMCHeader){ \r
1326 mcthere = kFALSE;\r
1327 }\r
1328 fAODArrayMCInfo = dynamic_cast<TClonesArray *>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));\r
1329 if(!fAODArrayMCInfo){ \r
1330 mcthere = kFALSE;\r
1331 }\r
1332 else {\r
1333 fHFECuts->SetMCEvent(aodE);\r
1334 if(fMonitorPhotonic) fBackgroundSubtraction->SetAODArrayMCInfo(fAODArrayMCInfo);\r
1335 }\r
1336 }\r
1337 else {\r
1338 AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());\r
1339 if(!mcH) mcthere = kFALSE;\r
1340 else {\r
1341 if(fMonitorPhotonic) fBackgroundSubtraction->SetMCEvent(fMCEvent);\r
1342 }\r
1343 }\r
1344\r
0e30407a 1345 \r
8c1c76e9 1346 /////////////////\r
1347 // centrality\r
1348 /////////////////\r
1349 \r
11ff28c5 1350 //AliESDEvent *esd = dynamic_cast<AliESDEvent*>(InputEvent());\r
1351 //if(!esd) return;\r
1352 AliCentrality *centrality = fInputEvent->GetCentrality();\r
7f695a7b 1353 //AliDebug(2,"Got the centrality");\r
8c1c76e9 1354 if(!centrality) return;\r
1355 cntr = centrality->GetCentralityPercentile("V0M");\r
1356 if((0.0< cntr) && (cntr<5.0)) binct = 0.5;\r
1357 if((5.0< cntr) && (cntr<10.0)) binct = 1.5;\r
1358 if((10.0< cntr) && (cntr<20.0)) binct = 2.5;\r
1359 if((20.0< cntr) && (cntr<30.0)) binct = 3.5;\r
1360 if((30.0< cntr) && (cntr<40.0)) binct = 4.5;\r
1361 if((40.0< cntr) && (cntr<50.0)) binct = 5.5;\r
1362 if((50.0< cntr) && (cntr<60.0)) binct = 6.5;\r
1363 if((60.0< cntr) && (cntr<70.0)) binct = 7.5;\r
1364 if((70.0< cntr) && (cntr<80.0)) binct = 8.5;\r
1365 if((80.0< cntr) && (cntr<90.0)) binct = 9.5;\r
1366 if((90.0< cntr) && (cntr<100.0)) binct = 10.5;\r
1367 \r
1368 if((0.< cntr) && (cntr < 20.)) binctt = 0.5;\r
1369 if((20.< cntr) && (cntr < 40.)) binctt = 1.5;\r
1370 if((40.< cntr) && (cntr < 80.)) binctt = 2.5;\r
1371\r
e17c1f86 1372 if((0.0< cntr) && (cntr<5.0)) binctMore = 0.5;\r
1373 if((5.0< cntr) && (cntr<10.0)) binctMore = 1.5;\r
1374 if((10.0< cntr) && (cntr<15.0)) binctMore = 2.5;\r
1375 if((15.0< cntr) && (cntr<20.0)) binctMore = 3.5;\r
1376 if((20.0< cntr) && (cntr<25.0)) binctMore = 4.5;\r
1377 if((25.0< cntr) && (cntr<30.0)) binctMore = 5.5;\r
1378 if((30.0< cntr) && (cntr<35.0)) binctMore = 6.5;\r
1379 if((35.0< cntr) && (cntr<40.0)) binctMore = 7.5;\r
1380 if((40.0< cntr) && (cntr<45.0)) binctMore = 8.5;\r
1381 if((45.0< cntr) && (cntr<50.0)) binctMore = 9.5;\r
1382 if((50.0< cntr) && (cntr<55.0)) binctMore = 10.5;\r
1383 if((55.0< cntr) && (cntr<60.0)) binctMore = 11.5;\r
1384 if((60.0< cntr) && (cntr<65.0)) binctMore = 12.5;\r
1385 if((65.0< cntr) && (cntr<70.0)) binctMore = 13.5;\r
1386 if((70.0< cntr) && (cntr<75.0)) binctMore = 14.5;\r
1387 if((75.0< cntr) && (cntr<80.0)) binctMore = 15.5;\r
1388 if((80.0< cntr) && (cntr<85.0)) binctMore = 16.5;\r
1389 if((85.0< cntr) && (cntr<90.0)) binctMore = 17.5;\r
1390 if((90.0< cntr) && (cntr<95.0)) binctMore = 18.5;\r
1391 if((95.0< cntr) && (cntr<100.0)) binctMore = 19.5;\r
1392\r
1393 binctLess = cntr;\r
a8ef1999 1394 \r
e17c1f86 1395 \r
8c1c76e9 1396 if(binct > 11.0) return;\r
1397 \r
1398 // centrality\r
6733d981 1399 valuensparsea[3] = binct; \r
e17c1f86 1400 valuensparseabis[1] = binct; \r
8c1c76e9 1401 valuensparsee[1] = binct; \r
e17c1f86 1402 valuensparsef[1] = binctMore; \r
a8ef1999 1403 valuensparsefsin[1] = binct; \r
e17c1f86 1404 valuensparsefbis[3] = binctMore; \r
a8ef1999 1405 valuensparsefbissin[3] = binct; \r
8c1c76e9 1406 valuensparseg[1] = binct;\r
1407 valuensparseh[1] = binct; \r
6733d981 1408 valuefractioncont[1] = binct;\r
11ff28c5 1409 valuensparsehprofile[1] = binct; \r
e17c1f86 1410 valuecossinephiep[2] = binctMore;\r
0e30407a 1411 valuensparseMCSourceDeltaPhiMaps[0] = binct;\r
5cd679b7 1412 valuedeltaphicontamination[1] = binct;\r
0e30407a 1413 \r
8c1c76e9 1414 //////////////////////\r
1415 // run number\r
1416 //////////////////////\r
1417\r
11ff28c5 1418 Int_t runnumber = fInputEvent->GetRunNumber();\r
7f695a7b 1419 AliDebug(2,Form("Run number %d",runnumber));\r
8c1c76e9 1420 \r
1421 if(!fPID->IsInitialized()){\r
1422 // Initialize PID with the given run number\r
1423 fPID->InitializePID(runnumber);\r
1424 }\r
5cd679b7 1425 if(!fPIDTOFOnly->IsInitialized()){\r
1426 // Initialize PID with the given run number\r
1427 fPIDTOFOnly->InitializePID(runnumber);\r
1428 }\r
8c1c76e9 1429\r
5cd679b7 1430 //\r
0e30407a 1431 if(!fPIDBackground->IsInitialized()){\r
1432 // Initialize PID with the given run number\r
1433 fPIDBackground->InitializePID(runnumber);\r
1434 }\r
1435\r
6400afdd 1436 fHFECuts->SetRecEvent(fInputEvent);\r
1437 if(mcEvent) fHFECuts->SetMCEvent(mcEvent);\r
1438\r
8c1c76e9 1439\r
1440 //////////\r
1441 // PID\r
1442 //////////\r
1443 \r
1444 AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse();\r
1445 if(!pidResponse){\r
7f695a7b 1446 AliDebug(2,"No PID response set");\r
8c1c76e9 1447 return;\r
1448 }\r
1449 fPID->SetPIDResponse(pidResponse);\r
5cd679b7 1450 fPIDTOFOnly->SetPIDResponse(pidResponse);\r
0e30407a 1451 fPIDBackground->SetPIDResponse(pidResponse);\r
2747660f 1452 if(fMonitorPhotonic) fBackgroundSubtraction->InitRun(fInputEvent,pidResponse);\r
8c1c76e9 1453\r
2747660f 1454 fHistEV->Fill(binctt,0.0);\r
8c1c76e9 1455\r
1456 //////////////////\r
1457 // Event cut\r
1458 //////////////////\r
11ff28c5 1459 if(!fHFECuts->CheckEventCuts("fEvRecCuts", fInputEvent)) {\r
3112b3a5 1460 AliDebug(2,"Does not pass the event cut");\r
8c1c76e9 1461 PostData(1, fListHist);\r
1462 return;\r
1463 }\r
1464\r
2747660f 1465 fHistEV->Fill(binctt,1.0);\r
8c1c76e9 1466\r
a70c9e97 1467\r
1468 ///////////////////////////////////////////////////////////\r
1469 // PileUpCut\r
1470 ///////////////////////////////////////////////////////////\r
d87a9d29 1471\r
1472 Float_t multTPC(0.); // tpc mult estimate\r
1473 Float_t multGlob(0.); // global multiplicity\r
1474 const Int_t nGoodTracks = fInputEvent->GetNumberOfTracks();\r
1475 for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) { // fill tpc mult\r
1476 AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*>(fInputEvent->GetTrack(iTracks));\r
1477 if (!trackAOD) continue;\r
1478 if (!(trackAOD->TestFilterBit(1))) continue;\r
1479 if ((trackAOD->Pt() < .2) || (trackAOD->Pt() > 5.0) || (TMath::Abs(trackAOD->Eta()) > .8) || (trackAOD->GetTPCNcls() < 70) || (trackAOD->GetDetPid()->GetTPCsignal() < 10.0) || (trackAOD->Chi2perNDF() < 0.2)) continue;\r
1480 multTPC++;\r
a70c9e97 1481 }\r
d87a9d29 1482 for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) { // fill global mult\r
1483 AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*>(fInputEvent->GetTrack(iTracks));\r
1484 if (!trackAOD) continue;\r
1485 if (!(trackAOD->TestFilterBit(16))) continue;\r
1486 if ((trackAOD->Pt() < .2) || (trackAOD->Pt() > 5.0) || (TMath::Abs(trackAOD->Eta()) > .8) || (trackAOD->GetTPCNcls() < 70) || (trackAOD->GetDetPid()->GetTPCsignal() < 10.0) || (trackAOD->Chi2perNDF() < 0.1)) continue;\r
1487 Double_t b[2] = {-99., -99.};\r
1488 Double_t bCov[3] = {-99., -99., -99.};\r
1489 if (!(trackAOD->PropagateToDCA(fInputEvent->GetPrimaryVertex(), fInputEvent->GetMagneticField(), 100., b, bCov))) continue;\r
1490 if ((TMath::Abs(b[0]) > 0.3) || (TMath::Abs(b[1]) > 0.3)) continue;\r
1491 multGlob++;\r
1492 } //track loop\r
1493\r
1494 Double_t pileup[4];\r
1495 pileup[0]=fInputEvent->GetCentrality()->GetCentralityPercentile("V0M");\r
1496 pileup[1]=fInputEvent->GetCentrality()->GetCentralityPercentile("TRK");\r
1497 pileup[2]=multTPC;\r
1498 pileup[3]=multGlob;\r
1499 fHistPileUp->Fill(pileup);\r
1500\r
1501 if(fPileUpCut){\r
1502 if (TMath::Abs(pileup[0]-pileup[1]) > 5) {\r
1503 AliDebug(2,"Does not pass the centrality correlation cut");\r
1504 return;\r
1505 }\r
1506 if(multTPC < (-36.81+1.48*multGlob) && multTPC > (63.03+1.78*multGlob)){\r
1507 AliDebug(2,"Does not pass the multiplicity correlation cut");\r
3112b3a5 1508 return;\r
1509 }\r
1510 }\r
d87a9d29 1511 \r
1512 // AliVVZERO* vzeroData=fInputEvent->GetVZEROData();\r
1513 // Double_t mult[3],multV0A(0),multV0C(0);\r
1514 // for(Int_t i=0; i<32; ++i) {\r
1515 // multV0A += vzeroData->GetMultiplicityV0A(i);\r
1516 // multV0C += vzeroData->GetMultiplicityV0C(i);\r
1517 // }\r
1518\r
1519 // int ntrk=0;\r
1520 // for(Int_t k = 0; k < fInputEvent->GetNumberOfTracks(); k++){\r
1521 // AliVTrack *track = (AliVTrack *) fInputEvent->GetTrack(k);\r
1522 // if(!track) continue;\r
1523 // if(!(track->GetStatus()&AliVTrack::kITSrefit)) continue;\r
1524 // if(!(track->GetStatus()&AliVTrack::kTPCrefit)) continue;\r
1525 // ntrk++;\r
1526 // }\r
1527 \r
1528 // mult[0]=fInputEvent->GetNumberOfTracks();\r
1529 // mult[1]=multV0A+multV0C;\r
1530 // mult[2]=binctMore;\r
1531 // fHistPileUp->Fill(mult);\r
1532\r
1533 // if(fUpperPileUpCut&&fLowerPileUpCut){\r
1534 // if((mult[0]<fLowerPileUpCut->Eval(mult[1])) || \r
1535 // (mult[0]>fUpperPileUpCut->Eval(mult[1]))){\r
1536 // AliDebug(2,"Does not pass the pileup cut");\r
1537 // PostData(1, fListHist);\r
1538 // return;\r
1539 // }\r
1540 // }\r
a70c9e97 1541\r
8c1c76e9 1542 //////////////////////////////////// \r
e17c1f86 1543 // First method event plane\r
8c1c76e9 1544 ////////////////////////////////////\r
1545\r
11ff28c5 1546 AliEventplane* vEPa = fInputEvent->GetEventplane();\r
e17c1f86 1547 Float_t eventPlanea = 0.0;\r
1548 Float_t eventPlaneTPC = 0.0;\r
1549 Float_t eventPlaneV0A = 0.0;\r
1550 Float_t eventPlaneV0C = 0.0;\r
1551 Float_t eventPlaneV0 = 0.0;\r
959ea9d8 1552 TVector2 *qTPC = 0x0;\r
e17c1f86 1553 TVector2 *qsub1a = 0x0;\r
1554 TVector2 *qsub2a = 0x0;\r
959ea9d8 1555 TVector2 qV0A,qV0C,qV0,*qAna;\r
1556 \r
e17c1f86 1557 // V0\r
a8ef1999 1558\r
11ff28c5 1559 if(fHFEVZEROEventPlane && (!fAODAnalysis)){\r
1560\r
1561 //AliESDEvent *esd = dynamic_cast<AliESDEvent*>(InputEvent());\r
1562 //if(!esd) return;\r
a8ef1999 1563 \r
11ff28c5 1564 fHFEVZEROEventPlane->ProcessEvent(fInputEvent);\r
a8ef1999 1565 \r
1566 if(TMath::Abs(fHFEVZEROEventPlane->GetEventPlaneV0A()+100) < 0.0000001) eventPlaneV0A = -100.0;\r
1567 else {\r
1568 eventPlaneV0A = TVector2::Phi_0_2pi(fHFEVZEROEventPlane->GetEventPlaneV0A());\r
1569 if(eventPlaneV0A > TMath::Pi()) eventPlaneV0A = eventPlaneV0A - TMath::Pi();\r
1570 }\r
1571 \r
1572 if(TMath::Abs(fHFEVZEROEventPlane->GetEventPlaneV0C()+100) < 0.0000001) eventPlaneV0C = -100.0;\r
1573 else {\r
1574 eventPlaneV0C = TVector2::Phi_0_2pi(fHFEVZEROEventPlane->GetEventPlaneV0C());\r
1575 if(eventPlaneV0C > TMath::Pi()) eventPlaneV0C = eventPlaneV0C - TMath::Pi();\r
1576 }\r
1577\r
1578 if(TMath::Abs(fHFEVZEROEventPlane->GetEventPlaneV0()+100) < 0.0000001) eventPlaneV0 = -100.0;\r
1579 else {\r
1580 eventPlaneV0 = TVector2::Phi_0_2pi(fHFEVZEROEventPlane->GetEventPlaneV0());\r
1581 if(eventPlaneV0 > TMath::Pi()) eventPlaneV0 = eventPlaneV0 - TMath::Pi();\r
1582 }\r
1583 \r
1584 }\r
1585 else {\r
1586 \r
959ea9d8 1587 Double_t qVx, qVy; //TR: info\r
d87a9d29 1588 eventPlaneV0 = TVector2::Phi_0_2pi(vEPa->CalculateVZEROEventPlane(fInputEvent,10,2,qVx,qVy));\r
a8ef1999 1589 if(eventPlaneV0 > TMath::Pi()) eventPlaneV0 = eventPlaneV0 - TMath::Pi();\r
959ea9d8 1590 qV0.Set(qVx,qVy);\r
1591 eventPlaneV0A = TVector2::Phi_0_2pi(vEPa->CalculateVZEROEventPlane(fInputEvent,8,2,qVx,qVy));\r
a8ef1999 1592 if(eventPlaneV0A > TMath::Pi()) eventPlaneV0A = eventPlaneV0A - TMath::Pi();\r
959ea9d8 1593 qV0A.Set(qVx,qVy);\r
1594 eventPlaneV0C = TVector2::Phi_0_2pi(vEPa->CalculateVZEROEventPlane(fInputEvent,9,2,qVx,qVy));\r
a8ef1999 1595 if(eventPlaneV0C > TMath::Pi()) eventPlaneV0C = eventPlaneV0C - TMath::Pi();\r
959ea9d8 1596 qV0C.Set(qVx,qVy);\r
a70c9e97 1597 \r
1598 if(eventPlaneV0<-900) return;\r
1599 if(eventPlaneV0A<-900) return;\r
1600 if(eventPlaneV0C<-900) return;\r
1601\r
1602 eventPlaneV0=TVector2::Phi_0_2pi(eventPlaneV0);\r
d87a9d29 1603 eventPlaneV0A=TVector2::Phi_0_2pi(eventPlaneV0A);\r
1604 eventPlaneV0C=TVector2::Phi_0_2pi(eventPlaneV0C);\r
a8ef1999 1605 }\r
1606\r
a70c9e97 1607\r
e17c1f86 1608 // TPC\r
1609\r
959ea9d8 1610 qTPC = vEPa->GetQVector(); \r
8c1c76e9 1611 Double_t qx = -1.0;\r
1612 Double_t qy = -1.0;\r
959ea9d8 1613 if(qTPC) {\r
1614 qx = qTPC->X();\r
1615 qy = qTPC->Y();\r
8c1c76e9 1616 } \r
1617 TVector2 qVectorfortrack;\r
1618 qVectorfortrack.Set(qx,qy);\r
e17c1f86 1619 eventPlaneTPC = TVector2::Phi_0_2pi(qVectorfortrack.Phi())/2.; \r
1620\r
1621 // Choose the one used for v2\r
1622\r
959ea9d8 1623 if(fVZEROEventPlane){ //TR: info\r
1624 eventPlanea = eventPlaneV0;\r
1625 qAna = &qV0;\r
1626 }\r
1627 if(fVZEROEventPlaneA){\r
1628 eventPlanea = eventPlaneV0A;\r
1629 qAna = &qV0A;\r
1630 }\r
1631 if(fVZEROEventPlaneC){\r
1632 eventPlanea = eventPlaneV0C;\r
1633 qAna = &qV0C;\r
1634 }\r
1635 if(!fVZEROEventPlane){\r
1636 eventPlanea = eventPlaneTPC;\r
1637 qAna = &qV0C;\r
1638 }\r
e17c1f86 1639\r
1640 valuecossinephiep[0] = TMath::Cos(2*eventPlanea);\r
1641 valuecossinephiep[1] = TMath::Sin(2*eventPlanea);\r
1642\r
8c1c76e9 1643 Float_t eventPlanesub1a = -100.0;\r
1644 Float_t eventPlanesub2a = -100.0;\r
e17c1f86 1645 Double_t diffsub1sub2a = -100.0;\r
a8ef1999 1646 Double_t diffsub1sub2asin = -100.0;\r
e17c1f86 1647 Double_t diffsubasubb = -100.0;\r
1648 Double_t diffsubasubc = -100.0;\r
1649 Double_t diffsubbsubc = -100.0;\r
a8ef1999 1650 Double_t diffsubasubbsin = -100.0;\r
1651 Double_t diffsubasubcsin = -100.0;\r
1652 Double_t diffsubbsubcsin = -100.0;\r
e17c1f86 1653\r
6733d981 1654 // two sub event TPC\r
11ff28c5 1655 qsub1a = vEPa->GetQsub1();\r
1656 qsub2a = vEPa->GetQsub2();\r
a70c9e97 1657\r
1658 /////////////////////////////////////////////////////////\r
1659 // Cut for event with event plane reconstructed by all\r
1660 ////////////////////////////////////////////////////////\r
1661 \r
1662 if((!qTPC) || (!qsub1a) || (!qsub2a)) {\r
1663 AliDebug(2,"No event plane");\r
1664 return;\r
a8ef1999 1665 }\r
6733d981 1666\r
a70c9e97 1667 eventPlanesub1a = TVector2::Phi_0_2pi(qsub1a->Phi())/2.;\r
1668 eventPlanesub2a = TVector2::Phi_0_2pi(qsub2a->Phi())/2.;\r
1669 diffsub1sub2a = TMath::Cos(2.*TVector2::Phi_0_2pi(qsub1a->Phi()/2.- qsub2a->Phi()/2.));\r
1670 diffsub1sub2asin = TMath::Sin(2.*TVector2::Phi_0_2pi(qsub1a->Phi()/2.- qsub2a->Phi()/2.));\r
1671\r
1672\r
959ea9d8 1673 // if ( !fDebugStreamer ) {\r
1674 // //debug stream\r
1675 // TDirectory *backup = gDirectory;\r
a70c9e97 1676 // fDebugStreamer = new TTreeSRedirector("TaskFlowTPCTOFEPSPdebug.root");\r
959ea9d8 1677 // if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer\r
1678 // } \r
1679\r
1680 // {\r
1681\r
1682 // double v0nrom = TMath::Sqrt(qV0.X()*qV0.X()+qV0.Y()*qV0.Y());\r
1683 // double v0Anrom = TMath::Sqrt(qV0A.X()*qV0A.X()+qV0A.Y()*qV0A.Y());\r
1684 // double v0Cnrom = TMath::Sqrt(qV0C.X()*qV0C.X()+qV0C.Y()*qV0C.Y());\r
1685 // double sub1nrom = TMath::Sqrt(qsub1a->X()*qsub1a->X()+qsub1a->Y()*qsub1a->Y());\r
1686 // double sub2nrom = TMath::Sqrt(qsub2a->X()*qsub2a->X()+qsub2a->Y()*qsub2a->Y());\r
1687\r
1688 // (* fDebugStreamer) << "UserExec" <<\r
1689 // "binct="<<binct<<\r
1690 // "qV0="<<v0nrom<<\r
1691 // "qV0A="<<v0Anrom<<\r
1692 // "qV0C="<<v0Cnrom<<\r
1693 // "qsub1a="<<sub1nrom<<\r
1694 // "qsub2a="<<sub2nrom<<\r
1695 // "\n";\r
1696 // }\r
1697\r
6733d981 1698 // three sub events in case of VZEROA and VZEROC\r
959ea9d8 1699 if(!fSP){\r
1700 diffsubasubb = TMath::Cos(2.*(eventPlaneV0A - eventPlaneV0C)); //TR: \r
1701 diffsubasubc = TMath::Cos(2.*(eventPlaneV0A - eventPlaneTPC)); //TR: \r
1702 diffsubbsubc = TMath::Cos(2.*(eventPlaneV0C - eventPlaneTPC)); //TR: \r
1703 }\r
1704 else{\r
1705 if(fVZEROEventPlaneA){\r
1706 diffsubasubb = qV0A.X()*qV0C.X()+qV0A.Y()*qV0C.Y();\r
1707 diffsubasubc = qV0A.X()*qTPC->X()+qV0A.Y()*qTPC->Y();\r
1708 diffsubbsubc = qV0C.X()*qTPC->X()+qV0C.Y()*qTPC->Y();\r
1709 }\r
1710 else if(fVZEROEventPlaneC){\r
1711 diffsubasubb = qV0C.X()*qV0A.X()+qV0C.Y()*qV0A.Y();\r
1712 diffsubasubc = qV0C.X()*qTPC->X()+qV0C.Y()*qTPC->Y();\r
1713 diffsubbsubc = qV0A.X()*qTPC->X()+qV0A.Y()*qTPC->Y();\r
1714 }\r
1715 }\r
6733d981 1716\r
1717 diffsubasubbsin = TMath::Sin(2.*(eventPlaneV0A - eventPlaneV0C));\r
1718 diffsubasubcsin = TMath::Sin(2.*(eventPlaneV0A - eventPlaneTPC));\r
1719 diffsubbsubcsin = TMath::Sin(2.*(eventPlaneV0C - eventPlaneTPC));\r
1720 // three sub events in case of VZERO all\r
1721 if(fVZEROEventPlane && (!fVZEROEventPlaneA) && (!fVZEROEventPlaneC)) {\r
959ea9d8 1722 if(!fSP){\r
1723 diffsubasubb = TMath::Cos(2.*(eventPlaneV0 - eventPlanesub1a)); //TR: \r
1724 diffsubasubc = TMath::Cos(2.*(eventPlaneV0 - eventPlanesub2a)); //TR: \r
1725 diffsubbsubc = TMath::Cos(2.*(eventPlanesub1a - eventPlanesub2a)); //TR: \r
1726 }\r
1727 else{\r
1728 diffsubasubb = qV0.X()*qsub1a->X()+qV0.Y()*qsub1a->Y(); \r
1729 diffsubasubc = qV0.X()*qsub2a->X()+qV0.Y()*qsub2a->Y(); \r
1730 diffsubbsubc = qsub1a->X()*qsub2a->X()+qsub1a->Y()*qsub2a->Y();\r
1731 }\r
6733d981 1732 \r
1733 diffsubasubbsin = TMath::Sin(2.*(eventPlaneV0 - eventPlanesub1a));\r
1734 diffsubasubcsin = TMath::Sin(2.*(eventPlaneV0 - eventPlanesub2a));\r
1735 diffsubbsubcsin = TMath::Sin(2.*(eventPlanesub1a - eventPlanesub2a));\r
1736 }\r
e17c1f86 1737 \r
7b5936fc 1738 //////////////////////////////////////\r
1739 // AliFlowEvent and MC event plane\r
1740 /////////////////////////////////////\r
8c1c76e9 1741\r
11ff28c5 1742 Int_t nbtracks = fInputEvent->GetNumberOfTracks();\r
7f695a7b 1743 AliDebug(2,Form("Number of tracks %d",nbtracks));\r
8c1c76e9 1744\r
7b5936fc 1745 if(fMonitorQCumulant) {\r
1746\r
1747 fcutsRP->SetEvent( InputEvent(), MCEvent());\r
1748 fcutsPOI->SetEvent( InputEvent(), MCEvent());\r
1749 if( fflowEvent ){ \r
1750 fflowEvent->~AliFlowEvent();\r
1751 new(fflowEvent) AliFlowEvent(fcutsRP,fcutsPOI);\r
1752 }else fflowEvent = new AliFlowEvent(fcutsRP,fcutsPOI);\r
1753 if(mcEvent && mcEvent->GenEventHeader()) {\r
1754 fflowEvent->SetMCReactionPlaneAngle(mcEvent);\r
1755 //if reaction plane not set from elsewhere randomize it before adding flow\r
1756 //if (!fflowEvent->IsSetMCReactionPlaneAngle()) fflowEvent->SetMCReactionPlaneAngle(gRandom->Uniform(0.0,TMath::TwoPi()));\r
1757 mcReactionPlane = TVector2::Phi_0_2pi(fflowEvent->GetMCReactionPlaneAngle());\r
1758 if(mcReactionPlane > TMath::Pi()) mcReactionPlane = mcReactionPlane - TMath::Pi();\r
7f695a7b 1759 AliDebug(2,Form("MC reaction plane %f",mcReactionPlane));\r
7b5936fc 1760 }\r
1761 fflowEvent->SetReferenceMultiplicity( nbtracks );\r
1762 fflowEvent->DefineDeadZone(0,0,0,0);\r
1763 //fflowEvent.TagSubeventsInEta(-0.8,-0.1,0.1,0.8);\r
1764 \r
1765 ////////////////\r
1766 // MC\r
1767 ///////////////\r
1768 if(fUseMCReactionPlane) {\r
1769 eventPlanea = mcReactionPlane;\r
1770 diffsub1sub2a = 0.0;\r
1771 }\r
8c1c76e9 1772 }\r
1773\r
1774 \r
1775 //////////////////////\r
1776 // Fill Histos\r
1777 //////////////////////\r
1778\r
a70c9e97 1779 fHistEV->Fill(binctt,2.0);\r
e17c1f86 1780 \r
a70c9e97 1781 // Fill\r
1782 valuensparsea[0] = eventPlaneV0A;\r
1783 valuensparsea[1] = eventPlaneV0C;\r
1784 valuensparsea[2] = eventPlaneTPC;\r
1785 if(fVZEROEventPlane && (!fVZEROEventPlaneA) && (!fVZEROEventPlaneC)) {\r
1786 // case VZERO all\r
1787 valuensparsea[0] = eventPlaneV0;\r
1788 valuensparsea[1] = eventPlanesub1a;\r
1789 valuensparsea[2] = eventPlanesub2a;\r
1790 } \r
d87a9d29 1791 //printf("%f %f %f\n",valuensparsea[0],valuensparsea[1],valuensparsea[2]);\r
a70c9e97 1792 fEventPlane->Fill(&valuensparsea[0]);\r
1793\r
1794 // Fill\r
1795 if(fMonitorEventPlane) fCosSin2phiep->Fill(&valuecossinephiep[0]);\r
e17c1f86 1796 \r
a70c9e97 1797 if(!fVZEROEventPlane) {\r
1798 valuensparsef[0] = diffsub1sub2a;\r
1799 fCosRes->Fill(&valuensparsef[0]);\r
1800 valuensparsefsin[0] = diffsub1sub2asin;\r
1801 if(fMonitorEventPlane) fSinRes->Fill(&valuensparsefsin[0]);\r
1802 if(fMonitorEventPlane) {\r
1803 fProfileCosRes->Fill(valuensparsef[1],valuensparsef[0]);\r
e17c1f86 1804 }\r
a70c9e97 1805 }\r
1806 else {\r
1807 valuensparsefbis[0] = diffsubasubb;\r
1808 valuensparsefbis[1] = diffsubasubc;\r
1809 valuensparsefbis[2] = diffsubbsubc;\r
1810 fCosResabc->Fill(&valuensparsefbis[0]); //TR: info\r
1811 valuensparsefbissin[0] = diffsubasubbsin;\r
1812 valuensparsefbissin[1] = diffsubbsubcsin;\r
1813 valuensparsefbissin[2] = diffsubasubcsin;\r
1814 if(fMonitorEventPlane) fSinResabc->Fill(&valuensparsefbissin[0]);\r
1815 if(fMonitorEventPlane) {\r
1816 fProfileCosResab->Fill(valuensparsefbis[3],valuensparsefbis[0]);\r
1817 fProfileCosResac->Fill(valuensparsefbis[3],valuensparsefbis[1]);\r
1818 fProfileCosResbc->Fill(valuensparsefbis[3],valuensparsefbis[2]);\r
e17c1f86 1819 }\r
e17c1f86 1820 }\r
8c1c76e9 1821 \r
0e30407a 1822 ////////////////////////////////////////\r
1823 // Loop to determine pool background\r
1824 /////////////////////////////////////////\r
7b5936fc 1825 if(fMonitorPhotonic) {\r
2747660f 1826\r
1827 fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent,binct);\r
1828 \r
7b5936fc 1829 if( fArraytrack ){ \r
1830 fArraytrack->~TArrayI();\r
1831 new(fArraytrack) TArrayI(nbtracks);\r
1832 }\r
1833 else { \r
1834 fArraytrack = new TArrayI(nbtracks);\r
1835 }\r
1836 fCounterPoolBackground = 0;\r
0e30407a 1837 \r
7b5936fc 1838 for(Int_t k = 0; k < nbtracks; k++){\r
1839 \r
1840 AliVTrack *track = (AliVTrack *) fInputEvent->GetTrack(k);\r
1841 if(!track) continue;\r
1842 \r
1843 // Track cuts\r
1844 Bool_t survivedbackground = kTRUE;\r
1845 if(fAODAnalysis) {\r
1846 AliAODTrack *aodtrack = dynamic_cast<AliAODTrack *>(track);\r
1847 if(aodtrack) {\r
1848 AliESDtrack esdTrack(aodtrack);\r
1849 // set the TPC cluster info\r
1850 esdTrack.SetTPCClusterMap(aodtrack->GetTPCClusterMap());\r
1851 esdTrack.SetTPCSharedMap(aodtrack->GetTPCSharedMap());\r
1852 esdTrack.SetTPCPointsF(aodtrack->GetTPCNclsF());\r
1853 // needed to calculate the impact parameters\r
1854 AliAODEvent *aodeventu = dynamic_cast<AliAODEvent *>(fInputEvent);\r
1855 if(aodeventu) {\r
1856 AliAODVertex *vAOD = aodeventu->GetPrimaryVertex();\r
1857 Double_t bfield = aodeventu->GetMagneticField();\r
1858 Double_t pos[3],cov[6];\r
1859 vAOD->GetXYZ(pos);\r
1860 vAOD->GetCovarianceMatrix(cov);\r
1861 const AliESDVertex vESD(pos,cov,100.,100);\r
1862 esdTrack.RelateToVertex(&vESD,bfield,3.);\r
1863 } \r
1864 if(!fHFEBackgroundCuts->IsSelected(&esdTrack)) {\r
1865 survivedbackground = kFALSE;\r
1866 }\r
0e30407a 1867 }\r
1868 }\r
7b5936fc 1869 else {\r
1870 AliESDtrack *esdtrack = dynamic_cast<AliESDtrack *>(track);\r
1871 if(esdtrack) {\r
1872 if(!fHFEBackgroundCuts->IsSelected(esdtrack)) survivedbackground = kFALSE;\r
1873 }\r
0e30407a 1874 }\r
7b5936fc 1875 // PID\r
1876 if(survivedbackground) {\r
1877 // PID track cuts\r
1878 AliHFEpidObject hfetrack2;\r
1879 if(!fAODAnalysis) hfetrack2.SetAnalysisType(AliHFEpidObject::kESDanalysis);\r
1880 else hfetrack2.SetAnalysisType(AliHFEpidObject::kAODanalysis);\r
1881 hfetrack2.SetRecTrack(track);\r
1882 hfetrack2.SetCentrality((Int_t)binct);\r
7f695a7b 1883 AliDebug(2,Form("centrality %f and %d",binct,hfetrack2.GetCentrality()));\r
7b5936fc 1884 hfetrack2.SetPbPb();\r
1885 if(fPIDBackground->IsSelected(&hfetrack2,0x0,"recTrackCont",fPIDBackgroundqa)) {\r
1886 fArraytrack->AddAt(k,fCounterPoolBackground);\r
1887 fCounterPoolBackground++;\r
7f695a7b 1888 AliDebug(2,Form("fCounterPoolBackground %d, track %d",fCounterPoolBackground,k));\r
7b5936fc 1889 }\r
0e30407a 1890 }\r
1891 }\r
1892 }\r
8c1c76e9 1893\r
7b5936fc 1894\r
1895 ///////////////////////////////////\r
1896 // Loop for kink mother AOD\r
1897 //////////////////////////////////\r
0e30407a 1898 // Look at kink mother in case of AOD\r
1899 Int_t numberofvertices = 1;\r
1900 AliAODEvent *aodevent = NULL;\r
1901 Int_t numberofmotherkink = 0; \r
1902 if(fAODAnalysis) {\r
1903 aodevent = dynamic_cast<AliAODEvent *>(fInputEvent);\r
1904 if(aodevent) {\r
1905 numberofvertices = aodevent->GetNumberOfVertices();\r
1906 }\r
1907 }\r
1908 Double_t listofmotherkink[numberofvertices];\r
1909 if(fAODAnalysis && aodevent) {\r
1910 for(Int_t ivertex=0; ivertex < numberofvertices; ivertex++) {\r
1911 AliAODVertex *aodvertex = aodevent->GetVertex(ivertex);\r
1912 if(!aodvertex) continue;\r
1913 if(aodvertex->GetType()==AliAODVertex::kKink) {\r
1914 AliAODTrack *mother = (AliAODTrack *) aodvertex->GetParent();\r
1915 if(!mother) continue;\r
1916 Int_t idmother = mother->GetID();\r
1917 listofmotherkink[numberofmotherkink] = idmother;\r
7f695a7b 1918 AliDebug(2,Form("ID %d",idmother));\r
0e30407a 1919 numberofmotherkink++;\r
1920 }\r
1921 }\r
1922 }\r
1923 \r
1924 //////////////////////////\r
1925 // Loop over track\r
1926 //////////////////////////\r
1927 \r
1928 for(Int_t k = 0; k < nbtracks; k++){\r
1929 \r
1930 AliVTrack *track = (AliVTrack *) fInputEvent->GetTrack(k);\r
1931 if(!track) continue;\r
1932 \r
4102d1cc 1933 if(fAODAnalysis) {\r
1934 AliAODTrack *aodtrack = dynamic_cast<AliAODTrack *>(track);\r
1935 if(!aodtrack){\r
1936 AliError("AOD track is not there");\r
0e30407a 1937 continue;\r
4102d1cc 1938 } \r
7f695a7b 1939 AliDebug(2,"Find AOD track on");\r
2747660f 1940 if(fUseFilterAOD){\r
1941 if(!(aodtrack->TestFilterBit(fFilter))) continue; // Only process AOD tracks where the HFE is set\r
8c1c76e9 1942 }\r
8c1c76e9 1943 }\r
959ea9d8 1944\r
4102d1cc 1945 if(fApplyCut) {\r
4102d1cc 1946\r
0e30407a 1947 valuetrackingcuts[0] = track->Pt(); \r
1948 valuetrackingcuts[1] = 0;\r
959ea9d8 1949 \r
0e30407a 1950 // RecKine: ITSTPC cuts \r
1951 if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepRecKineITSTPC + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue;\r
7b5936fc 1952 if(fMonitorTrackCuts) fTrackingCuts->Fill(&valuetrackingcuts[0]);\r
959ea9d8 1953\r
0e30407a 1954 // Reject kink mother\r
2747660f 1955 if(fRejectKinkMother) {\r
1956 if(fAODAnalysis) {\r
1957 Bool_t kinkmotherpass = kTRUE;\r
1958 for(Int_t kinkmother = 0; kinkmother < numberofmotherkink; kinkmother++) {\r
1959 if(track->GetID() == listofmotherkink[kinkmother]) {\r
1960 kinkmotherpass = kFALSE;\r
1961 continue;\r
1962 }\r
0e30407a 1963 }\r
2747660f 1964 if(!kinkmotherpass) continue;\r
a8ef1999 1965 }\r
2747660f 1966 else {\r
1967 AliESDtrack *esdtrack = dynamic_cast<AliESDtrack *>(track);\r
1968 if(esdtrack){ \r
1969 if(esdtrack->GetKinkIndex(0) != 0) continue; \r
1970 } // Quick and dirty fix to reject both kink mothers and daughters\r
1971 }\r
1972 } \r
1973\r
4317a065 1974 valuetrackingcuts[1] = 1; \r
7b5936fc 1975 if(fMonitorTrackCuts) fTrackingCuts->Fill(&valuetrackingcuts[0]); \r
0e30407a 1976 // RecPrim\r
1977 if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepRecPrim + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue;\r
4317a065 1978 valuetrackingcuts[1] = 2; \r
7b5936fc 1979 if(fMonitorTrackCuts) fTrackingCuts->Fill(&valuetrackingcuts[0]); \r
1980 \r
0e30407a 1981 // HFEcuts: ITS layers cuts\r
7b5936fc 1982 if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepHFEcutsITS + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue;\r
4317a065 1983 valuetrackingcuts[1] = 3; \r
7b5936fc 1984 if(fMonitorTrackCuts) fTrackingCuts->Fill(&valuetrackingcuts[0]); \r
0e30407a 1985\r
1986 // HFE cuts: TOF PID and mismatch flag\r
1987 if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepHFEcutsTOF + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue;\r
4317a065 1988 valuetrackingcuts[1] = 4; \r
7b5936fc 1989 if(fMonitorTrackCuts) fTrackingCuts->Fill(&valuetrackingcuts[0]); \r
0e30407a 1990 \r
1991 // HFE cuts: TPC PID cleanup\r
1992 if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepHFEcutsTPC + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue;\r
4317a065 1993 valuetrackingcuts[1] = 5; \r
7b5936fc 1994 if(fMonitorTrackCuts) fTrackingCuts->Fill(&valuetrackingcuts[0]); \r
0e30407a 1995 \r
1996 // HFEcuts: Nb of tracklets TRD0\r
1997 if(!fHFECuts->CheckParticleCuts(AliHFEcuts::kStepHFEcutsTRD + AliHFEcuts::kNcutStepsMCTrack, (TObject *)track)) continue;\r
4317a065 1998 valuetrackingcuts[1] = 6; \r
7b5936fc 1999 if(fMonitorTrackCuts) fTrackingCuts->Fill(&valuetrackingcuts[0]); \r
0e30407a 2000 \r
8c1c76e9 2001 }\r
7f695a7b 2002 AliDebug(2,"Survived");\r
8c1c76e9 2003\r
8c1c76e9 2004 /////////////////////////////////////////////////////////\r
0e30407a 2005 // Subtract candidate from TPC event plane\r
8c1c76e9 2006 ////////////////////////////////////////////////////////\r
e17c1f86 2007 Float_t eventplanesubtracted = 0.0; \r
2008\r
e17c1f86 2009 if(!fVZEROEventPlane) {\r
2010 // Subtract the tracks from the event plane\r
959ea9d8 2011 Double_t qX = qTPC->X() - vEPa->GetQContributionX(track); //Modify the components: subtract the track you want to look at with your analysis\r
2012 Double_t qY = qTPC->Y() - vEPa->GetQContributionY(track); //Modify the components: subtract the track you want to look at with your analysis\r
e17c1f86 2013 TVector2 newQVectorfortrack;\r
2014 newQVectorfortrack.Set(qX,qY);\r
2015 eventplanesubtracted = TVector2::Phi_0_2pi(newQVectorfortrack.Phi())/2; \r
2016 }\r
2017 else eventplanesubtracted = eventPlanea;\r
8c1c76e9 2018\r
0e30407a 2019 ///////////////////////////////////////////\r
2020 // Event plane\r
2021 //////////////////////////////////////////\r
e17c1f86 2022 Bool_t fillEventPlane = kTRUE;\r
2023 if(!fVZEROEventPlane){\r
e17c1f86 2024 if((!qsub1a) || (!qsub2a)) fillEventPlane = kFALSE;\r
2025 if(fSubEtaGapTPC) {\r
2026 if(track->Eta() < (- fEtaGap/2.)) eventplanesubtracted = eventPlanesub1a;\r
2027 else if(track->Eta() > (fEtaGap/2.)) eventplanesubtracted = eventPlanesub2a;\r
2028 else fillEventPlane = kFALSE;\r
2029 }\r
8c1c76e9 2030 }\r
959ea9d8 2031\r
8c1c76e9 2032 ///////////////\r
2033 // MC\r
2034 //////////////\r
2035 if(fUseMCReactionPlane) {\r
2036 eventplanesubtracted = mcReactionPlane;\r
e17c1f86 2037 fillEventPlane = kTRUE;\r
8c1c76e9 2038 }\r
2039 \r
2040 //////////////////////////////////////////////////////////////////////////////\r
2041 ///////////////////////////AFTERBURNER\r
2042 Double_t phitrack = track->Phi(); \r
2043 if (fAfterBurnerOn)\r
2044 {\r
2045 phitrack = GetPhiAfterAddV2(track->Phi(),mcReactionPlane);\r
2046 }\r
2047 //////////////////////////////////////////////////////////////////////////////\r
2048\r
2049\r
2050 ///////////////////////\r
2051 // Calculate deltaphi\r
2052 ///////////////////////\r
2053 \r
2054 // Suppose phi track is between 0.0 and phi\r
2055 Double_t deltaphi = TVector2::Phi_0_2pi(phitrack - eventplanesubtracted);\r
2056 if(deltaphi > TMath::Pi()) deltaphi = deltaphi - TMath::Pi();\r
0e30407a 2057\r
5cd679b7 2058 ////////////////////////////////\r
2059 // Determine the deltaphi bin\r
2060 ///////////////////////////////\r
2061\r
2062 // in-plane\r
2063 if(((deltaphi<(TMath::Pi()/4.)) && (deltaphi>0.0)) || ((deltaphi>(3*TMath::Pi()/4.)) && (deltaphi<TMath::Pi()))) valuedeltaphicontamination[0] = 0.5;\r
2064 // out-of-plane\r
2065 if((deltaphi>(TMath::Pi()/4.)) && (deltaphi<(3*TMath::Pi()/4.))) valuedeltaphicontamination[0] = 1.5;\r
2066\r
0e30407a 2067 ////////////////////////////////////////\r
2068 // Define variables\r
2069 ///////////////////////////////////////\r
2070\r
5cd679b7 2071\r
2072 valuedeltaphicontamination[2] = track->Pt();\r
0e30407a 2073 valuensparsee[2] = track->Pt();\r
2074 valuensparsee[3] = track->Eta(); \r
2075 valuensparseg[2] = track->Pt();\r
2076 valuensparseh[2] = track->Pt();\r
6733d981 2077 valuefractioncont[0] = track->Pt();\r
0e30407a 2078 valuensparsehprofile[2] = track->Pt();\r
2079 valuensparseMCSourceDeltaPhiMaps[1] = track->Pt();\r
2080 if(track->Charge() > 0.0) {\r
2081 valuensparseg[3] = 0.2;\r
2082 valuensparseh[3] = 0.2;\r
2083 }\r
2084 else {\r
2085 valuensparseg[3] = -0.2;\r
2086 valuensparseh[3] = -0.2;\r
2087 }\r
2088 valuensparseh[4] = track->Eta();\r
2089 valuensparseg[4] = track->Eta();\r
2090\r
7f695a7b 2091 AliDebug(2,Form("charge %d",(Int_t)track->Charge()));\r
0e30407a 2092\r
2093 ////////////////////////\r
2094 // Fill before PID\r
2095 ///////////////////////\r
2096 \r
7b5936fc 2097 if(fMonitorWithoutPID) { \r
0e30407a 2098 \r
2099 valuensparseg[0] = deltaphi;\r
2100 if(fillEventPlane) fDeltaPhiMapsBeforePID->Fill(&valuensparseg[0]);\r
2101 \r
2102 //\r
2103 valuensparseh[0] = TMath::Cos(2*TVector2::Phi_mpi_pi(phitrack-eventplanesubtracted));\r
2104 if(fillEventPlane) {\r
2105 fCosPhiMapsBeforePID->Fill(&valuensparseh[0]);\r
2106 }\r
2107 }\r
2108 \r
2109 ////////////////////////\r
2110 // Apply PID\r
2111 ////////////////////////\r
2112 if(!fNoPID) {\r
2113 // Apply PID for Data\r
2114 if(!fMCPID) {\r
5cd679b7 2115 // pid object\r
0e30407a 2116 AliHFEpidObject hfetrack;\r
2117 if(!fAODAnalysis) hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);\r
2118 else hfetrack.SetAnalysisType(AliHFEpidObject::kAODanalysis);\r
2119 hfetrack.SetRecTrack(track);\r
2120 hfetrack.SetCentrality((Int_t)binct);\r
7f695a7b 2121 AliDebug(2,Form("centrality %f and %d",binct,hfetrack.GetCentrality()));\r
0e30407a 2122 hfetrack.SetPbPb();\r
5cd679b7 2123\r
2124 // Only TOF PID\r
7b5936fc 2125 if(fMonitorContamination) {\r
2126 if(fPIDTOFOnly->IsSelected(&hfetrack,0x0,"recTrackCont",0x0)) {\r
2127 Float_t nsigma = pidResponse->NumberOfSigmasTPC(track, AliPID::kElectron);\r
2128 valuedeltaphicontamination[3] = nsigma;\r
2129 fDeltaPhiMapsContamination->Fill(&valuedeltaphicontamination[0]);\r
2130 }\r
5cd679b7 2131 }\r
2132\r
2133 // Complete PID TOF+TPC\r
0e30407a 2134 if(!fPID->IsSelected(&hfetrack,0x0,"recTrackCont",fPIDqa)) {\r
2135 continue;\r
2136 }\r
2137 }\r
2138 else {\r
2139 if(!mcEvent) continue;\r
2140 if(!(mctrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(track->GetLabel()))))) continue;\r
7f695a7b 2141 AliDebug(2,Form("PdgCode %d",TMath::Abs(mctrack->Particle()->GetPdgCode())));\r
0e30407a 2142 if(TMath::Abs(mctrack->Particle()->GetPdgCode())!=11) continue;\r
2143 }\r
2144 }\r
2145\r
2146\r
2147 /////////////////////////////////////////////////////////////////////////////\r
2148 // Add candidate to AliFlowEvent for POI and subtract from RP if needed\r
2149 ////////////////////////////////////////////////////////////////////////////\r
7b5936fc 2150 if(fMonitorQCumulant) {\r
2151 Int_t idtrack = static_cast<AliVTrack*>(track)->GetID();\r
2152 Bool_t found = kFALSE;\r
2153 Int_t numberoffound = 0;\r
7f695a7b 2154 AliDebug(2,Form("A: Number of tracks %d",fflowEvent->NumberOfTracks()));\r
7b5936fc 2155 for(Int_t iRPs=0; iRPs< fflowEvent->NumberOfTracks(); iRPs++) {\r
2156 AliFlowTrack *iRP = (AliFlowTrack*) (fflowEvent->GetTrack(iRPs));\r
2157 //if(!iRP->InRPSelection()) continue;\r
2158 if( TMath::Abs(idtrack) == TMath::Abs(iRP->GetID()) ) {\r
2159 iRP->SetForPOISelection(kTRUE);\r
2160 found = kTRUE;\r
2161 numberoffound ++;\r
2162 }\r
0e30407a 2163 }\r
7f695a7b 2164 AliDebug(2,Form("Found %d mal",numberoffound));\r
7b5936fc 2165 if(!found) {\r
2166 AliFlowCandidateTrack *sTrack = (AliFlowCandidateTrack*) MakeTrack(massElectron,track->Pt(),track->Phi(), track->Eta());\r
2167 sTrack->SetID(idtrack);\r
2168 fflowEvent->AddTrack(sTrack);\r
7f695a7b 2169 AliDebug(2,"Add the track");\r
7b5936fc 2170 }\r
7f695a7b 2171 AliDebug(2,Form("B: Number of tracks %d",fflowEvent->NumberOfTracks()));\r
0e30407a 2172 }\r
0e30407a 2173 \r
2174 \r
8c1c76e9 2175 /////////////////////\r
2176 // Fill THnSparseF\r
2177 /////////////////////\r
2178\r
2179 //\r
e17c1f86 2180 valuensparseabis[0] = eventplanesubtracted;\r
7b5936fc 2181 if((fillEventPlane) && (fMonitorEventPlane)) fEventPlaneaftersubtraction->Fill(&valuensparseabis[0]);\r
8c1c76e9 2182 \r
e17c1f86 2183\r
7b5936fc 2184 if(fMonitorEventPlane) \r
e17c1f86 2185 {\r
2186 //\r
2187 valuensparsee[0] = TMath::Cos(2*phitrack);\r
2188 fCos2phie->Fill(&valuensparsee[0]);\r
2189 valuensparsee[0] = TMath::Sin(2*phitrack);\r
2190 fSin2phie->Fill(&valuensparsee[0]);\r
2191 //\r
2192 valuensparsee[0] = TMath::Cos(2*eventplanesubtracted);\r
2193 if(fillEventPlane) fCos2phiep->Fill(&valuensparsee[0]);\r
2194 valuensparsee[0] = TMath::Sin(2*eventplanesubtracted);\r
2195 if(fillEventPlane) fSin2phiep->Fill(&valuensparsee[0]);\r
2196 valuensparsee[0] = TMath::Sin(2*TVector2::Phi_mpi_pi(phitrack-eventplanesubtracted));\r
2197 if(fillEventPlane) fSin2phiephiep->Fill(&valuensparsee[0]);\r
2198 //\r
2199 }\r
2200\r
8c1c76e9 2201 // \r
2202 valuensparseg[0] = deltaphi;\r
e17c1f86 2203 if(fillEventPlane) fDeltaPhiMaps->Fill(&valuensparseg[0]);\r
8c1c76e9 2204 \r
2205 //\r
2206 valuensparseh[0] = TMath::Cos(2*TVector2::Phi_mpi_pi(phitrack-eventplanesubtracted));\r
e17c1f86 2207 if(fillEventPlane) {\r
959ea9d8 2208 fCosPhiMaps->Fill(&valuensparseh[0]); //TR: fCosPhiQSum+=valuensparseh[0]*TMath:Sqrt(qAna->X()*qAna->X()+qAna->Y()*qAna->Y()); fCosPhiQN++;\r
6733d981 2209 if((valuefractioncont[1] >=0) && (valuefractioncont[1] < 11)){\r
2210 if(fContamination[((Int_t)valuefractioncont[1])]){\r
2211 Double_t weight = fContamination[((Int_t)valuefractioncont[1])]->Eval(track->P());\r
2212 if(weight<0.0) weight=0.0;\r
2213 if(weight>1.0) weight=1.0;\r
2214 fFractionContamination->Fill(&valuefractioncont[0],weight);\r
6b2521a4 2215 if(fv2contamination[((Int_t)valuefractioncont[1])]){\r
2216 Double_t v2 = fv2contamination[((Int_t)valuefractioncont[1])]->Eval(track->Pt());\r
709ba9e7 2217 AliDebug(2,Form("value v2 %f, contamination %f and pt %f centrality %d\n",v2,weight,track->Pt(),(Int_t)valuefractioncont[1]));\r
2218 AliDebug(2,Form("Check for centrality 3: value v2 %f, contamination %f\n",fv2contamination[3]->Eval(track->Pt()),fContamination[3]->Eval(track->P())));\r
2219 AliDebug(2,Form("Check for centrality 4: value v2 %f, contamination %f\n",fv2contamination[4]->Eval(track->Pt()),fContamination[4]->Eval(track->P())));\r
2220 AliDebug(2,Form("Check for centrality 5: value v2 %f, contamination %f\n",fv2contamination[5]->Eval(track->Pt()),fContamination[5]->Eval(track->P())));\r
6b2521a4 2221 fContaminationv2->Fill(valuefractioncont[1],valuefractioncont[0],v2,weight);\r
2222 }\r
6733d981 2223 } \r
2224 }\r
7b5936fc 2225 if(fMonitorEventPlane) {\r
959ea9d8 2226 if(fSP)\r
2227 valuensparseh[0] *= TMath::Sqrt(qAna->X()*qAna->X()+qAna->Y()*qAna->Y());\r
2228 fProfileCosPhiMaps->Fill(valuensparsehprofile[1],valuensparsehprofile[2],valuensparseh[0]); //TR: info\r
e17c1f86 2229 }\r
2230 }\r
2231 \r
7b5936fc 2232 if(fMonitorPhotonic) {\r
0e30407a 2233 Int_t indexmother = -1;\r
2747660f 2234 Int_t source = 1;\r
2235 if(mcthere) source = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);\r
2236 fBackgroundSubtraction->LookAtNonHFE(k, track, fInputEvent, 1, binct, deltaphi, source, indexmother);\r
2237 \r
2238 if((!fAODAnalysis && mcthere) || !mcthere) {\r
2239 // background\r
2240 source = 0;\r
2241 indexmother = -1;\r
2242 source = FindMother(TMath::Abs(track->GetLabel()),mcEvent, indexmother);\r
2243 valuensparseMCSourceDeltaPhiMaps[2] = source;\r
2244 if(mcEvent) fMCSourceDeltaPhiMaps->Fill(&valuensparseMCSourceDeltaPhiMaps[0]);\r
2245 //LookAtNonHFE(k,track,fInputEvent,mcEvent,binct,deltaphi,source,indexmother);\r
2246 Int_t taggedvalue = LookAtNonHFE(k,track,fInputEvent,mcEvent,binct,deltaphi,source,indexmother);\r
2247 if(fMonitorPhotonic) {\r
2248 // No opposite charge partner found in the invariant mass choosen\r
2249 if((taggedvalue!=2) && (taggedvalue!=6)) {\r
2250 //fDeltaPhiMapsTaggedNonPhotonic->Fill(&valuensparseg[0]);\r
2251 //fCosPhiMapsTaggedNonPhotonic->Fill(&valuensparseh[0]);\r
2252 }\r
2253 // One opposite charge partner found in the invariant mass choosen\r
2254 if((taggedvalue==2) || (taggedvalue==6)) {\r
2255 fDeltaPhiMapsTaggedPhotonic->Fill(&valuensparseg[0]);\r
2256 //fCosPhiMapsTaggedPhotonic->Fill(&valuensparseh[0]);\r
2257 }\r
2258 // One same charge partner found in the invariant mass choosen\r
2259 if((taggedvalue==4) || (taggedvalue==6)) {\r
2260 fDeltaPhiMapsTaggedPhotonicLS->Fill(&valuensparseg[0]);\r
2261 //fCosPhiMapsTaggedPhotonicLS->Fill(&valuensparseh[0]);\r
2262 }\r
0e30407a 2263 }\r
2264 }\r
2265 }\r
8c1c76e9 2266 \r
2267 }\r
2268\r
2269 //////////////////////////////////////////////////////////////////////////////\r
2270 ///////////////////////////AFTERBURNER\r
7b5936fc 2271 if (fAfterBurnerOn & fMonitorQCumulant)\r
8c1c76e9 2272 {\r
2273 fflowEvent->AddFlow(fV1,fV2,fV3,fV4,fV5); //add flow\r
2274 fflowEvent->CloneTracks(fNonFlowNumberOfTrackClones); //add nonflow by cloning tracks\r
2275 }\r
2276 //////////////////////////////////////////////////////////////////////////////\r
2277\r
2278\r
2279\r
7f695a7b 2280 //for(Int_t bincless = 0; bincless < fNbBinsCentralityQCumulant; bincless++) {\r
2281 // if((fBinCentralityLess[bincless]< cntr) && (cntr < fBinCentralityLess[bincless+1])) PostData(bincless+2,fflowEvent);\r
2282 //}\r
0e30407a 2283\r
7b5936fc 2284 if(fMonitorPhotonic) {\r
2285 if(fArraytrack) {\r
2286 delete fArraytrack;\r
2287 fArraytrack = NULL;\r
2288 }\r
0e30407a 2289 }\r
8c1c76e9 2290 \r
8c1c76e9 2291 PostData(1, fListHist);\r
2292\r
8c1c76e9 2293 \r
2294}\r
2295//______________________________________________________________________________\r
914042c2 2296AliFlowCandidateTrack *AliAnalysisTaskFlowTPCTOFEPSP::MakeTrack( Double_t mass, \r
8c1c76e9 2297 Double_t pt, Double_t phi, Double_t eta) {\r
2298 //\r
2299 // Make Track (Not needed actually)\r
2300 //\r
2301\r
2302 AliFlowCandidateTrack *sTrack = new AliFlowCandidateTrack();\r
2303 sTrack->SetMass(mass);\r
2304 sTrack->SetPt(pt);\r
2305 sTrack->SetPhi(phi);\r
2306 sTrack->SetEta(eta);\r
2307 sTrack->SetForPOISelection(kTRUE);\r
2308 sTrack->SetForRPSelection(kFALSE);\r
2309 return sTrack;\r
2310}\r
2311//_________________________________________________________________________________ \r
914042c2 2312Double_t AliAnalysisTaskFlowTPCTOFEPSP::GetPhiAfterAddV2(Double_t phi,Double_t reactionPlaneAngle) const\r
8c1c76e9 2313{\r
2314 //\r
2315 // Adds v2, uses Newton-Raphson iteration\r
2316 //\r
2317 Double_t phiend=phi;\r
2318 Double_t phi0=phi;\r
2319 Double_t f=0.;\r
2320 Double_t fp=0.;\r
2321 Double_t phiprev=0.;\r
2322\r
2323 for (Int_t i=0; i<fMaxNumberOfIterations; i++)\r
2324 {\r
2325 phiprev=phiend; //store last value for comparison\r
2326 f = phiend-phi0+fV2*TMath::Sin(2.*(phiend-reactionPlaneAngle));\r
2327 fp = 1.0+2.0*fV2*TMath::Cos(2.*(phiend-reactionPlaneAngle)); //first derivative\r
2328 phiend -= f/fp;\r
2329 if (TMath::AreEqualAbs(phiprev,phiend,fPrecisionPhi)) break;\r
2330 }\r
2331 return phiend;\r
2332}\r
0e30407a 2333//_____________________________________________________________________________________________\r
914042c2 2334Int_t AliAnalysisTaskFlowTPCTOFEPSP::LookAtNonHFE(Int_t iTrack1, AliVTrack *track1, AliVEvent *vEvent, AliMCEvent *mcEvent,Int_t binct,Double_t deltaphi,Int_t source,Int_t indexmother)\r
0e30407a 2335{ \r
2336 //\r
2337 // Look At Non HFE\r
2338 //\r
2339\r
2340 // return -1 if nothing\r
2341 // return 2 if opposite charge within the mass range found\r
2342 // return 4 if like charge within the mass range found\r
2343 // return 6 if opposite charge and like charge within the mass range found\r
2344 //\r
2345\r
2346 Int_t taggedphotonic = -1;\r
2347\r
2348 Bool_t oppositetaggedphotonic = kFALSE;\r
2349 Bool_t sametaggedphotonic = kFALSE;\r
2350\r
7f695a7b 2351 AliDebug(2,Form("fCounterPoolBackground %d in LookAtNonHFE!!!",fCounterPoolBackground));\r
0e30407a 2352 if(!fArraytrack) return taggedphotonic;\r
7f695a7b 2353 AliDebug(2,Form("process track %d",iTrack1));\r
0e30407a 2354 \r
2355 TVector3 v3D1;\r
2356 TVector3 v3D2;\r
2357\r
2358 Double_t valuensparseDeltaPhiMaps[5];\r
2359 Double_t valueangle[3];\r
2360\r
2361 valuensparseDeltaPhiMaps[1] = binct;\r
2362 valuensparseDeltaPhiMaps[2] = track1->Pt();\r
2363 valuensparseDeltaPhiMaps[0] = deltaphi;\r
2364 valuensparseDeltaPhiMaps[4] = source;\r
2365 \r
2366 valueangle[2] = source;\r
2367 valueangle[1] = binct;\r
2368\r
5cd679b7 2369 // Pdg code\r
2370 Int_t pdg1 = CheckPdg(TMath::Abs(track1->GetLabel()),mcEvent);\r
2371 Int_t numberfound = 0;\r
2372\r
0e30407a 2373 //Magnetic Field\r
2374 Double_t bfield = vEvent->GetMagneticField();\r
7b4c9210 2375\r
2376 // Get Primary vertex\r
2377 const AliVVertex *pVtx = vEvent->GetPrimaryVertex();\r
0e30407a 2378 \r
2379 for(Int_t idex = 0; idex < fCounterPoolBackground; idex++) \r
2380 {\r
2381\r
2382 Int_t iTrack2 = fArraytrack->At(idex);\r
7f695a7b 2383 AliDebug(2,Form("track %d",iTrack2));\r
0e30407a 2384 AliVTrack* track2 = (AliVTrack *) vEvent->GetTrack(iTrack2);\r
2385 if (!track2) \r
2386 {\r
7f695a7b 2387 printf("ERROR: Could not receive track %d", iTrack2);\r
0e30407a 2388 continue;\r
2389 }\r
2390 if(iTrack2==iTrack1) continue;\r
7f695a7b 2391 AliDebug(2,"Different");\r
0e30407a 2392\r
5cd679b7 2393 // Reset the MC info\r
2394 valueangle[2] = source;\r
2395 valuensparseDeltaPhiMaps[4] = source;\r
2396\r
0e30407a 2397 // track cuts and PID already done\r
2398\r
2399 // if MC look\r
5cd679b7 2400 Int_t pdg2 = -100;\r
0e30407a 2401 if(mcEvent) {\r
2402 Int_t source2 = 0;\r
2403 Int_t indexmother2 = -1;\r
2404 source2 = FindMother(TMath::Abs(track2->GetLabel()),mcEvent, indexmother2);\r
5cd679b7 2405 pdg2 = CheckPdg(TMath::Abs(track2->GetLabel()),mcEvent);\r
7b4c9210 2406 if(source2 >=0 ) {\r
5cd679b7 2407 if((indexmother2 == indexmother) && (source == source2) && ((pdg1*pdg2)<0.0)) {\r
7b4c9210 2408 if(source == kElectronfromconversion) {\r
2409 valueangle[2] = kElectronfromconversionboth;\r
2410 valuensparseDeltaPhiMaps[4] = kElectronfromconversionboth;\r
5cd679b7 2411 numberfound++;\r
7b4c9210 2412 }\r
2413 if(source == kElectronfrompi0) {\r
2414 valueangle[2] = kElectronfrompi0both;\r
2415 valuensparseDeltaPhiMaps[4] = kElectronfrompi0both;\r
2416 }\r
2417 if(source == kElectronfrometa) {\r
2418 valueangle[2] = kElectronfrometaboth;\r
2419 valuensparseDeltaPhiMaps[4] = kElectronfrometaboth;\r
2420 }\r
0e30407a 2421 }\r
2422 }\r
2423 }\r
2424 \r
2425 if(fAlgorithmMA && (!fAODAnalysis))\r
2426 {\r
2427 // tracks\r
2428 AliESDtrack *esdtrack2 = dynamic_cast<AliESDtrack *>(track2); \r
2429 AliESDtrack *esdtrack1 = dynamic_cast<AliESDtrack *>(track1); \r
2430 if((!esdtrack2) || (!esdtrack1)) continue;\r
2431\r
2432 //Variables\r
2433 Double_t p1[3];\r
2434 Double_t p2[3];\r
2435 Double_t xt1; //radial position track 1 at the DCA point\r
2436 Double_t xt2; //radial position track 2 at the DCA point\r
2437 //DCA track1-track2\r
2438 Double_t dca12 = esdtrack2->GetDCA(esdtrack1,bfield,xt2,xt1);\r
2439\r
2440 // Cut dca\r
2441 if(dca12 > fMaxdca) continue;\r
2442 \r
2443 //Momento of the track extrapolated to DCA track-track \r
2444 //Track1\r
2445 Bool_t hasdcaT1 = esdtrack1->GetPxPyPzAt(xt1,bfield,p1);\r
2446 //Track2\r
2447 Bool_t hasdcaT2 = esdtrack2->GetPxPyPzAt(xt2,bfield,p2);\r
2448 \r
2449 if(!hasdcaT1 || !hasdcaT2) AliWarning("It could be a problem in the extrapolation");\r
2450 \r
2451 //track1-track2 Invariant Mass\r
2452 Double_t eMass = 0.000510998910; //Electron mass in GeV\r
2453 Double_t pP1 = sqrt(p1[0]*p1[0]+p1[1]*p1[1]+p1[2]*p1[2]); //Track 1 momentum\r
2454 Double_t pP2 = sqrt(p2[0]*p2[0]+p2[1]*p2[1]+p2[2]*p2[2]); //Track 2 momentum\r
2455 Double_t eE1 = TMath::Sqrt(pP1*pP1+eMass*eMass);\r
2456 Double_t eE2 = TMath::Sqrt(pP2*pP2+eMass*eMass);\r
2457 \r
2458 //TLorentzVector v1(p1[0],p1[1],p1[2],sqrt(eMass*eMass+pP1*pP1));\r
2459 //TLorentzVector v2(p2[0],p2[1],p2[2],sqrt(eMass*eMass+pP2*pP2));\r
2460 //Double_t imass = (v1+v2).M(); //Invariant Mass\r
2461 //Double_t angle3D = v1.Angle(v2.Vect()); //Opening Angle (Total Angle)\r
2462 \r
2463 // daughter\r
2464 v3D1.SetXYZ(p1[0],p1[1],p1[2]);\r
2465 v3D2.SetXYZ(p2[0],p2[1],p2[2]);\r
2466 Double_t openingangle = TVector2::Phi_0_2pi(v3D2.Angle(v3D1));\r
2467 \r
2468 // mother\r
2469 TVector3 motherrec = v3D1 + v3D2;\r
2470 Double_t invmass = TMath::Sqrt((eE1+eE2)*(eE1+eE2)-(motherrec.Px()*motherrec.Px()+motherrec.Py()*motherrec.Py()+motherrec.Pz()*motherrec.Pz()));\r
2471 \r
2472 // xy\r
2473 //TVector3 vectordiff = v3D1 - v3D2;\r
2474 //Double_t diffphi = TVector2::Phi_0_2pi(vectordiff.Phi());\r
2475 //Double_t massxy = TMath::Sqrt((eE1+eE2)*(eE1+eE2)-(pP1*pP1+pP2*pP2+2*pP1*pP2*TMath::Cos(diffphi)));\r
2476\r
2477 // rz\r
2478 //Double_t difftheta = TVector2::Phi_0_2pi(vectordiff.Eta());\r
2479 //Double_t massrz = TMath::Sqrt((eE1+eE2)*(eE1+eE2)-(pP1*pP1+pP2*pP2+2*pP1*pP2*TMath::Cos(difftheta)));\r
2480 \r
2481\r
2482 Float_t fCharge1 = track1->Charge();\r
2483 Float_t fCharge2 = track2->Charge();\r
2484\r
2485 // Fill Histo\r
2486 //valueangle[0] = diffphi;\r
2487 //valueangle[1] = difftheta;\r
2488 valueangle[0] = openingangle;\r
2489 if((fCharge1*fCharge2)>0.0) fSameSignAngle->Fill(&valueangle[0]);\r
2490 else fOppSignAngle->Fill(&valueangle[0]);\r
2491\r
2492 // Cut\r
2493 if(openingangle > fMaxopening3D) continue;\r
2494 //if(difftheta > fMaxopeningtheta) continue;\r
2495 //if(diffphi > fMaxopeningphi) continue;\r
2496\r
2497 // Invmass\r
2498 valuensparseDeltaPhiMaps[3] = invmass;\r
2499 if((fCharge1*fCharge2)>0.0) fSameSignDeltaPhiMaps->Fill(&valuensparseDeltaPhiMaps[0]);\r
2500 else fOppSignDeltaPhiMaps->Fill(&valuensparseDeltaPhiMaps[0]);\r
2501 \r
2502 // Cut\r
2503 if(invmass < fMaxInvmass) {\r
2504 if((fCharge1*fCharge2)<0.0) oppositetaggedphotonic=kTRUE;\r
2505 if((fCharge1*fCharge2)>0.0) sametaggedphotonic=kTRUE;\r
2506 }\r
2507\r
2508\r
2509 }\r
2510 else \r
2511 {\r
2512 Int_t fPDGtrack1 = 11; \r
2513 Int_t fPDGtrack2 = 11;\r
2514 \r
2515 Float_t fCharge1 = track1->Charge();\r
2516 Float_t fCharge2 = track2->Charge();\r
2517 \r
2518 if(fCharge1>0) fPDGtrack1 = -11;\r
2519 if(fCharge2>0) fPDGtrack2 = -11;\r
2520 \r
7b4c9210 2521 AliKFParticle ktrack1(*track1, fPDGtrack1);\r
2522 AliKFParticle ktrack2(*track2, fPDGtrack2);\r
2523 AliKFParticle recoGamma(ktrack1, ktrack2);\r
0e30407a 2524 \r
2525 //Reconstruction Cuts\r
7b4c9210 2526 if(recoGamma.GetNDF()<1) continue;\r
2527 Double_t chi2OverNDF = recoGamma.GetChi2()/recoGamma.GetNDF();\r
0e30407a 2528 if(TMath::Sqrt(TMath::Abs(chi2OverNDF))>fChi2OverNDFCut) continue;\r
5cd679b7 2529\r
2530 // DCA\r
2531 //Double_t dca12 = ktrack1.GetDistanceFromParticle(ktrack2);\r
2532 //if(dca12 > fMaxdca) continue; \r
2533\r
7b4c9210 2534 // if set mass constraint\r
2535 if(fSetMassConstraint && pVtx) {\r
2536 AliKFVertex primV(*pVtx);\r
2537 primV += recoGamma;\r
5cd679b7 2538 primV -= ktrack1;\r
2539 primV -= ktrack2;\r
7b4c9210 2540 recoGamma.SetProductionVertex(primV);\r
2541 recoGamma.SetMassConstraint(0,0.0001);\r
2542 } \r
2543\r
0e30407a 2544 //Invariant Mass\r
2545 Double_t imass; \r
2546 Double_t width;\r
7b4c9210 2547 recoGamma.GetMass(imass,width);\r
0e30407a 2548 \r
2549 //Opening Angle (Total Angle)\r
7b4c9210 2550 Double_t angle = ktrack1.GetAngle(ktrack2);\r
0e30407a 2551 valueangle[0] = angle;\r
2552 if((fCharge1*fCharge2)>0.0) fSameSignAngle->Fill(&valueangle[0]);\r
7b4c9210 2553 else fOppSignAngle->Fill(&valueangle[0]);\r
2554\r
2555 // Cut\r
2556 if(angle > fMaxopening3D) continue; \r
0e30407a 2557\r
2558 // Invmass\r
2559 valuensparseDeltaPhiMaps[3] = imass;\r
2560 if((fCharge1*fCharge2)>0.0) fSameSignDeltaPhiMaps->Fill(&valuensparseDeltaPhiMaps[0]);\r
5cd679b7 2561 else {\r
2562 fOppSignDeltaPhiMaps->Fill(&valuensparseDeltaPhiMaps[0]);\r
2563 /*\r
2564 if(valueangle[2] == kElectronfromconversionboth) {\r
7f695a7b 2565 printf("Reconstructed charge1 %f, charge 2 %f and invmass %f",fCharge1,fCharge2,imass);\r
2566 printf("MC charge1 %d, charge 2 %d",pdg1,pdg2);\r
2567 printf("DCA %f",dca12);\r
2568 printf("Number of found %d",numberfound);\r
5cd679b7 2569 }\r
2570 */\r
2571 }\r
0e30407a 2572 \r
2573 // Cut\r
2574 if(imass < fMaxInvmass) {\r
2575 if((fCharge1*fCharge2)<0.0) oppositetaggedphotonic=kTRUE;\r
2576 if((fCharge1*fCharge2)>0.0) sametaggedphotonic=kTRUE;\r
2577 }\r
0e30407a 2578 }\r
2579 }\r
7b4c9210 2580 \r
0e30407a 2581 if(oppositetaggedphotonic && sametaggedphotonic){\r
2582 taggedphotonic = 6;\r
2583 }\r
2584\r
2585 if(!oppositetaggedphotonic && sametaggedphotonic){\r
2586 taggedphotonic = 4;\r
2587 }\r
2588\r
2589 if(oppositetaggedphotonic && !sametaggedphotonic){\r
2590 taggedphotonic = 2;\r
2591 }\r
2592\r
2593 \r
2594 return taggedphotonic;\r
2595}\r
0e30407a 2596//_________________________________________________________________________\r
914042c2 2597Int_t AliAnalysisTaskFlowTPCTOFEPSP::FindMother(Int_t tr, AliMCEvent *mcEvent, Int_t &indexmother){\r
0e30407a 2598 //\r
2599 // Find the mother if MC\r
2600 //\r
2601\r
2602 if(!mcEvent) return 0;\r
7b4c9210 2603\r
2604 Int_t pdg = CheckPdg(tr,mcEvent);\r
2605 if(TMath::Abs(pdg)!= 11) {\r
2606 indexmother = -1;\r
2607 return kNoElectron;\r
2608 }\r
0e30407a 2609 \r
2610 indexmother = IsMotherGamma(tr,mcEvent);\r
2611 if(indexmother > 0) return kElectronfromconversion;\r
2612 indexmother = IsMotherPi0(tr,mcEvent);\r
2613 if(indexmother > 0) return kElectronfrompi0;\r
2614 indexmother = IsMotherC(tr,mcEvent);\r
2615 if(indexmother > 0) return kElectronfromC;\r
2616 indexmother = IsMotherB(tr,mcEvent);\r
2617 if(indexmother > 0) return kElectronfromB;\r
2618 indexmother = IsMotherEta(tr,mcEvent);\r
2619 if(indexmother > 0) return kElectronfrometa;\r
2620 \r
2621 return kElectronfromother;\r
2622\r
2623\r
7b4c9210 2624}\r
2625//____________________________________________________________________________________________________________\r
914042c2 2626Int_t AliAnalysisTaskFlowTPCTOFEPSP::CheckPdg(Int_t tr, AliMCEvent* mcEvent) {\r
7b4c9210 2627\r
2628 //\r
2629 // Return the pdg of the particle\r
2630 //\r
2631\r
7b4c9210 2632\r
5cd679b7 2633 Int_t pdgcode = -1;\r
7b4c9210 2634 if(tr < 0) return pdgcode;\r
5cd679b7 2635\r
2636 if(!mcEvent) return pdgcode;\r
2637\r
7b4c9210 2638 AliVParticle *mctrack = mcEvent->GetTrack(tr);\r
2639 \r
2640 \r
2641 if(mctrack->IsA() == AliMCParticle::Class()) {\r
2642 AliMCParticle *mctrackesd = NULL;\r
2643 if(!(mctrackesd = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return pdgcode;\r
2644 pdgcode = mctrackesd->PdgCode();\r
2645 }\r
2646\r
2647 if(mctrack->IsA() == AliAODMCParticle::Class()) {\r
2648 AliAODMCParticle *mctrackaod = NULL;\r
2649 if(!(mctrackaod = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return pdgcode;\r
2650 pdgcode = mctrackaod->GetPdgCode();\r
2651 }\r
2652 \r
2653 return pdgcode;\r
2654\r
2655 \r
0e30407a 2656}\r
2657//____________________________________________________________________________________________________________\r
914042c2 2658Int_t AliAnalysisTaskFlowTPCTOFEPSP::IsMotherGamma(Int_t tr, AliMCEvent* mcEvent) {\r
0e30407a 2659\r
2660 //\r
2661 // Return the lab of gamma mother or -1 if not gamma\r
2662 //\r
2663\r
2664 if(tr < 0) return -1;\r
2665 AliVParticle *mctrack = mcEvent->GetTrack(tr);\r
2666 \r
2667 if(mctrack->IsA() == AliMCParticle::Class()) {\r
2668 AliMCParticle *mctrackesd = NULL;\r
2669 if(!(mctrackesd = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return -1;\r
2670 TParticle *particle = 0x0;\r
2671 particle = mctrackesd->Particle();\r
2672 // Take mother\r
2673 if(!particle) return -1;\r
2674 Int_t imother = particle->GetFirstMother(); \r
2675 if(imother < 0) return -1; \r
2676 AliMCParticle *mothertrack = NULL;\r
2677 if(!(mothertrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(imother))))) return -1;\r
2678 TParticle * mother = mothertrack->Particle();\r
2679 if(!mother) return -1;\r
2680 // Check gamma \r
2681 Int_t pdg = mother->GetPdgCode();\r
2682 if(TMath::Abs(pdg) == 22) return imother;\r
2683 if(TMath::Abs(pdg) == 11) {\r
2684 return IsMotherGamma(imother,mcEvent);\r
2685 }\r
2686 return -1;\r
2687 }\r
2688\r
2689 if(mctrack->IsA() == AliAODMCParticle::Class()) {\r
2690 AliAODMCParticle *mctrackaod = NULL;\r
2691 if(!(mctrackaod = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return -1;\r
2692 // Take mother\r
2693 Int_t imother = mctrackaod->GetMother();\r
2694 if(imother < 0) return -1; \r
2695 AliAODMCParticle *mothertrack = NULL;\r
2696 if(!(mothertrack = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(imother))))) return -1;\r
2697 // Check gamma \r
2698 Int_t pdg = mothertrack->GetPdgCode();\r
2699 if(TMath::Abs(pdg) == 22) return imother;\r
2700 if(TMath::Abs(pdg) == 11) {\r
2701 return IsMotherGamma(imother,mcEvent);\r
2702 }\r
2703 return -1;\r
2704\r
2705 }\r
2706 \r
2707 return -1;\r
2708\r
2709 \r
2710}\r
2711//\r
2712//____________________________________________________________________________________________________________\r
914042c2 2713Int_t AliAnalysisTaskFlowTPCTOFEPSP::IsMotherPi0(Int_t tr, AliMCEvent* mcEvent) {\r
0e30407a 2714\r
2715 //\r
2716 // Return the lab of pi0 mother or -1 if not pi0\r
2717 //\r
2718\r
2719 if(tr < 0) return -1;\r
2720 AliVParticle *mctrack = mcEvent->GetTrack(tr);\r
2721 \r
2722 if(mctrack->IsA() == AliMCParticle::Class()) {\r
2723 AliMCParticle *mctrackesd = NULL;\r
2724 if(!(mctrackesd = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return -1;\r
2725 TParticle *particle = 0x0;\r
2726 particle = mctrackesd->Particle();\r
2727 // Take mother\r
2728 if(!particle) return -1;\r
2729 Int_t imother = particle->GetFirstMother(); \r
2730 if(imother < 0) return -1; \r
2731 AliMCParticle *mothertrack = NULL;\r
2732 if(!(mothertrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(imother))))) return -1;\r
2733 TParticle * mother = mothertrack->Particle();\r
2734 if(!mother) return -1;\r
2735 // Check gamma \r
2736 Int_t pdg = mother->GetPdgCode();\r
2737 if(TMath::Abs(pdg) == 111) return imother;\r
2738 if(TMath::Abs(pdg) == 11) {\r
2739 return IsMotherPi0(imother,mcEvent);\r
2740 }\r
2741 return -1;\r
2742 }\r
2743\r
2744 if(mctrack->IsA() == AliAODMCParticle::Class()) {\r
2745 AliAODMCParticle *mctrackaod = NULL;\r
2746 if(!(mctrackaod = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return -1;\r
2747 // Take mother\r
2748 Int_t imother = mctrackaod->GetMother();\r
2749 if(imother < 0) return -1; \r
2750 AliAODMCParticle *mothertrack = NULL;\r
2751 if(!(mothertrack = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(imother))))) return -1;\r
2752 // Check gamma \r
2753 Int_t pdg = mothertrack->GetPdgCode();\r
2754 if(TMath::Abs(pdg) == 111) return imother;\r
2755 if(TMath::Abs(pdg) == 11) {\r
2756 return IsMotherPi0(imother,mcEvent);\r
2757 }\r
2758 return -1;\r
2759 }\r
2760\r
2761 return -1;\r
2762 \r
2763}\r
2764//____________________________________________________________________________________________________________\r
914042c2 2765Int_t AliAnalysisTaskFlowTPCTOFEPSP::IsMotherC(Int_t tr, AliMCEvent* mcEvent) {\r
0e30407a 2766\r
2767 //\r
2768 // Return the lab of signal mother or -1 if not signal\r
2769 //\r
2770\r
2771 if(tr < 0) return -1;\r
2772 AliVParticle *mctrack = mcEvent->GetTrack(tr);\r
2773 \r
2774 if(mctrack->IsA() == AliMCParticle::Class()) {\r
2775 AliMCParticle *mctrackesd = NULL;\r
2776 if(!(mctrackesd = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return -1;\r
2777 TParticle *particle = 0x0;\r
2778 particle = mctrackesd->Particle();\r
2779 // Take mother\r
2780 if(!particle) return -1;\r
2781 Int_t imother = particle->GetFirstMother(); \r
2782 if(imother < 0) return -1; \r
2783 AliMCParticle *mothertrack = NULL;\r
2784 if(!(mothertrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(imother))))) return -1;\r
2785 TParticle * mother = mothertrack->Particle();\r
2786 if(!mother) return -1;\r
2787 // Check gamma \r
2788 Int_t pdg = mother->GetPdgCode();\r
2789 if((TMath::Abs(pdg)==411) || (TMath::Abs(pdg)==421) || (TMath::Abs(pdg)==431) || (TMath::Abs(pdg)==4122) || (TMath::Abs(pdg)==4132) || (TMath::Abs(pdg)==4232) || (TMath::Abs(pdg)==43320)) return imother;\r
2790 if(TMath::Abs(pdg) == 11) {\r
2791 return IsMotherC(imother,mcEvent);\r
2792 }\r
2793 return -1;\r
2794 }\r
2795\r
2796 if(mctrack->IsA() == AliAODMCParticle::Class()) {\r
2797 AliAODMCParticle *mctrackaod = NULL;\r
2798 if(!(mctrackaod = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return -1;\r
2799 // Take mother\r
2800 Int_t imother = mctrackaod->GetMother();\r
2801 if(imother < 0) return -1; \r
2802 AliAODMCParticle *mothertrack = NULL;\r
2803 if(!(mothertrack = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(imother))))) return -1;\r
2804 // Check gamma \r
2805 Int_t pdg = mothertrack->GetPdgCode();\r
2806 if((TMath::Abs(pdg)==411) || (TMath::Abs(pdg)==421) || (TMath::Abs(pdg)==431) || (TMath::Abs(pdg)==4122) || (TMath::Abs(pdg)==4132) || (TMath::Abs(pdg)==4232) || (TMath::Abs(pdg)==43320)) return imother;\r
2807 if(TMath::Abs(pdg) == 11) {\r
2808 return IsMotherC(imother,mcEvent);\r
2809 }\r
2810 return -1;\r
2811 }\r
2812\r
2813 return -1;\r
2814\r
2815}\r
2816//____________________________________________________________________________________________________________\r
914042c2 2817Int_t AliAnalysisTaskFlowTPCTOFEPSP::IsMotherB(Int_t tr, AliMCEvent* mcEvent) {\r
0e30407a 2818\r
2819 //\r
2820 // Return the lab of signal mother or -1 if not signal\r
2821 //\r
2822\r
2823 if(tr < 0) return -1;\r
2824 AliVParticle *mctrack = mcEvent->GetTrack(tr);\r
2825 \r
2826 if(mctrack->IsA() == AliMCParticle::Class()) {\r
2827 AliMCParticle *mctrackesd = NULL;\r
2828 if(!(mctrackesd = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return -1;\r
2829 TParticle *particle = 0x0;\r
2830 particle = mctrackesd->Particle();\r
2831 // Take mother\r
2832 if(!particle) return -1;\r
2833 Int_t imother = particle->GetFirstMother(); \r
2834 if(imother < 0) return -1; \r
2835 AliMCParticle *mothertrack = NULL;\r
2836 if(!(mothertrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(imother))))) return -1;\r
2837 TParticle * mother = mothertrack->Particle();\r
2838 if(!mother) return -1;\r
2839 // Check gamma \r
2840 Int_t pdg = mother->GetPdgCode();\r
2841 if((TMath::Abs(pdg)==511) || (TMath::Abs(pdg)==521) || (TMath::Abs(pdg)==531) || (TMath::Abs(pdg)==5122) || (TMath::Abs(pdg)==5132) || (TMath::Abs(pdg)==5232) || (TMath::Abs(pdg)==53320)) return imother; \r
2842 if(TMath::Abs(pdg) == 11) {\r
2843 return IsMotherB(imother,mcEvent);\r
2844 }\r
2845 return -1;\r
2846 }\r
2847\r
2848 if(mctrack->IsA() == AliAODMCParticle::Class()) {\r
2849 AliAODMCParticle *mctrackaod = NULL;\r
2850 if(!(mctrackaod = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return -1;\r
2851 // Take mother\r
2852 Int_t imother = mctrackaod->GetMother();\r
2853 if(imother < 0) return -1; \r
2854 AliAODMCParticle *mothertrack = NULL;\r
2855 if(!(mothertrack = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(imother))))) return -1;\r
2856 // Check gamma \r
2857 Int_t pdg = mothertrack->GetPdgCode();\r
2858 if((TMath::Abs(pdg)==511) || (TMath::Abs(pdg)==521) || (TMath::Abs(pdg)==531) || (TMath::Abs(pdg)==5122) || (TMath::Abs(pdg)==5132) || (TMath::Abs(pdg)==5232) || (TMath::Abs(pdg)==53320)) return imother;\r
2859 if(TMath::Abs(pdg) == 11) {\r
2860 return IsMotherB(imother,mcEvent);\r
2861 }\r
2862 return -1;\r
2863 }\r
2864\r
2865 return -1;\r
2866\r
2867}\r
2868//____________________________________________________________________________________________________________\r
914042c2 2869Int_t AliAnalysisTaskFlowTPCTOFEPSP::IsMotherEta(Int_t tr, AliMCEvent* mcEvent) {\r
0e30407a 2870\r
2871 //\r
2872 // Return the lab of pi0 mother or -1 if not pi0\r
2873 //\r
2874\r
2875 if(tr < 0) return -1;\r
2876 AliVParticle *mctrack = mcEvent->GetTrack(tr);\r
2877 \r
2878 if(mctrack->IsA() == AliMCParticle::Class()) {\r
2879 AliMCParticle *mctrackesd = NULL;\r
2880 if(!(mctrackesd = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return -1;\r
2881 TParticle *particle = 0x0;\r
2882 particle = mctrackesd->Particle();\r
2883 // Take mother\r
2884 if(!particle) return -1;\r
2885 Int_t imother = particle->GetFirstMother(); \r
2886 if(imother < 0) return -1; \r
2887 AliMCParticle *mothertrack = NULL;\r
2888 if(!(mothertrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(TMath::Abs(imother))))) return -1;\r
2889 TParticle * mother = mothertrack->Particle();\r
2890 if(!mother) return -1;\r
2891 // Check gamma \r
2892 Int_t pdg = mother->GetPdgCode();\r
2893 if(TMath::Abs(pdg) == 221) return imother;\r
2894 if(TMath::Abs(pdg) == 11) {\r
2895 return IsMotherEta(imother,mcEvent);\r
2896 }\r
2897 return -1;\r
2898 }\r
2899\r
2900 if(mctrack->IsA() == AliAODMCParticle::Class()) {\r
2901 AliAODMCParticle *mctrackaod = NULL;\r
2902 if(!(mctrackaod = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(tr))))) return -1;\r
2903 // Take mother\r
2904 Int_t imother = mctrackaod->GetMother();\r
2905 if(imother < 0) return -1; \r
2906 AliAODMCParticle *mothertrack = NULL;\r
2907 if(!(mothertrack = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(TMath::Abs(imother))))) return -1;\r
2908 // Check gamma \r
2909 Int_t pdg = mothertrack->GetPdgCode();\r
2910 if(TMath::Abs(pdg) == 221) return imother;\r
2911 if(TMath::Abs(pdg) == 11) {\r
2912 return IsMotherEta(imother,mcEvent);\r
2913 }\r
2914 return -1;\r
2915 }\r
2916\r
2917 return -1;\r
2918 \r
2919}\r