1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Authors: Svein Lindal, Daniel Lohner *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
16 ////////////////////////////////////////////////
17 //---------------------------------------------
18 // QA Task for V0 Reader V1
19 //---------------------------------------------
20 ////////////////////////////////////////////////
22 #include "AliAnalysisTaskConversionQA.h"
24 #include "AliAnalysisManager.h"
25 #include "TParticle.h"
27 #include "AliPIDResponse.h"
29 #include "AliESDtrackCuts.h"
30 #include "AliAODMCParticle.h"
31 #include "AliAODMCHeader.h"
38 ClassImp(AliAnalysisTaskConversionQA)
40 //________________________________________________________________________
41 AliAnalysisTaskConversionQA::AliAnalysisTaskConversionQA() : AliAnalysisTaskSE(),
43 fConversionGammas(NULL),
44 fConversionCuts(NULL),
46 fNumberOfESDTracks(0),
52 ffillHistograms(kFALSE),
57 hNGoodESDTracks(NULL),
59 hNContributorsVertex(NULL),
64 hGammaChi2perNDF(NULL),
66 hGammaArmenteros(NULL),
67 hGammaCosinePointingAngle(NULL),
72 hElecNfindableClsTPC(NULL),
73 hPosiNfindableClsTPC(NULL),
77 hElectronITSdEdxP(NULL),
79 hElectronNSigmadEdxP(NULL),
80 hElectronNSigmaPiondEdxP(NULL),
81 hElectronNSigmaITSP(NULL),
82 hElectronNSigmaTOFP(NULL),
84 hPositronITSdEdxP(NULL),
86 hPositronNSigmadEdxP(NULL),
87 hPositronNSigmaPiondEdxP(NULL),
88 hPositronNSigmaITSP(NULL),
89 hPositronNSigmaTOFP(NULL),
92 // hTrueResolutionR(NULL),
93 // hTrueResolutionZ(NULL),
94 // hTrueResolutionPhi(NULL),
95 // hTrueGammaPt(NULL),
96 // hTrueGammaPhi(NULL),
97 // hTrueGammaEta(NULL),
98 // hTrueGammaMass(NULL),
99 // hTrueGammaChi2perNDF(NULL),
100 // hTrueGammaPsiPair(NULL),
101 // hTrueGammaQt(NULL),
102 // hTrueGammaCosinePointingAngle(NULL),
103 // hTrueGammaXY(NULL),
104 // hTrueGammaZR(NULL),
105 // hTrueElecPt(NULL),
106 // hTrueElecEta(NULL),
107 // hTrueElecPhi(NULL),
108 // hTrueElecNfindableClsTPC(NULL),
109 // hTruePosiNfindableClsTPC(NULL),
110 // hTrueElecAsymP(NULL),
119 fnGammaCandidates(1),
126 AliAnalysisTaskConversionQA::AliAnalysisTaskConversionQA(const char *name) : AliAnalysisTaskSE(name),
128 fConversionGammas(NULL),
129 fConversionCuts(NULL),
131 fNumberOfESDTracks(0),
137 ffillHistograms(kFALSE),
142 hNGoodESDTracks(NULL),
144 hNContributorsVertex(NULL),
145 hITSClusterPhi(NULL),
149 hGammaChi2perNDF(NULL),
151 hGammaArmenteros(NULL),
152 hGammaCosinePointingAngle(NULL),
157 hElecNfindableClsTPC(NULL),
158 hPosiNfindableClsTPC(NULL),
161 hElectrondEdxP(NULL),
162 hElectronITSdEdxP(NULL),
164 hElectronNSigmadEdxP(NULL),
165 hElectronNSigmaPiondEdxP(NULL),
166 hElectronNSigmaITSP(NULL),
167 hElectronNSigmaTOFP(NULL),
168 hPositrondEdxP(NULL),
169 hPositronITSdEdxP(NULL),
171 hPositronNSigmadEdxP(NULL),
172 hPositronNSigmaPiondEdxP(NULL),
173 hPositronNSigmaITSP(NULL),
174 hPositronNSigmaTOFP(NULL),
179 // hTrueResolutionR(NULL),
180 // hTrueResolutionZ(NULL),
181 // hTrueResolutionPhi(NULL),
182 // hTrueGammaPt(NULL),
183 // hTrueGammaPhi(NULL),
184 // hTrueGammaEta(NULL),
185 // hTrueGammaMass(NULL),
186 // hTrueGammaChi2perNDF(NULL),
187 // hTrueGammaPsiPair(NULL),
188 // hTrueGammaQt(NULL),
189 // hTrueGammaCosinePointingAngle(NULL),
190 // hTrueGammaXY(NULL),
191 // hTrueGammaZR(NULL),
192 // hTrueElecPt(NULL),
193 // hTrueElecEta(NULL),
194 // hTrueElecPhi(NULL),
195 // hTrueElecNfindableClsTPC(NULL),
196 // hTruePosiNfindableClsTPC(NULL),
197 // hTrueElecAsymP(NULL),
206 fnGammaCandidates(1),
210 // Default constructor
212 DefineInput(0, TChain::Class());
213 DefineOutput(1, TList::Class());
216 //________________________________________________________________________
217 AliAnalysisTaskConversionQA::~AliAnalysisTaskConversionQA()
219 // default deconstructor
222 //________________________________________________________________________
223 void AliAnalysisTaskConversionQA::UserCreateOutputObjects()
225 // Create User Output Objects
227 if(fOutputList != NULL){
231 if(fOutputList == NULL){
232 fOutputList = new TList();
233 fOutputList->SetOwner(kTRUE);
238 fESDList = new TList();
239 fESDList->SetOwner(kTRUE);
240 fESDList->SetName("ESD QA");
241 fOutputList->Add(fESDList);
243 hVertexZ = new TH1F("Vertex_Z","Vertex_Z",300,-15,15);
244 fESDList->Add(hVertexZ);
245 hNContributorsVertex = new TH1I("ContrVertex_Z","ContrVertex_Z",3000,0,3000);
246 fESDList->Add(hNContributorsVertex);
247 if(fIsHeavyIon) hNGoodESDTracks = new TH1I("GoodESDTracks","GoodESDTracks",3000,0,3000);
248 else hNGoodESDTracks = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
249 fESDList->Add(hNGoodESDTracks);
250 if(fIsHeavyIon) hNV0Tracks = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
251 else hNV0Tracks = new TH1I("V0 Multiplicity","V0 Multiplicity",2000,0,2000);
252 fESDList->Add(hNV0Tracks);
254 hITSClusterPhi = new TH2F("ITSClusterPhi","hITSClusterPhi",72,0,2*TMath::Pi(),7,0,7);
255 fESDList->Add(hITSClusterPhi);
256 hGammaPt = new TH1F("Gamma_Pt","Gamma_Pt",250,0,25);
257 fESDList->Add(hGammaPt);
258 hGammaPhi = new TH1F("Gamma_Phi","Gamma_Phi",360,0,2*TMath::Pi());
259 fESDList->Add(hGammaPhi);
260 hGammaEta = new TH1F("Gamma_Eta","Gamma_Eta",600,-1.5,1.5);
261 fESDList->Add(hGammaEta);
262 hGammaChi2perNDF = new TH1F("Gamma_Chi2perNDF","Gamma_Chi2perNDF",500,0,100);
263 fESDList->Add(hGammaChi2perNDF);
264 hGammaPsiPair = new TH1F("Gamma_PsiPair","Gamma_PsiPair",500,0,2);
265 fESDList->Add(hGammaPsiPair);
266 hGammaArmenteros = new TH2F("Gamma_Armenteros","Gamma_Armenteros",200,-1,1,400,0,0.1);
267 fESDList->Add(hGammaArmenteros);
268 hGammaCosinePointingAngle = new TH1F("Gamma_CosinePointingAngle","Gamma_CosinePointingAngle",900,0.7,1.);
269 fESDList->Add(hGammaCosinePointingAngle);
270 hGammaInvMass = new TH1F( "Gamma_InvMass","",200, 0, 0.2);
271 fESDList->Add(hGammaInvMass);
272 hElecPt = new TH2F("Electron_Positron_Pt","Electron_Positron_Pt",250,0,25,250,0,25);
273 fESDList->Add(hElecPt);
274 hElecEta = new TH2F("Electron_Positron_Eta","Electron_Positron_Eta",600,-1.5,1.5,600,-1.5,1.5);
275 fESDList->Add(hElecEta);
276 hElecPhi = new TH2F("Electron_Positron_Phi","Electron_Positron_Phi",360,0,2*TMath::Pi(),360,0,2*TMath::Pi());
277 fESDList->Add(hElecPhi);
278 hElecClsTPC = new TH1F("Electron_ClusterTPC","Electron_ClusterTPC",200,0,200);
279 fESDList->Add(hElecClsTPC);
280 hPosiClsTPC = new TH1F("Positron_ClusterTPC","Positron_ClusterTPC",200,0,200);
281 fESDList->Add(hPosiClsTPC);
283 hElecNfindableClsTPC = new TH1F("Electron_findableClusterTPC","Electron_findableClusterTPC",100,0,1);
284 fESDList->Add(hElecNfindableClsTPC);
285 hPosiNfindableClsTPC = new TH1F("Positron_findableClusterTPC","Positron_findableClusterTPC",100,0,1);
286 fESDList->Add(hPosiNfindableClsTPC);
288 hElectrondEdxP = new TH2F("Electron_dEdx_P","Electron_dEdx_P",100, 0.05, 20, 200, 0, 200);
289 SetLogBinningXTH2(hElectrondEdxP);
290 fESDList->Add(hElectrondEdxP);
291 hPositrondEdxP = new TH2F("Positron_dEdx_P","Positron_dEdx_P",100, 0.05, 20, 200, 0, 200);
292 SetLogBinningXTH2(hPositrondEdxP);
293 fESDList->Add(hPositrondEdxP);
294 hElectronNSigmadEdxP = new TH2F("Electron_NSigmadEdx_P","Electron_NSigmadEdx_P",100, 0.05, 20, 200, -10, 10);
295 SetLogBinningXTH2(hElectronNSigmadEdxP);
296 fESDList->Add(hElectronNSigmadEdxP);
297 hPositronNSigmadEdxP = new TH2F("Positron_NSigmadEdx_P","Positron_NSigmadEdx_P",100, 0.05, 20, 200, -10, 10);
298 SetLogBinningXTH2(hPositronNSigmadEdxP);
299 fESDList->Add(hPositronNSigmadEdxP);
300 hElectronNSigmaPiondEdxP = new TH2F("Electron_NSigmaPiondEdx_P","Electron_NSigmaPiondEdx_P",100, 0.05, 20, 200, -10, 10);
301 SetLogBinningXTH2(hElectronNSigmaPiondEdxP);
302 fESDList->Add(hElectronNSigmaPiondEdxP);
303 hPositronNSigmaPiondEdxP = new TH2F("Positron_NSigmaPiondEdx_P","Positron_NSigmaPiondEdx_P",100, 0.05, 20, 200, -10, 10);
304 SetLogBinningXTH2(hPositronNSigmaPiondEdxP);
305 fESDList->Add(hPositronNSigmaPiondEdxP);
307 hElectronTOFP = new TH2F("Electron_TOF_P","Electron_TOF_P",100, 0.05, 20, 600, -1000, 29000);
308 SetLogBinningXTH2(hElectronTOFP);
309 fESDList->Add(hElectronTOFP);
310 hPositronTOFP = new TH2F("Positron_TOF_P","Positron_TOF_P",100, 0.05, 20, 600, -1000, 29000);
311 SetLogBinningXTH2(hPositronTOFP);
312 fESDList->Add(hPositronTOFP);
313 hElectronNSigmaTOFP = new TH2F("Electron_NSigmaTOF_P","Electron_NSigmaTOF_P",100, 0.05, 20, 200, -10, 10);
314 SetLogBinningXTH2(hElectronNSigmaTOFP);
315 fESDList->Add(hElectronNSigmaTOFP);
316 hPositronNSigmaTOFP = new TH2F("Positron_NSigmaTOF_P","Positron_NSigmaTOF_P",100, 0.05, 20, 200, -10, 10);
317 SetLogBinningXTH2(hPositronNSigmaTOFP);
318 fESDList->Add(hPositronNSigmaTOFP);
320 hElectronITSdEdxP = new TH2F("Electron_ITSdEdx_P","Electron_ITSdEdx_P",100, 0.05, 20, 200, 0, 200);
321 SetLogBinningXTH2(hElectronITSdEdxP);
322 fESDList->Add(hElectronITSdEdxP);
323 hPositronITSdEdxP = new TH2F("Positron_ITSdEdx_P","Positron_ITSdEdx_P",100, 0.05, 20, 200, 0, 200);
324 SetLogBinningXTH2(hPositronITSdEdxP);
325 fESDList->Add(hPositronITSdEdxP);
326 hElectronNSigmaITSP = new TH2F("Electron_NSigmaITS_P","Electron_NSigmaITS_P",100, 0.05, 20, 200, 0, 200);
327 SetLogBinningXTH2(hElectronNSigmaITSP);
328 fESDList->Add(hElectronNSigmaITSP);
329 hPositronNSigmaITSP = new TH2F("Positron_NSigmaITS_P","Positron_NSigmaITS_P",100, 0.05, 20, 200, 0, 200);
330 SetLogBinningXTH2(hPositronNSigmaITSP);
331 fESDList->Add(hPositronNSigmaITSP);
335 // hGammaXY = new TH2F("Gamma_ConversionPoint_XY","Gamma_ConversionPoint_XY",960,-120,120,960,-120,120);
336 // fESDList->Add(hGammaXY);
337 // hGammaZR= new TH2F("Gamma_ConversionPoint_ZR","Gamma_ConversionPoint_ZR",1200,-150,150,480,0,120);
338 // fESDList->Add(hGammaZR);
341 // hElecAsymP = new TH2F("Electron_Asym_vs_P", "Electron_Asym_vs_P",200,0.,20.,200,0.,1.);
342 // fESDList->Add(hElecAsymP);
345 // fTrueList = new TList();
346 // fTrueList->SetOwner(kTRUE);
347 // fTrueList->SetName("True QA");
348 // fOutputList->Add(fTrueList);
350 // hTrueResolutionR = new TH2F("True_ConversionPointResolution_R","True_ConversionPointResolution_R",240,0,120,200,-20,20);
351 // fTrueList->Add(hTrueResolutionR);
352 // hTrueResolutionZ = new TH2F("True_ConversionPointResolution_Z","True_ConversionPointResolution_Z",480,-120,120,200,-20,20);
353 // fTrueList->Add(hTrueResolutionZ);
354 // hTrueResolutionPhi = new TH2F("True_ConversionPointResolution_Phi","True_ConversionPointResolution_Phi",360,0,2*TMath::Pi(),200,-TMath::Pi()/30., TMath::Pi()/30.);
355 // fTrueList->Add(hTrueResolutionPhi);
357 // hTrueGammaPt = new TH1F("True_Gamma_Pt","True_Gamma_Pt",250,0,25);
358 // fTrueList->Add(hTrueGammaPt);
359 // hTrueGammaPhi = new TH1F("True_Gamma_Phi","True_Gamma_Phi",360,0,2*TMath::Pi());
360 // fTrueList->Add(hTrueGammaPhi);
361 // hTrueGammaEta = new TH1F("True_Gamma_Eta","True_Gamma_Eta",600,-1.5,1.5);
362 // fTrueList->Add(hTrueGammaEta);
363 // hTrueGammaMass = new TH1F("True_Gamma_Mass","True_Gamma_Mass",1000,0,0.3);
364 // fTrueList->Add(hTrueGammaMass);
365 // hTrueGammaChi2perNDF = new TH1F("True_Gamma_Chi2perNDF","True_Gamma_Chi2perNDF",500,0,100);
366 // fTrueList->Add(hTrueGammaChi2perNDF);
367 // hTrueGammaPsiPair = new TH1F("True_Gamma_PsiPair","True_Gamma_PsiPair",500,0,2);
368 // fTrueList->Add(hTrueGammaPsiPair);
369 // hTrueGammaQt = new TH1F("True_Gamma_Qt","True_Gamma_Qt",400,0,0.1);
370 // fTrueList->Add(hTrueGammaQt);
371 // hTrueGammaCosinePointingAngle = new TH1F("True_Gamma_CosinePointingAngle","True_Gamma_CosinePointingAngle",900,0.7,1.);
372 // fTrueList->Add(hTrueGammaCosinePointingAngle);
373 // hTrueGammaXY = new TH2F("True_Gamma_ConversionPoint_XY","True_Gamma_ConversionPoint_XY",960,-120,120,960,-120,120);
374 // fTrueList->Add(hTrueGammaXY);
375 // hTrueGammaZR= new TH2F("TrueGamma_ConversionPoint_ZR","TrueGamma_ConversionPoint_ZR",1200,-150,150,480,0,120);
376 // fTrueList->Add(hTrueGammaZR);
378 // hTrueElecPt = new TH2F("True_Electron_Positron_Pt","True_Electron_Positron_Pt",250,0,25,250,0,25);
379 // fTrueList->Add(hTrueElecPt);
380 // hTrueElecEta = new TH2F("True_Electron_Positron_Eta","True_Electron_Positron_Eta",600,-1.5,1.5,600,-1.5,1.5);
381 // fTrueList->Add(hTrueElecEta);
382 // hTrueElecPhi = new TH2F("True_Electron_Positron_Phi","True_Electron_Positron_Phi",360,0,2*TMath::Pi(),360,0,2*TMath::Pi());
383 // fTrueList->Add(hTrueElecPhi);
384 // hTrueElecNfindableClsTPC = new TH1F("True_Electron_findableClusterTPC","True_Electron_findableClusterTPC",100,0,1);
385 // fTrueList->Add(hTrueElecNfindableClsTPC);
386 // hTruePosiNfindableClsTPC = new TH1F("True_Positron_findableClusterTPC","True_Positron_findableClusterTPC",100,0,1);
387 // fTrueList->Add(hTruePosiNfindableClsTPC);
388 // hTrueElecAsymP = new TH2F("True_Electron_Asym_vs_P", "True_Electron_Asym_vs_P",200,0.,20.,200,0.,1.);
389 // fTrueList->Add(hTrueElecAsymP);
391 if(fConversionCuts->GetCutHistograms()){
392 fOutputList->Add(fConversionCuts->GetCutHistograms());
397 fTreeList = new TList();
398 fTreeList->SetOwner(kTRUE);
399 fTreeList->SetName("TreeList");
400 fOutputList->Add(fTreeList);
402 fTreeQA = new TTree("PhotonQA","PhotonQA");
404 fTreeQA->Branch("daughterProp",&fDaughterProp);
405 fTreeQA->Branch("recCords",&fGammaConvCoord);
406 fTreeQA->Branch("photonProp",&fGammaPhotonProp);
407 fTreeQA->Branch("pt",&fGammaPt,"fGammaPt/F");
408 fTreeQA->Branch("theta",&fGammaTheta,"fGammaTheta/F");
409 fTreeQA->Branch("chi2ndf",&fGammaChi2NDF,"fGammaChi2NDF/F");
411 fTreeQA->Branch("kind",&fKind,"fKind/b");
413 fTreeList->Add(fTreeQA);
417 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
419 PostData(1, fOutputList);
421 //_____________________________________________________________________________
422 Bool_t AliAnalysisTaskConversionQA::Notify()
424 if(!fConversionCuts->GetDoEtaShift()) return kTRUE;; // No Eta Shift requested, continue
426 if(fConversionCuts->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
427 fConversionCuts->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
428 fConversionCuts->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
432 printf(" Gamma Conversion QA Task %s :: Eta Shift Manually Set to %f \n\n",
433 (fConversionCuts->GetCutNumber()).Data(),fConversionCuts->GetEtaShift());
434 fConversionCuts->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
439 //________________________________________________________________________
440 void AliAnalysisTaskConversionQA::UserExec(Option_t *){
444 Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
445 if(eventQuality != 0){// Event Not Accepted
448 fInputEvent = InputEvent();
449 if(fIsMC) fMCEvent = MCEvent();
450 if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){ fMCStack = fMCEvent->Stack(); }
452 Int_t eventNotAccepted =
453 fConversionCuts->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
454 if(eventNotAccepted) return; // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
456 fConversionGammas=fV0Reader->GetReconstructedGammas();
459 if(fConversionCuts->GetSignalRejection() != 0){
460 if(fInputEvent->IsA()==AliESDEvent::Class()){
461 fConversionCuts->GetNotRejectedParticles(fConversionCuts->GetSignalRejection(),
462 fConversionCuts->GetAcceptedHeader(),
465 else if(fInputEvent->IsA()==AliAODEvent::Class()){
466 fConversionCuts->GetNotRejectedParticles(fConversionCuts->GetSignalRejection(),
467 fConversionCuts->GetAcceptedHeader(),
475 hVertexZ->Fill(fInputEvent->GetPrimaryVertex()->GetZ());
476 hNContributorsVertex->Fill(fConversionCuts->GetNumberOfContributorsVtx(fInputEvent));
477 hNGoodESDTracks->Fill(fNumberOfESDTracks);
478 hNV0Tracks->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
481 if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class())
482 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
484 for(Int_t firstGammaIndex=0;firstGammaIndex<fConversionGammas->GetEntriesFast();firstGammaIndex++){
485 AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fConversionGammas->At(firstGammaIndex));
486 if (gamma==NULL) continue;
487 if(fMCEvent && fConversionCuts->GetSignalRejection() != 0){
488 if(!fConversionCuts->IsParticleFromBGEvent(gamma->GetMCLabelPositive(), fMCStack, fInputEvent))
490 if(!fConversionCuts->IsParticleFromBGEvent(gamma->GetMCLabelNegative(), fMCStack, fInputEvent))
493 if(!fConversionCuts->PhotonIsSelected(gamma,fInputEvent)){
497 if(ffillTree) ProcessQATree(gamma);
498 if(ffillHistograms) ProcessQA(gamma);
500 if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class())
501 RelabelAODPhotonCandidates(kFALSE); // In case of AODMC relabeling MC
503 PostData(1, fOutputList);
507 ///________________________________________________________________________
508 void AliAnalysisTaskConversionQA::ProcessQATree(AliAODConversionPhoton *gamma){
510 // Fill Histograms for QA and MC
511 AliVEvent* event = (AliVEvent*) InputEvent();
515 AliPIDResponse* pidResonse = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetPIDResponse();
517 fGammaPt = gamma->GetPhotonPt();
519 fGammaTheta = gamma->Theta();
520 fGammaChi2NDF = gamma->GetChi2perNDF();
522 fGammaPhotonProp(0) = gamma->GetArmenterosQt();
523 fGammaPhotonProp(1) = gamma->GetArmenterosAlpha();
524 fGammaPhotonProp(2) = gamma->GetPsiPair();
525 fGammaPhotonProp(3) = fConversionCuts->GetCosineOfPointingAngle(gamma,event);
526 fGammaPhotonProp(4) = gamma->GetMass();
528 fGammaConvCoord(0) = gamma->GetConversionX();
529 fGammaConvCoord(1) = gamma->GetConversionY();
530 fGammaConvCoord(2) = gamma->GetConversionZ();
531 fGammaConvCoord(3) = gamma->GetConversionRadius();
532 fGammaConvCoord(4) = gamma->GetPhotonPhi();
534 AliVTrack * negTrack = fConversionCuts->GetTrack(event, gamma->GetTrackLabelNegative());
535 AliVTrack * posTrack = fConversionCuts->GetTrack(event, gamma->GetTrackLabelPositive());
538 if(!negTrack||!posTrack)return;
541 if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){
542 fKind = IsTruePhotonESD(gamma);
543 } else if (fMCEvent && fInputEvent->IsA()==AliAODEvent::Class()){
544 fKind = IsTruePhotonAOD(gamma);
547 fDaughterProp(0) = posTrack->Pt();
548 fDaughterProp(7) = negTrack->Pt();
549 fDaughterProp(1) = posTrack->Theta();
550 fDaughterProp(8) = negTrack->Theta();
551 // Double32_t signalPos[4] = {0,0,0,0};
553 // Char_t nrowsPos[3];
554 // if (posTrack->GetTPCdEdxInfo()) {
555 // posTrack->GetTPCdEdxInfo()->GetTPCSignalRegionInfo(signalPos,nclPos,nrowsPos);
556 // fDaughterProp(2) = signalPos[0];
557 // fDaughterProp(14) = signalPos[1];
558 // fDaughterProp(16) = signalPos[2];
560 // fDaughterProp(2) = posTrack->GetTPCsignal();
561 // fDaughterProp(14) = 0;
562 // fDaughterProp(16) = 0;
564 // Double32_t signalNeg[4] = {0,0,0,0};
566 // Char_t nrowsNeg[3];
567 // if (negTrack->GetTPCdEdxInfo()) {
568 // negTrack->GetTPCdEdxInfo()->GetTPCSignalRegionInfo(signalNeg,nclNeg,nrowsNeg);
569 // fDaughterProp(9) = signalNeg[0];
570 // fDaughterProp(15) = signalNeg[1];
571 // fDaughterProp(17) = signalNeg[2];
573 // fDaughterProp(9) = negTrack->GetTPCsignal();
574 // fDaughterProp(15) = 0;
575 // fDaughterProp(17) = 0;
578 fDaughterProp(2) = posTrack->GetTPCsignal();
579 fDaughterProp(3) = pidResonse->NumberOfSigmasTPC(posTrack,AliPID::kElectron);
580 fDaughterProp(22) = pidResonse->NumberOfSigmasTPC(posTrack,AliPID::kPion);
581 fDaughterProp(9) = negTrack->GetTPCsignal();
582 fDaughterProp(10) = pidResonse->NumberOfSigmasTPC(negTrack,AliPID::kElectron);
583 fDaughterProp(23) = pidResonse->NumberOfSigmasTPC(negTrack,AliPID::kPion);
584 Int_t nPosClusterITS = 0;
585 Int_t nNegClusterITS = 0;
586 for(Int_t itsLayer = 0; itsLayer<6;itsLayer++){
587 if(TESTBIT(negTrack->GetITSClusterMap(),itsLayer)){
590 if(TESTBIT(posTrack->GetITSClusterMap(),itsLayer)){
596 fDaughterProp(14) = (Float_t)nPosClusterITS;
597 fDaughterProp(15) = (Float_t)nNegClusterITS;
598 if (nPosClusterITS > 0 ){
599 fDaughterProp(16) = posTrack->GetITSsignal();
600 fDaughterProp(20) = pidResonse->NumberOfSigmasITS(posTrack,AliPID::kElectron);
602 fDaughterProp(16) = 1000;
603 fDaughterProp(20) = 20;
605 if (nNegClusterITS > 0 ){
606 fDaughterProp(17) = negTrack->GetITSsignal();
607 fDaughterProp(21) = pidResonse->NumberOfSigmasITS(negTrack,AliPID::kElectron);
609 fDaughterProp(17) = 1000;
610 fDaughterProp(21) = 20;
614 if((posTrack->GetStatus() & AliESDtrack::kTOFpid) && !(posTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
615 Double_t t0pos = pidResonse->GetTOFResponse().GetStartTime(posTrack->P());
616 Double_t timesPos[5];
617 posTrack->GetIntegratedTimes(timesPos);
618 Double_t TOFsignalPos = posTrack->GetTOFsignal();
619 Double_t dTpos = TOFsignalPos - t0pos - timesPos[0];
620 fDaughterProp(4) = dTpos;
621 fDaughterProp(5) = pidResonse->NumberOfSigmasTOF(posTrack, AliPID::kElectron);
623 fDaughterProp(4) = 20000;
624 fDaughterProp(5) = -20;
626 if((negTrack->GetStatus() & AliESDtrack::kTOFpid) && !(negTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
627 Double_t t0neg = pidResonse->GetTOFResponse().GetStartTime(negTrack->P());
628 Double_t timesNeg[5];
629 negTrack->GetIntegratedTimes(timesNeg);
630 Double_t TOFsignalNeg = negTrack->GetTOFsignal();
631 Double_t dTneg = TOFsignalNeg - t0neg - timesNeg[0];
632 fDaughterProp(11) = dTneg;
633 fDaughterProp(12) = pidResonse->NumberOfSigmasTOF(negTrack, AliPID::kElectron);
635 fDaughterProp(11) = 20000;
636 fDaughterProp(12) = -20;
639 fDaughterProp(6) = (Float_t)posTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius()));
640 fDaughterProp(18) = posTrack->GetNcls(1);
641 fDaughterProp(13) = (Float_t)negTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius()));
642 fDaughterProp(19) = negTrack->GetNcls(1);
649 //_____________________________________________________________________________________________________
650 void AliAnalysisTaskConversionQA::ProcessQA(AliAODConversionPhoton *gamma){
652 AliPIDResponse* pidResonse = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetPIDResponse();
654 // Fill Histograms for QA and MC
656 hGammaPt->Fill(gamma->GetPhotonPt());
657 hGammaPhi->Fill(gamma->GetPhotonPhi());
658 hGammaEta->Fill(gamma->Eta());
659 hGammaChi2perNDF->Fill(gamma->GetChi2perNDF());
660 hGammaPsiPair->Fill(gamma->GetPsiPair());
661 hGammaArmenteros->Fill(gamma->GetArmenterosAlpha(),gamma->GetArmenterosQt());
662 hGammaCosinePointingAngle->Fill(fConversionCuts->GetCosineOfPointingAngle(gamma,fInputEvent));
663 hGammaInvMass->Fill(gamma->GetMass());
664 // hGammaXY->Fill(gamma->GetConversionX(),gamma->GetConversionY());
665 // hGammaZR->Fill(gamma->GetConversionZ(),gamma->GetConversionRadius());
667 AliVTrack * negTrack = fConversionCuts->GetTrack(fInputEvent, gamma->GetTrackLabelNegative());
668 AliVTrack * posTrack = fConversionCuts->GetTrack(fInputEvent, gamma->GetTrackLabelPositive());
669 if(!negTrack||!posTrack)return;
672 hElecPt->Fill(negTrack->Pt(),posTrack->Pt());
673 hElecEta->Fill(negTrack->Eta(),posTrack->Eta());
674 hElecPhi->Fill(negTrack->Phi(),posTrack->Phi());
676 hElecNfindableClsTPC->Fill((Float_t)posTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius())));
677 hPosiNfindableClsTPC->Fill((Float_t)negTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius())));
678 hElecClsTPC->Fill(negTrack->GetNcls(1));
679 hPosiClsTPC->Fill(posTrack->GetNcls(1));
681 hElectrondEdxP->Fill(negTrack->P() ,negTrack->GetTPCsignal());
682 hElectronNSigmadEdxP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kElectron));
683 hElectronNSigmaPiondEdxP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kPion));
684 hPositrondEdxP->Fill(posTrack->P() ,posTrack->GetTPCsignal());
685 hPositronNSigmadEdxP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kElectron));
686 hPositronNSigmaPiondEdxP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kPion));
689 if((negTrack->GetStatus() & AliESDtrack::kTOFpid) && !(negTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
690 Double_t t0neg = pidResonse->GetTOFResponse().GetStartTime(negTrack->P());
691 Double_t timesNeg[5];
692 negTrack->GetIntegratedTimes(timesNeg);
693 Double_t TOFsignalNeg = negTrack->GetTOFsignal();
694 Double_t dTneg = TOFsignalNeg - t0neg - timesNeg[0];
695 hElectronTOFP->Fill(negTrack->P() ,dTneg);
696 hElectronNSigmaTOFP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTOF(negTrack, AliPID::kElectron));
698 if((posTrack->GetStatus() & AliESDtrack::kTOFpid) && !(posTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
699 Double_t t0pos = pidResonse->GetTOFResponse().GetStartTime(posTrack->P());
700 Double_t timesPos[5];
701 posTrack->GetIntegratedTimes(timesPos);
702 Double_t TOFsignalPos = posTrack->GetTOFsignal();
703 Double_t dTpos = TOFsignalPos - t0pos - timesPos[0];
704 hPositronTOFP->Fill(posTrack->P() ,dTpos);
705 hPositronNSigmaTOFP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTOF(posTrack, AliPID::kElectron));
708 Int_t nPosClusterITS = 0;
709 Int_t nNegClusterITS = 0;
710 for(Int_t itsLayer = 0; itsLayer<6;itsLayer++){
711 if(TESTBIT(negTrack->GetITSClusterMap(),itsLayer)){
714 if(TESTBIT(posTrack->GetITSClusterMap(),itsLayer)){
718 Double_t negtrackPhi = negTrack->Phi();
719 Double_t postrackPhi = posTrack->Phi();
720 hITSClusterPhi->Fill(negtrackPhi,nNegClusterITS);
721 hITSClusterPhi->Fill(postrackPhi,nPosClusterITS);
724 if (nPosClusterITS > 0 ){
725 hPositronITSdEdxP->Fill(posTrack->P() ,posTrack->GetITSsignal());
726 hPositronNSigmaITSP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasITS(posTrack,AliPID::kElectron));
728 if (nNegClusterITS > 0 ){
729 hElectronITSdEdxP->Fill(negTrack->P() ,negTrack->GetITSsignal());
730 hElectronNSigmaITSP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasITS(negTrack,AliPID::kElectron));
734 // if(gamma->P()!=0){
735 // hElecAsymP->Fill(gamma->P(),negTrack->P()/gamma->P());
737 // hElecNfindableClsTPC->Fill((Float_t)negTrack->GetNcls(1)/(Float_t)negTrack->GetTPCNclsF());
738 // hPosiNfindableClsTPC->Fill((Float_t)posTrack->GetNcls(1)/(Float_t)posTrack->GetTPCNclsF());
739 // if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){
740 // ProcessTrueQAESD(gamma,(AliESDtrack*)negTrack,(AliESDtrack*)posTrack);
741 // } else if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class()){
742 // ProcessTrueQAAOD(gamma,(AliAODTrack*)negTrack,(AliAODTrack*)posTrack);
746 // //________________________________________________________________________
747 // void AliAnalysisTaskConversionQA::ProcessTrueQAESD(AliAODConversionPhoton *TruePhotonCandidate, AliESDtrack *elec, AliESDtrack *posi)
750 // if(IsTruePhotonESD(TruePhotonCandidate)!=0 && IsTruePhotonESD(TruePhotonCandidate)!=5 ) return;
752 // TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
753 // TParticle *mcPhoton = TruePhotonCandidate->GetMCParticle(fMCStack);
755 // hTrueResolutionR->Fill(TruePhotonCandidate->GetConversionRadius(),
756 // TruePhotonCandidate->GetConversionRadius()-negDaughter->R());
757 // hTrueResolutionZ->Fill(TruePhotonCandidate->GetConversionZ(),
758 // TruePhotonCandidate->GetConversionZ()-negDaughter->Vz());
759 // hTrueResolutionPhi->Fill(TruePhotonCandidate->Phi(),
760 // TruePhotonCandidate->Phi()-mcPhoton->Phi());
761 // hTrueGammaPt->Fill(TruePhotonCandidate->Pt());
762 // hTrueGammaPhi->Fill(TruePhotonCandidate->Phi());
763 // hTrueGammaEta->Fill(TruePhotonCandidate->Eta());
764 // hTrueGammaMass->Fill(TruePhotonCandidate->GetMass());
765 // hTrueGammaChi2perNDF->Fill(TruePhotonCandidate->GetChi2perNDF());
766 // hTrueGammaPsiPair->Fill(TruePhotonCandidate->GetPsiPair());
767 // hTrueGammaQt->Fill(TruePhotonCandidate->GetArmenterosQt());
768 // hTrueGammaCosinePointingAngle->Fill(fConversionCuts->GetCosineOfPointingAngle(TruePhotonCandidate,fInputEvent));
769 // hTrueGammaXY->Fill(TruePhotonCandidate->GetConversionX(),TruePhotonCandidate->GetConversionY());
770 // hTrueGammaZR->Fill(TruePhotonCandidate->GetConversionZ(),TruePhotonCandidate->GetConversionRadius());
771 // hTrueElecPt->Fill(elec->Pt(),posi->Pt());
772 // hTrueElecEta->Fill(elec->Eta(),posi->Eta());
773 // hTrueElecPhi->Fill(elec->Phi(),posi->Phi());
774 // hTrueElecNfindableClsTPC
775 // ->Fill((Float_t)elec->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(TruePhotonCandidate->GetConversionRadius())));
776 // hTruePosiNfindableClsTPC
777 // ->Fill((Float_t)posi->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(TruePhotonCandidate->GetConversionRadius())));
778 // if(TruePhotonCandidate->P()!=0){
779 // hTrueElecAsymP->Fill(TruePhotonCandidate->P(),elec->P()/TruePhotonCandidate->P());
782 // hTrueElecNfindableClsTPC->Fill((Float_t)elec->GetNcls(1)/(Float_t)elec->GetTPCNclsF());
783 // hTruePosiNfindableClsTPC->Fill((Float_t)posi->GetNcls(1)/(Float_t)posi->GetTPCNclsF());
786 // //________________________________________________________________________
787 // void AliAnalysisTaskConversionQA::ProcessTrueQAAOD(AliAODConversionPhoton *TruePhotonCandidate, AliAODTrack *elec, AliAODTrack *posi)
790 // if(IsTruePhotonAOD(TruePhotonCandidate)!=0 && IsTruePhotonESD(TruePhotonCandidate)!=5 ) return;
792 // TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
793 // AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
794 // AliAODMCParticle *mcPhoton = (AliAODMCParticle*) AODMCTrackArray->At(negDaughter->GetMother());
796 // hTrueResolutionR->Fill(TruePhotonCandidate->GetConversionRadius(),
797 // TruePhotonCandidate->GetConversionRadius()-(TMath::Sqrt(negDaughter->Xv()*negDaughter->Xv()+negDaughter->Yv()*negDaughter->Yv())));
798 // hTrueResolutionZ->Fill(TruePhotonCandidate->GetConversionZ(),
799 // TruePhotonCandidate->GetConversionZ()-negDaughter->Zv());
800 // hTrueResolutionPhi->Fill(TruePhotonCandidate->Phi(),
801 // TruePhotonCandidate->Phi()-mcPhoton->Phi());
802 // hTrueGammaPt->Fill(TruePhotonCandidate->Pt());
803 // hTrueGammaPhi->Fill(TruePhotonCandidate->Phi());
804 // hTrueGammaEta->Fill(TruePhotonCandidate->Eta());
805 // hTrueGammaMass->Fill(TruePhotonCandidate->GetMass());
806 // hTrueGammaChi2perNDF->Fill(TruePhotonCandidate->GetChi2perNDF());
807 // hTrueGammaPsiPair->Fill(TruePhotonCandidate->GetPsiPair());
808 // hTrueGammaQt->Fill(TruePhotonCandidate->GetArmenterosQt());
809 // hTrueGammaCosinePointingAngle->Fill(fConversionCuts->GetCosineOfPointingAngle(TruePhotonCandidate,fInputEvent));
810 // hTrueGammaXY->Fill(TruePhotonCandidate->GetConversionX(),TruePhotonCandidate->GetConversionY());
811 // hTrueGammaZR->Fill(TruePhotonCandidate->GetConversionZ(),TruePhotonCandidate->GetConversionRadius());
812 // hTrueElecPt->Fill(elec->Pt(),posi->Pt());
813 // hTrueElecEta->Fill(elec->Eta(),posi->Eta());
814 // hTrueElecPhi->Fill(elec->Phi(),posi->Phi());
815 // hTrueElecNfindableClsTPC
816 // ->Fill((Float_t)elec->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(TruePhotonCandidate->GetConversionRadius())));
817 // hTruePosiNfindableClsTPC
818 // ->Fill((Float_t)posi->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(TruePhotonCandidate->GetConversionRadius())));
819 // hTrueElecNfindableClsTPC->Fill((Float_t)elec->GetNcls(1)/(Float_t)elec->GetTPCNclsF());
820 // hTruePosiNfindableClsTPC->Fill((Float_t)posi->GetNcls(1)/(Float_t)posi->GetTPCNclsF());
823 //________________________________________________________________________
824 void AliAnalysisTaskConversionQA::CountTracks(){
826 if(fInputEvent->IsA()==AliESDEvent::Class()){
827 // Using standard function for setting Cuts
828 Bool_t selectPrimaries=kTRUE;
829 AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
830 EsdTrackCuts->SetMaxDCAToVertexZ(2);
831 EsdTrackCuts->SetEtaRange(-0.8, 0.8);
832 EsdTrackCuts->SetPtRange(0.15);
833 fNumberOfESDTracks = 0;
834 for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
835 AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
836 if(!curTrack) continue;
837 // if(fMCEvent && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
838 // if(!((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack)) continue;
840 if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTracks++;
845 else if(fInputEvent->IsA()==AliAODEvent::Class()){
846 fNumberOfESDTracks = 0;
847 for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
848 AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
849 if(!curTrack->IsPrimaryCandidate()) continue;
850 if(abs(curTrack->Eta())>0.8) continue;
851 if(curTrack->Pt()<0.15) continue;
852 if(abs(curTrack->ZAtDCA())>2) continue;
853 fNumberOfESDTracks++;
859 //________________________________________________________________________
861 Bool_t AliAnalysisTaskConversionQA::IsTruePhotonESD(AliAODConversionPhoton *TruePhotonCandidate)
863 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
864 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
866 if(posDaughter == NULL || negDaughter == NULL) return kFALSE; // One particle does not exist
867 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
868 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)) return kFALSE;
869 else if(posDaughter->GetMother(0) == -1) return kFALSE;
871 if(pdgCode[0]!=11 || pdgCode[1]!=11) return kFALSE; //One Particle is not electron
872 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return kFALSE; // Same Charge
873 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return kFALSE;// check if the daughters come from a conversion
875 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
876 if(Photon->GetPdgCode() != 22) return kFALSE; // Mother is no Photon
881 UInt_t AliAnalysisTaskConversionQA::IsTruePhotonESD(AliAODConversionPhoton *TruePhotonCandidate)
886 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
887 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
888 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
889 Int_t motherLabelPhoton;
890 Int_t pdgCodePos = 0;
891 Int_t pdgCodeNeg = 0;
895 if(posDaughter == NULL || negDaughter == NULL) {
897 // return kFALSE; // One particle does not exist
899 } else if( posDaughter->GetMother(0) != negDaughter->GetMother(0) || (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) {
902 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
903 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
904 if(pdgCodePos==11 && pdgCodeNeg==11) return 10; //Electron Combinatorial
905 if(pdgCodePos==11 && pdgCodeNeg==11 &&
906 (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) return 15; //direct Electron Combinatorial
908 if(pdgCodePos==211 && pdgCodeNeg==211) return 11; //Pion Combinatorial
909 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211)) return 12; //Pion, Proton Combinatorics
910 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) return 13; //Pion, Electron Combinatorics
911 if(pdgCodePos==321 || pdgCodeNeg==321) return 14; //Kaon combinatorics
914 pdgCodePos=posDaughter->GetPdgCode();
915 pdgCodeNeg=negDaughter->GetPdgCode();
916 motherLabelPhoton= Photon->GetMother(0);
917 if ( TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode()) pdgCode = TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode();
919 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) return 2; // true from hadronic decays
920 else if ( !(pdgCodeNeg==pdgCodePos)){
921 if(pdgCode == 111) return 3; // pi0 Dalitz
922 else if (pdgCode == 221) return 4; // eta Dalitz
923 else if (!(negDaughter->GetUniqueID() != 5 || posDaughter->GetUniqueID() !=5)){
924 if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
925 return 0; // primary photons
926 } else if (pdgCode == 22){
927 return 5; //secondary photons
936 //________________________________________________________________________
937 UInt_t AliAnalysisTaskConversionQA::IsTruePhotonAOD(AliAODConversionPhoton *TruePhotonCandidate)
942 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
943 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
944 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
945 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
946 Int_t motherLabelPhoton = Photon->GetMother();
947 Int_t pdgCodePos = 0;
948 Int_t pdgCodeNeg = 0;
951 if(posDaughter == NULL || negDaughter == NULL) {
953 // return kFALSE; // One particle does not exist
955 } else if( posDaughter->GetMother() != negDaughter->GetMother() || (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1)) {
958 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
959 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
960 if(pdgCodePos==11 && pdgCodeNeg==11) kind = 10; //Electron Combinatorial
961 if(pdgCodePos==11 && pdgCodeNeg==11 &&
962 (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1))kind = 15; //direct Electron Combinatorial
964 if(pdgCodePos==211 && pdgCodeNeg==211) kind = 11; //Pion Combinatorial
965 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211)) kind = 12; //Pion, Proton Combinatorics
966 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) kind = 13; //Pion, Electron Combinatorics
967 if(pdgCodePos==321 || pdgCodeNeg==321) kind = 14; //Kaon combinatorics
970 pdgCodePos=posDaughter->GetPdgCode();
971 pdgCodeNeg=negDaughter->GetPdgCode();
973 if ( TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode())
974 pdgCode = TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode();
975 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) kind = 2; // true from hadronic decays
976 else if ( !(pdgCodeNeg==pdgCodePos)){
977 if(pdgCode == 111) kind = 3; // pi0 Dalitz
978 else if (pdgCode == 221) kind = 4; // eta Dalitz
979 else if (!(negDaughter->GetMCProcessCode() != 5 || posDaughter->GetMCProcessCode() !=5)){
980 if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
981 kind = 0; // primary photons
982 } else if (pdgCode == 22){
983 kind = 5; //secondary photons
995 //________________________________________________________________________
996 void AliAnalysisTaskConversionQA::RelabelAODPhotonCandidates(Bool_t mode){
998 // Relabeling For AOD Event
1000 // MCLabel -> AODMCLabel
1003 fMCStackPos = new Int_t[fConversionGammas->GetEntries()];
1004 fMCStackNeg = new Int_t[fConversionGammas->GetEntries()];
1007 for(Int_t iGamma = 0;iGamma<fConversionGammas->GetEntries();iGamma++){
1008 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fConversionGammas->At(iGamma);
1009 if(!PhotonCandidate) continue;
1010 if(!mode){// Back to ESD Labels
1011 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
1012 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
1013 //PhotonCandidate->IsAODMCLabel(kFALSE);
1016 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
1017 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
1019 Bool_t AODLabelPos = kFALSE;
1020 Bool_t AODLabelNeg = kFALSE;
1022 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
1023 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
1025 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
1026 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
1027 AODLabelPos = kTRUE;
1031 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
1032 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
1033 AODLabelNeg = kTRUE;
1036 if(AODLabelNeg && AODLabelPos){
1039 } // Both ESD Tracks have AOD Tracks with Positive IDs
1040 if(!AODLabelPos || !AODLabelNeg){
1041 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
1042 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
1043 if(tempDaughter->GetID()<0){
1045 if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelPositive()){
1046 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
1047 AODLabelPos = kTRUE;
1051 if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelNegative()){
1052 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
1053 AODLabelNeg = kTRUE;
1057 if(AODLabelNeg && AODLabelPos){
1061 if(!AODLabelPos || !AODLabelNeg){
1062 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
1068 delete[] fMCStackPos;
1069 delete[] fMCStackNeg;
1073 void AliAnalysisTaskConversionQA::SetLogBinningXTH2(TH2* histoRebin){
1074 TAxis *axisafter = histoRebin->GetXaxis();
1075 Int_t bins = axisafter->GetNbins();
1076 Double_t from = axisafter->GetXmin();
1077 Double_t to = axisafter->GetXmax();
1078 Double_t *newbins = new Double_t[bins+1];
1080 Double_t factor = TMath::Power(to/from, 1./bins);
1081 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
1082 axisafter->Set(bins, newbins);
1087 //________________________________________________________________________
1088 void AliAnalysisTaskConversionQA::Terminate(Option_t *)