1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: Martin Wilde, Daniel Lohner, Friederike Bock *
7 * based on: on older version (see aliroot up to v5-04-42-AN) *
8 * AliAnalysisTaskGammaConversion.cxx *
9 * Authors: Kathrin Koch, Kenneth Aamodt, Ana Marin *
11 * Permission to use, copy, modify and distribute this software and its *
12 * documentation strictly for non-commercial purposes is hereby granted *
13 * without fee, provided that the above copyright notice appears in all *
14 * copies and that both the copyright notice and this permission notice *
15 * appear in the supporting documentation. The authors make no claims *
16 * about the suitability of this software for any purpose. It is *
17 * provided "as is" without express or implied warranty. *
18 **************************************************************************/
20 ////////////////////////////////////////////////
21 //---------------------------------------------
23 // Class used to do analysis on conversion pairs
24 //---------------------------------------------
25 ///////////////////////////////////////////////
33 #include "THnSparse.h"
36 #include "AliAnalysisTask.h"
37 #include "AliAnalysisManager.h"
38 #include "AliESDEvent.h"
39 #include "AliESDInputHandler.h"
40 #include "AliMCEventHandler.h"
41 #include "AliMCEvent.h"
42 #include "AliMCParticle.h"
43 #include "AliCentrality.h"
44 #include "AliESDVZERO.h"
45 #include "AliESDpid.h"
46 #include "AliAnalysisTaskGammaConvV1.h"
47 #include "AliVParticle.h"
48 #include "AliESDtrack.h"
49 #include "AliESDtrackCuts.h"
50 #include "AliKFVertex.h"
51 #include "AliV0ReaderV1.h"
52 #include "AliGenCocktailEventHeader.h"
53 #include "AliConversionAODBGHandlerRP.h"
54 #include "AliAODMCParticle.h"
55 #include "AliAODMCHeader.h"
56 #include "AliEventplane.h"
58 ClassImp(AliAnalysisTaskGammaConvV1)
60 //________________________________________________________________________
61 AliAnalysisTaskGammaConvV1::AliAnalysisTaskGammaConvV1(): AliAnalysisTaskSE(),
76 fHeaderNameList(NULL),
79 fGammaCandidates(NULL),
81 fConversionCuts(NULL),
84 hESDConvGammaPt(NULL),
86 hESDConvGammaEta(NULL),
87 tESDConvGammaPtDcazCat(NULL),
94 hESDMotherInvMassPt(NULL),
95 sESDMotherInvMassPtZM(NULL),
96 hESDMotherBackInvMassPt(NULL),
97 sESDMotherBackInvMassPtZM(NULL),
98 hESDMotherInvMassEalpha(NULL),
99 hESDMotherPi0PtY(NULL),
100 hESDMotherEtaPtY(NULL),
101 hESDMotherPi0PtAlpha(NULL),
102 hESDMotherEtaPtAlpha(NULL),
103 hESDMotherPi0YEtaLowPtGamma(NULL),
104 hESDMotherPi0YEtaHighPtGamma(NULL),
105 hESDMotherEtaYEtaLowPtGamma(NULL),
106 hESDMotherEtaYEtaHighPtGamma(NULL),
109 hMCDecayGammaPi0Pt(NULL),
110 hMCDecayGammaRhoPt(NULL),
111 hMCDecayGammaEtaPt(NULL),
112 hMCDecayGammaOmegaPt(NULL),
113 hMCDecayGammaEtapPt(NULL),
114 hMCDecayGammaPhiPt(NULL),
115 hMCDecayGammaSigmaPt(NULL),
116 hMCConvGammaPt(NULL),
118 hMCConvGammaEta(NULL),
120 hMCPi0WOWeightPt(NULL),
127 hMCK0sWOWeightPt(NULL),
129 hESDTrueMotherInvMassPt(NULL),
130 hESDTruePrimaryMotherInvMassPt(NULL),
131 hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
132 pESDTruePrimaryMotherWeightsInvMassPt(NULL),
133 hESDTruePrimaryPi0MCPtResolPt(NULL),
134 hESDTruePrimaryEtaMCPtResolPt(NULL),
135 hESDTrueSecondaryMotherInvMassPt(NULL),
136 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
137 hESDTrueK0sWithPi0DaughterMCPt(NULL),
138 hESDTrueSecondaryMotherFromEtaInvMassPt(NULL),
139 hESDTrueEtaWithPi0DaughterMCPt(NULL),
140 hESDTrueBckGGInvMassPt(NULL),
141 hESDTrueBckContInvMassPt(NULL),
142 hESDTruePi0PtY(NULL),
143 hESDTrueEtaPtY(NULL),
144 hESDTruePi0PtAlpha(NULL),
145 hESDTrueEtaPtAlpha(NULL),
146 hESDTruePi0YEtaLowPtGamma(NULL),
147 hESDTruePi0YEtaHighPtGamma(NULL),
148 hESDTrueEtaYEtaLowPtGamma(NULL),
149 hESDTrueEtaYEtaHighPtGamma(NULL),
150 hESDTrueMotherDalitzInvMassPt(NULL),
151 hESDTrueConvGammaPt(NULL),
152 hESDCombinatorialPt(NULL),
153 hESDTruePrimaryConvGammaPt(NULL),
154 hESDTruePrimaryConvGammaESDPtMCPt(NULL),
155 hESDTrueSecondaryConvGammaPt(NULL),
156 hESDTrueSecondaryConvGammaFromXFromK0sPt(NULL),
157 hESDTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
158 hESDTrueDalitzPsiPairDeltaPhi(NULL),
159 hESDTrueGammaPsiPairDeltaPhi(NULL),
161 hNGoodESDTracks(NULL),
162 hNGammaCandidates(NULL),
165 tESDMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
172 fEventPlaneAngle(-100),
174 fnGammaCandidates(0),
185 fMoveParticleAccordingToVertex(kTRUE),
187 fDoMesonAnalysis(kTRUE),
190 fIsFromMBHeader(kTRUE),
196 //________________________________________________________________________
197 AliAnalysisTaskGammaConvV1::AliAnalysisTaskGammaConvV1(const char *name):
198 AliAnalysisTaskSE(name),
209 fPhotonDCAList(NULL),
213 fHeaderNameList(NULL),
216 fGammaCandidates(NULL),
218 fConversionCuts(NULL),
219 fMesonCutArray(NULL),
221 hESDConvGammaPt(NULL),
222 hESDConvGammaR(NULL),
223 hESDConvGammaEta(NULL),
224 tESDConvGammaPtDcazCat(NULL),
231 hESDMotherInvMassPt(NULL),
232 sESDMotherInvMassPtZM(NULL),
233 hESDMotherBackInvMassPt(NULL),
234 sESDMotherBackInvMassPtZM(NULL),
235 hESDMotherInvMassEalpha(NULL),
236 hESDMotherPi0PtY(NULL),
237 hESDMotherEtaPtY(NULL),
238 hESDMotherPi0PtAlpha(NULL),
239 hESDMotherEtaPtAlpha(NULL),
240 hESDMotherPi0YEtaLowPtGamma(NULL),
241 hESDMotherPi0YEtaHighPtGamma(NULL),
242 hESDMotherEtaYEtaLowPtGamma(NULL),
243 hESDMotherEtaYEtaHighPtGamma(NULL),
246 hMCDecayGammaPi0Pt(NULL),
247 hMCDecayGammaRhoPt(NULL),
248 hMCDecayGammaEtaPt(NULL),
249 hMCDecayGammaOmegaPt(NULL),
250 hMCDecayGammaEtapPt(NULL),
251 hMCDecayGammaPhiPt(NULL),
252 hMCDecayGammaSigmaPt(NULL),
253 hMCConvGammaPt(NULL),
255 hMCConvGammaEta(NULL),
257 hMCPi0WOWeightPt(NULL),
264 hMCK0sWOWeightPt(NULL),
266 hESDTrueMotherInvMassPt(NULL),
267 hESDTruePrimaryMotherInvMassPt(NULL),
268 hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
269 pESDTruePrimaryMotherWeightsInvMassPt(NULL),
270 hESDTruePrimaryPi0MCPtResolPt(NULL),
271 hESDTruePrimaryEtaMCPtResolPt(NULL),
272 hESDTrueSecondaryMotherInvMassPt(NULL),
273 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
274 hESDTrueK0sWithPi0DaughterMCPt(NULL),
275 hESDTrueSecondaryMotherFromEtaInvMassPt(NULL),
276 hESDTrueEtaWithPi0DaughterMCPt(NULL),
277 hESDTrueBckGGInvMassPt(NULL),
278 hESDTrueBckContInvMassPt(NULL),
279 hESDTruePi0PtY(NULL),
280 hESDTrueEtaPtY(NULL),
281 hESDTruePi0PtAlpha(NULL),
282 hESDTrueEtaPtAlpha(NULL),
283 hESDTruePi0YEtaLowPtGamma(NULL),
284 hESDTruePi0YEtaHighPtGamma(NULL),
285 hESDTrueEtaYEtaLowPtGamma(NULL),
286 hESDTrueEtaYEtaHighPtGamma(NULL),
287 hESDTrueMotherDalitzInvMassPt(NULL),
288 hESDTrueConvGammaPt(NULL),
289 hESDCombinatorialPt(NULL),
290 hESDTruePrimaryConvGammaPt(NULL),
291 hESDTruePrimaryConvGammaESDPtMCPt(NULL),
292 hESDTrueSecondaryConvGammaPt(NULL),
293 hESDTrueSecondaryConvGammaFromXFromK0sPt(NULL),
294 hESDTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
295 hESDTrueDalitzPsiPairDeltaPhi(NULL),
296 hESDTrueGammaPsiPairDeltaPhi(NULL),
298 hNGoodESDTracks(NULL),
299 hNGammaCandidates(NULL),
302 tESDMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
309 fEventPlaneAngle(-100),
311 fnGammaCandidates(0),
322 fMoveParticleAccordingToVertex(kTRUE),
324 fDoMesonAnalysis(kTRUE),
327 fIsFromMBHeader(kTRUE),
330 // Define output slots here
331 DefineOutput(1, TList::Class());
334 AliAnalysisTaskGammaConvV1::~AliAnalysisTaskGammaConvV1()
336 if(fGammaCandidates){
337 delete fGammaCandidates;
338 fGammaCandidates = 0x0;
345 delete[] fBGHandlerRP;
349 //___________________________________________________________
350 void AliAnalysisTaskGammaConvV1::InitBack(){
352 const Int_t nDim = 4;
353 Int_t nBins[nDim] = {800,250,7,4};
354 Double_t xMin[nDim] = {0,0, 0,0};
355 Double_t xMax[nDim] = {0.8,25,7,4};
357 sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
358 sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
360 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
361 fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
362 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
363 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
364 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
365 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
367 Int_t collisionSystem = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(0,1));
368 Int_t centMin = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(1,1));
369 Int_t centMax = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(2,1));
371 if(collisionSystem == 1 || collisionSystem == 2 ||
372 collisionSystem == 5 || collisionSystem == 8 ||
373 collisionSystem == 9){
374 centMin = centMin*10;
375 centMax = centMax*10;
376 if(centMax ==0 && centMax!=centMin) centMax=100;
378 else if(collisionSystem == 3 || collisionSystem == 6){
382 else if(collisionSystem == 4 || collisionSystem == 7){
383 centMin = ((centMin*5)+45);
384 centMax = ((centMax*5)+45);
387 fBackList[iCut] = new TList();
388 fBackList[iCut]->SetName(Form("%s_%s Back histograms",cutstring.Data(),cutstringMeson.Data()));
389 fBackList[iCut]->SetOwner(kTRUE);
390 fCutFolder[iCut]->Add(fBackList[iCut]);
392 sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
393 fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
395 fMotherList[iCut] = new TList();
396 fMotherList[iCut]->SetName(Form("%s_%s Mother histograms",cutstring.Data(),cutstringMeson.Data()));
397 fMotherList[iCut]->SetOwner(kTRUE);
398 fCutFolder[iCut]->Add(fMotherList[iCut]);
400 sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
401 fMotherList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
403 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
404 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
405 collisionSystem,centMin,centMax,
406 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
407 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity());
408 fBGHandlerRP[iCut] = NULL;
411 fBGHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
412 ((AliConversionCuts*)fCutArray->At(fiCut))->IsHeavyIon(),
413 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
414 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
415 fBGHandler[iCut] = NULL;
420 //________________________________________________________________________
421 void AliAnalysisTaskGammaConvV1::UserCreateOutputObjects()
425 if(fOutputContainer != NULL){
426 delete fOutputContainer;
427 fOutputContainer = NULL;
429 if(fOutputContainer == NULL){
430 fOutputContainer = new TList();
431 fOutputContainer->SetOwner(kTRUE);
434 // Array of current cut's gammas
435 fGammaCandidates = new TList();
437 fCutFolder = new TList*[fnCuts];
438 fESDList = new TList*[fnCuts];
439 fBackList = new TList*[fnCuts];
440 fMotherList = new TList*[fnCuts];
441 hNEvents = new TH1I*[fnCuts];
442 hNGoodESDTracks = new TH1I*[fnCuts];
443 hNGammaCandidates = new TH1I*[fnCuts];
444 hNV0Tracks = new TH1I*[fnCuts];
445 hEtaShift = new TProfile*[fnCuts];
446 hESDConvGammaPt = new TH1F*[fnCuts];
448 if (fDoPhotonQA == 2){
449 fPhotonDCAList = new TList*[fnCuts];
450 tESDConvGammaPtDcazCat = new TTree*[fnCuts];
452 if (fDoPhotonQA > 0){
453 hESDConvGammaR = new TH1F*[fnCuts];
454 hESDConvGammaEta = new TH1F*[fnCuts];
457 if(fDoMesonAnalysis){
458 hESDMotherInvMassPt = new TH2F*[fnCuts];
459 hESDMotherBackInvMassPt = new TH2F*[fnCuts];
460 hESDMotherInvMassEalpha = new TH2F*[fnCuts];
461 if (fDoMesonQA == 2){
462 fMesonDCAList = new TList*[fnCuts];
463 tESDMesonsInvMassPtDcazMinDcazMaxFlag = new TTree*[fnCuts];
466 hESDMotherPi0PtY = new TH2F*[fnCuts];
467 hESDMotherEtaPtY = new TH2F*[fnCuts];
468 hESDMotherPi0PtAlpha = new TH2F*[fnCuts];
469 hESDMotherEtaPtAlpha = new TH2F*[fnCuts];
470 hESDMotherPi0YEtaLowPtGamma = new TH2F*[fnCuts];
471 hESDMotherPi0YEtaHighPtGamma = new TH2F*[fnCuts];
472 hESDMotherEtaYEtaLowPtGamma = new TH2F*[fnCuts];
473 hESDMotherEtaYEtaHighPtGamma = new TH2F*[fnCuts];
477 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
479 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
480 TString cutstringMeson = "NoMesonCut";
481 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
483 fCutFolder[iCut] = new TList();
484 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s",cutstring.Data(),cutstringMeson.Data()));
485 fCutFolder[iCut]->SetOwner(kTRUE);
486 fOutputContainer->Add(fCutFolder[iCut]);
487 fESDList[iCut] = new TList();
488 fESDList[iCut]->SetName(Form("%s_%s ESD histograms",cutstring.Data(),cutstringMeson.Data()));
489 fESDList[iCut]->SetOwner(kTRUE);
490 fCutFolder[iCut]->Add(fESDList[iCut]);
492 hNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
493 hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
494 hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
495 hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
496 if (((AliConversionCuts*)fCutArray->At(iCut))->IsSpecialTrigger() == 4 ){
497 TString TriggerNames = "Not Trigger: ";
498 TriggerNames = TriggerNames+ ( (AliConversionCuts*)fCutArray->At(iCut))->GetSpecialTriggerName();
499 hNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
501 hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
503 hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
504 hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
505 hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
506 hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
507 hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
508 fESDList[iCut]->Add(hNEvents[iCut]);
509 if(fIsHeavyIon) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
510 else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
511 fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
512 if(fIsHeavyIon) hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
513 else hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
514 fESDList[iCut]->Add(hNGammaCandidates[iCut]);
515 if(fIsHeavyIon) hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
516 else hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2000,0,2000);
517 fESDList[iCut]->Add(hNV0Tracks[iCut]);
518 hEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
519 fESDList[iCut]->Add(hEtaShift[iCut]);
520 hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
521 fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
523 if (fDoPhotonQA == 2){
524 fPhotonDCAList[iCut] = new TList();
525 fPhotonDCAList[iCut]->SetName(Form("%s_%s Photon DCA tree",cutstring.Data(),cutstringMeson.Data()));
526 fPhotonDCAList[iCut]->SetOwner(kTRUE);
527 fCutFolder[iCut]->Add(fPhotonDCAList[iCut]);
529 tESDConvGammaPtDcazCat[iCut] = new TTree("ESD_ConvGamma_Pt_Dcaz_R_Eta","ESD_ConvGamma_Pt_Dcaz_R_Eta_Cat");
530 tESDConvGammaPtDcazCat[iCut]->Branch("Pt",&fPtGamma,"fPtGamma/F");
531 tESDConvGammaPtDcazCat[iCut]->Branch("DcaZPhoton",&fDCAzPhoton,"fDCAzPhoton/F");
532 // tESDConvGammaPtDcazCat[iCut]->Branch("R",&fRConvPhoton,"fRConvPhoton/F");
533 // tESDConvGammaPtDcazCat[iCut]->Branch("Eta",&fEtaPhoton,"fEtaPhoton/F");
535 tESDConvGammaPtDcazCat[iCut]->Branch("cat",&iCatPhoton,"iCatPhoton/b");
537 tESDConvGammaPtDcazCat[iCut]->Branch("photonMCInfo",&iPhotonMCInfo,"iPhotonMCInfo/b");
539 fPhotonDCAList[iCut]->Add(tESDConvGammaPtDcazCat[iCut]);
542 if (fDoPhotonQA > 0){
543 hESDConvGammaR[iCut] = new TH1F("ESD_ConvGamma_R","ESD_ConvGamma_R",800,0,200);
544 fESDList[iCut]->Add(hESDConvGammaR[iCut]);
545 hESDConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",2000,-2,2);
546 fESDList[iCut]->Add(hESDConvGammaEta[iCut]);
549 if(fDoMesonAnalysis){
550 hESDMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
551 fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
552 hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
553 fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
554 hESDMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
555 fESDList[iCut]->Add(hESDMotherInvMassEalpha[iCut]);
556 if (fDoMesonQA == 2){
557 fMesonDCAList[iCut] = new TList();
558 fMesonDCAList[iCut]->SetName(Form("%s_%s Meson DCA tree",cutstring.Data(),cutstringMeson.Data()));
559 fMesonDCAList[iCut]->SetOwner(kTRUE);
560 fCutFolder[iCut]->Add(fMesonDCAList[iCut]);
562 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut] = new TTree("ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag","ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag");
563 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("InvMass",&fInvMass,"fInvMass/F");
564 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("Pt",&fPt,"fPt/F");
565 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMin",&fDCAzGammaMin,"fDCAzGammaMin/F");
566 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMax",&fDCAzGammaMax,"fDCAzGammaMax/F");
567 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("kind",&iFlag,"iFlag/b");
569 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("mesonMCInfo",&iMesonMCInfo,"iMesonMCInfo/b");
571 fMesonDCAList[iCut]->Add(tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]);
574 if (fDoMesonQA > 0 ){
575 hESDMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",250,0.03,25.,150,-1.5,1.5);
576 SetLogBinningXTH2(hESDMotherPi0PtY[iCut]);
577 fESDList[iCut]->Add(hESDMotherPi0PtY[iCut]);
578 hESDMotherEtaPtY[iCut] = new TH2F("ESD_MotherEta_Pt_Y","ESD_MotherEta_Pt_Y",250,0.03,25.,150,-1.5,1.5);
579 SetLogBinningXTH2(hESDMotherEtaPtY[iCut]);
580 fESDList[iCut]->Add(hESDMotherEtaPtY[iCut]);
581 hESDMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",250,0.03,25.,100,0,1);
582 SetLogBinningXTH2(hESDMotherPi0PtAlpha[iCut]);
583 fESDList[iCut]->Add(hESDMotherPi0PtAlpha[iCut]);
584 hESDMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",250,0.03,25.,100,0,1);
585 SetLogBinningXTH2(hESDMotherEtaPtAlpha[iCut]);
586 fESDList[iCut]->Add(hESDMotherEtaPtAlpha[iCut]);
587 hESDMotherPi0YEtaLowPtGamma[iCut] = new TH2F("ESD_MotherPi0_Y_EtaLowPtGamma","ESD_MotherPi0_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
588 fESDList[iCut]->Add(hESDMotherPi0YEtaLowPtGamma[iCut]);
589 hESDMotherPi0YEtaHighPtGamma[iCut] = new TH2F("ESD_MotherPi0_Y_EtaHighPtGamma","ESD_MotherPi0_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
590 fESDList[iCut]->Add(hESDMotherPi0YEtaHighPtGamma[iCut]);
591 hESDMotherEtaYEtaLowPtGamma[iCut] = new TH2F("ESD_MotherEta_Y_EtaLowPtGamma","ESD_MotherEta_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
592 fESDList[iCut]->Add(hESDMotherEtaYEtaLowPtGamma[iCut]);
593 hESDMotherEtaYEtaHighPtGamma[iCut] = new TH2F("ESD_MotherEta_Y_EtaHighPtGamma","ESD_MotherEta_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
594 fESDList[iCut]->Add(hESDMotherEtaYEtaHighPtGamma[iCut]);
602 if(fDoMesonAnalysis){
603 InitBack(); // Init Background Handler
608 fMCList = new TList*[fnCuts];
610 fTrueList = new TList*[fnCuts];
611 // Selected Header List
612 fHeaderNameList = new TList*[fnCuts];
613 hMCHeaders = new TH1I*[fnCuts];
614 hMCAllGammaPt = new TH1F*[fnCuts];
615 hMCDecayGammaPi0Pt = new TH1F*[fnCuts];
616 hMCDecayGammaRhoPt = new TH1F*[fnCuts];
617 hMCDecayGammaEtaPt = new TH1F*[fnCuts];
618 hMCDecayGammaOmegaPt = new TH1F*[fnCuts];
619 hMCDecayGammaEtapPt = new TH1F*[fnCuts];
620 hMCDecayGammaPhiPt = new TH1F*[fnCuts];
621 hMCDecayGammaSigmaPt = new TH1F*[fnCuts];
622 hMCConvGammaPt = new TH1F*[fnCuts];
623 hESDTrueConvGammaPt = new TH1F*[fnCuts];
625 hESDCombinatorialPt = new TH2F*[fnCuts];
626 hESDTruePrimaryConvGammaPt = new TH1F*[fnCuts];
627 hESDTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
628 hESDTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
629 hESDTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
630 hESDTrueSecondaryConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
632 hESDTrueDalitzPsiPairDeltaPhi= new TH2F*[fnCuts];
633 hESDTrueGammaPsiPairDeltaPhi= new TH2F*[fnCuts];
635 if (fDoPhotonQA > 0){
636 hMCConvGammaR = new TH1F*[fnCuts];
637 hMCConvGammaEta = new TH1F*[fnCuts];
640 if(fDoMesonAnalysis){
641 hMCPi0Pt = new TH1F*[fnCuts];
642 hMCPi0WOWeightPt = new TH1F*[fnCuts];
643 hMCEtaPt = new TH1F*[fnCuts];
644 hMCPi0InAccPt = new TH1F*[fnCuts];
645 hMCEtaInAccPt = new TH1F*[fnCuts];
647 hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
648 hESDTruePrimaryMotherInvMassPt = new TH2F*[fnCuts];
649 hESDTruePrimaryMotherW0WeightingInvMassPt = new TH2F*[fnCuts];
650 pESDTruePrimaryMotherWeightsInvMassPt = new TProfile2D*[fnCuts];
651 hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
652 hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
653 hESDTrueSecondaryMotherFromEtaInvMassPt = new TH2F*[fnCuts];
654 hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
656 hMCPi0PtY = new TH2F*[fnCuts];
657 hMCEtaPtY = new TH2F*[fnCuts];
658 hMCK0sPt = new TH1F*[fnCuts];
659 hMCK0sWOWeightPt = new TH1F*[fnCuts];
660 hMCK0sPtY = new TH2F*[fnCuts];
661 hESDTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
662 hESDTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
663 hESDTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
664 hESDTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
665 hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
666 hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
667 hESDTruePi0PtY = new TH2F*[fnCuts];
668 hESDTrueEtaPtY = new TH2F*[fnCuts];
669 hESDTruePi0PtAlpha = new TH2F*[fnCuts];
670 hESDTrueEtaPtAlpha = new TH2F*[fnCuts];
671 hESDTruePi0YEtaLowPtGamma = new TH2F*[fnCuts];
672 hESDTruePi0YEtaHighPtGamma = new TH2F*[fnCuts];
673 hESDTrueEtaYEtaLowPtGamma = new TH2F*[fnCuts];
674 hESDTrueEtaYEtaHighPtGamma = new TH2F*[fnCuts];
678 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
679 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
680 TString cutstringMeson = "NoMesonCut";
681 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
683 fMCList[iCut] = new TList();
684 fMCList[iCut]->SetName(Form("%s_%s MC histograms",cutstring.Data(),cutstringMeson.Data()));
685 fMCList[iCut]->SetOwner(kTRUE);
686 fCutFolder[iCut]->Add(fMCList[iCut]);
687 hMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
688 fMCList[iCut]->Add(hMCHeaders[iCut]);
689 hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
690 fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
691 hMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
692 fMCList[iCut]->Add(hMCDecayGammaPi0Pt[iCut]);
693 hMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
694 fMCList[iCut]->Add(hMCDecayGammaRhoPt[iCut]);
695 hMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
696 fMCList[iCut]->Add(hMCDecayGammaEtaPt[iCut]);
697 hMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
698 fMCList[iCut]->Add(hMCDecayGammaOmegaPt[iCut]);
699 hMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
700 fMCList[iCut]->Add(hMCDecayGammaEtapPt[iCut]);
701 hMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
702 fMCList[iCut]->Add(hMCDecayGammaPhiPt[iCut]);
703 hMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
704 fMCList[iCut]->Add(hMCDecayGammaSigmaPt[iCut]);
705 hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
706 fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
708 if (fDoPhotonQA > 0){
709 hMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
710 fMCList[iCut]->Add(hMCConvGammaR[iCut]);
711 hMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",100,-4,4);
712 fMCList[iCut]->Add(hMCConvGammaEta[iCut]);
715 if(fDoMesonAnalysis){
716 hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
717 hMCPi0Pt[iCut]->Sumw2();
718 fMCList[iCut]->Add(hMCPi0Pt[iCut]);
719 hMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
720 hMCPi0WOWeightPt[iCut]->Sumw2();
721 fMCList[iCut]->Add(hMCPi0WOWeightPt[iCut]);
723 hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
724 hMCEtaPt[iCut]->Sumw2();
725 fMCList[iCut]->Add(hMCEtaPt[iCut]);
726 hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
727 hMCPi0InAccPt[iCut]->Sumw2();
728 fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
729 hMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
730 hMCEtaInAccPt[iCut]->Sumw2();
731 fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
733 hMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",250,0.03,25.,150,-1.5,1.5);
734 hMCPi0PtY[iCut]->Sumw2();
735 SetLogBinningXTH2(hMCPi0PtY[iCut]);
736 fMCList[iCut]->Add(hMCPi0PtY[iCut]);
737 hMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",250,0.03,25.,150,-1.5,1.5);
738 hMCEtaPtY[iCut]->Sumw2();
739 SetLogBinningXTH2(hMCEtaPtY[iCut]);
740 fMCList[iCut]->Add(hMCEtaPtY[iCut]);
741 hMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",250,0,25);
742 hMCK0sPt[iCut]->Sumw2();
743 fMCList[iCut]->Add(hMCK0sPt[iCut]);
744 hMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",250,0,25);
745 hMCK0sWOWeightPt[iCut]->Sumw2();
746 fMCList[iCut]->Add(hMCK0sWOWeightPt[iCut]);
747 hMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",250,0.03,25.,150,-1.5,1.5);
748 hMCK0sPtY[iCut]->Sumw2();
749 SetLogBinningXTH2(hMCK0sPtY[iCut]);
750 fMCList[iCut]->Add(hMCK0sPtY[iCut]);
755 fTrueList[iCut] = new TList();
756 fTrueList[iCut]->SetName(Form("%s_%s True histograms",cutstring.Data(),cutstringMeson.Data()));
757 fTrueList[iCut]->SetOwner(kTRUE);
758 fCutFolder[iCut]->Add(fTrueList[iCut]);
760 hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
761 fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
763 hESDCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
764 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
765 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
766 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
767 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
768 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
769 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
770 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
771 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
772 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
773 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
774 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
775 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
776 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
777 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
778 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
779 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
780 fTrueList[iCut]->Add(hESDCombinatorialPt[iCut]);
781 hESDTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
782 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaPt[iCut]);
783 hESDTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
784 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaPt[iCut]);
786 hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]
787 = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
788 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
789 hESDTrueSecondaryConvGammaFromXFromLambdaPt[iCut]
790 = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
791 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
793 hESDTrueDalitzPsiPairDeltaPhi[iCut]
794 = new TH2F("ESD_TrueDalitzPsiPairDeltaPhi_Pt", "ESD_TrueDalitzPsiPairDeltaPhi_Pt",400,-2,2,400,-2,2);
795 fTrueList[iCut]->Add(hESDTrueDalitzPsiPairDeltaPhi[iCut]);
797 hESDTrueGammaPsiPairDeltaPhi[iCut]
798 = new TH2F("ESD_TrueGammaPsiPairDeltaPhi_Pt", "ESD_TrueGammaPsiPairDeltaPhi_Pt",200,-2,2,400,-2,2);
799 fTrueList[iCut]->Add(hESDTrueGammaPsiPairDeltaPhi[iCut]);
802 hESDTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
803 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaESDPtMCPt[iCut]);
805 if(fDoMesonAnalysis){
806 hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
807 fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
808 hESDTruePrimaryMotherInvMassPt[iCut]
809 = new TH2F("ESD_TruePrimaryMother_InvMass_Pt", "ESD_TruePrimaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
810 hESDTruePrimaryMotherInvMassPt[iCut]->Sumw2();
811 fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassPt[iCut]);
812 hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]
813 = new TH2F("ESD_TruePrimaryMotherW0Weights_InvMass_Pt", "ESD_TruePrimaryMotherW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
814 hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]->Sumw2();
815 fTrueList[iCut]->Add(hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]);
816 pESDTruePrimaryMotherWeightsInvMassPt[iCut]
817 = new TProfile2D("ESD_TruePrimaryMotherWeights_InvMass_Pt", "ESD_TruePrimaryMotherWeights_InvMass_Pt", 800,0,0.8,250,0,25);
818 pESDTruePrimaryMotherWeightsInvMassPt[iCut]->Sumw2();
819 fTrueList[iCut]->Add(pESDTruePrimaryMotherWeightsInvMassPt[iCut]);
820 hESDTrueSecondaryMotherInvMassPt[iCut]
821 = new TH2F("ESD_TrueSecondaryMother_InvMass_Pt", "ESD_TrueSecondaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
822 hESDTrueSecondaryMotherInvMassPt[iCut]->Sumw2();
823 fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
824 hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]
825 = new TH2F("ESD_TrueSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueSecondaryMotherFromK0s_InvMass_Pt",800,0,0.8,250,0,25);
826 hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]->Sumw2();
827 fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
828 hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]
829 = new TH2F("ESD_TrueSecondaryMotherFromEta_InvMass_Pt","ESD_TrueSecondaryMotherFromEta_InvMass_Pt",800,0,0.8,250,0,25);
830 fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]);
831 hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueDalitz_InvMass_Pt","ESD_TrueDalitz_InvMass_Pt",800,0,0.8,250,0,25);
832 fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
834 hESDTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
835 hESDTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
836 SetLogBinningXTH2(hESDTruePrimaryPi0MCPtResolPt[iCut]);
837 fTrueList[iCut]->Add(hESDTruePrimaryPi0MCPtResolPt[iCut]);
838 hESDTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
839 hESDTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
840 SetLogBinningXTH2(hESDTruePrimaryEtaMCPtResolPt[iCut]);
841 fTrueList[iCut]->Add(hESDTruePrimaryEtaMCPtResolPt[iCut]);
842 hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
843 fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
844 hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
845 fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
846 hESDTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
847 fTrueList[iCut]->Add(hESDTrueK0sWithPi0DaughterMCPt[iCut]);
848 hESDTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
849 fTrueList[iCut]->Add(hESDTrueEtaWithPi0DaughterMCPt[iCut]);
850 hESDTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",250,0.03,25.,150,-1.5,1.5);
851 SetLogBinningXTH2(hESDTruePi0PtY[iCut]);
852 fTrueList[iCut]->Add(hESDTruePi0PtY[iCut]);
853 hESDTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",250,0.03,25.,150,-1.5,1.5);
854 SetLogBinningXTH2(hESDTrueEtaPtY[iCut]);
855 fTrueList[iCut]->Add(hESDTrueEtaPtY[iCut]);
856 hESDTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",250,0.03,25.,100,0,1);
857 SetLogBinningXTH2(hESDTruePi0PtAlpha[iCut]);
858 fTrueList[iCut]->Add(hESDTruePi0PtAlpha[iCut]);
859 hESDTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",250,0.03,25.,100,0,1);
860 SetLogBinningXTH2(hESDTrueEtaPtAlpha[iCut]);
861 fTrueList[iCut]->Add(hESDTrueEtaPtAlpha[iCut]);
863 hESDTruePi0YEtaLowPtGamma[iCut] = new TH2F("ESD_TruePi0_Y_EtaLowPtGamma","ESD_TruePi0_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
864 fTrueList[iCut]->Add(hESDTruePi0YEtaLowPtGamma[iCut]);
865 hESDTruePi0YEtaHighPtGamma[iCut] = new TH2F("ESD_TruePi0_Y_EtaHighPtGamma","ESD_TruePi0_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
866 fTrueList[iCut]->Add(hESDTruePi0YEtaHighPtGamma[iCut]);
867 hESDTrueEtaYEtaLowPtGamma[iCut] = new TH2F("ESD_TrueEta_Y_EtaLowPtGamma","ESD_TrueEta_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
868 fTrueList[iCut]->Add(hESDTrueEtaYEtaLowPtGamma[iCut]);
869 hESDTrueEtaYEtaHighPtGamma[iCut] = new TH2F("ESD_TrueEta_Y_EtaHighPtGamma","ESD_TrueEta_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
870 fTrueList[iCut]->Add(hESDTrueEtaYEtaHighPtGamma[iCut]);
876 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
877 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
880 if((AliConversionCuts*)fV0Reader->GetConversionCuts())
881 if(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
882 fOutputContainer->Add(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
884 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
885 if(!((AliConversionCuts*)fCutArray->At(iCut))) continue;
886 if(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms()){
887 fCutFolder[iCut]->Add(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms());
889 if(fDoMesonAnalysis){
890 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
891 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
892 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
896 PostData(1, fOutputContainer);
898 //_____________________________________________________________________________
899 Bool_t AliAnalysisTaskGammaConvV1::Notify()
901 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
902 if(!((AliConversionCuts*)fCutArray->At(iCut))->GetDoEtaShift()){
903 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
904 continue; // No Eta Shift requested, continue
906 if(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
907 ((AliConversionCuts*)fCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
908 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
909 ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
913 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
914 (((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift());
915 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
916 ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
922 //_____________________________________________________________________________
923 void AliAnalysisTaskGammaConvV1::UserExec(Option_t *)
926 // Called for each event
928 Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
929 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
930 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
931 hNEvents[iCut]->Fill(eventQuality);
936 if(fIsMC) fMCEvent = MCEvent();
937 if(fMCEvent == NULL) fIsMC = kFALSE;
939 fInputEvent = InputEvent();
941 if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
942 fMCStack = fMCEvent->Stack();
943 if(fMCStack == NULL) fIsMC = kFALSE;
946 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
948 // ------------------- BeginEvent ----------------------------
950 AliEventplane *EventPlane = fInputEvent->GetEventplane();
951 if(fIsHeavyIon)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
952 else fEventPlaneAngle=0.0;
954 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
955 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
956 fV0Reader->RelabelAODs(kTRUE);
958 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
960 Int_t eventNotAccepted =
961 ((AliConversionCuts*)fCutArray->At(iCut))
962 ->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
963 if(eventNotAccepted){
964 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
965 hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
969 if(eventQuality != 0){// Event Not Accepted
970 // cout << "event rejected due to: " <<eventQuality << endl;
971 hNEvents[iCut]->Fill(eventQuality);
975 hNEvents[iCut]->Fill(eventQuality); // Should be 0 here
976 hNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
977 if(((AliConversionCuts*)fCutArray->At(iCut))->IsHeavyIon() == 2) hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
978 else hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
981 // Process MC Particle
982 if(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection() != 0){
983 if(fInputEvent->IsA()==AliESDEvent::Class()){
984 ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
985 ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
988 else if(fInputEvent->IsA()==AliAODEvent::Class()){
989 ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
990 ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
994 if(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader()){
995 for(Int_t i = 0;i<(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
996 TString nameBin= hMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
997 if (nameBin.CompareTo("")== 0){
998 TString nameHeader = ((TObjString*)((TList*)((AliConversionCuts*)fCutArray->At(iCut))
999 ->GetAcceptedHeader())->At(i))->GetString();
1000 hMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
1007 if(fInputEvent->IsA()==AliESDEvent::Class())
1008 ProcessMCParticles();
1009 if(fInputEvent->IsA()==AliAODEvent::Class())
1010 ProcessAODMCParticles();
1013 ProcessPhotonCandidates(); // Process this cuts gammas
1015 hNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
1016 if(fDoMesonAnalysis){ // Meson Analysis
1017 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1018 fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
1019 fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
1020 fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
1021 fUnsmearedE = new Double_t[fGammaCandidates->GetEntries()];
1023 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1024 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
1025 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
1026 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
1027 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
1028 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
1032 CalculatePi0Candidates(); // Combine Gammas
1033 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1034 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1035 CalculateBackground(); // Combinatorial Background
1036 UpdateEventByEventData(); // Store Event for mixed Events
1039 CalculateBackgroundRP(); // Combinatorial Background
1040 fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
1043 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1044 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1045 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1046 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1047 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1048 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
1050 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1051 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1052 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1053 delete[] fUnsmearedE; fUnsmearedE = 0x0;
1056 fGammaCandidates->Clear(); // delete this cuts good gammas
1059 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1060 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
1061 fV0Reader->RelabelAODs(kFALSE);
1064 PostData(1, fOutputContainer);
1066 //________________________________________________________________________
1067 void AliAnalysisTaskGammaConvV1::ProcessPhotonCandidates()
1070 TList *GammaCandidatesStepOne = new TList();
1071 TList *GammaCandidatesStepTwo = new TList();
1072 // Loop over Photon Candidates allocated by ReaderV1
1073 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1074 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1075 if(!PhotonCandidate) continue;
1076 fIsFromMBHeader = kTRUE;
1077 if(fIsMC && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1078 Int_t isPosFromMBHeader
1079 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1080 if(isPosFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1081 Int_t isNegFromMBHeader
1082 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1083 if(isNegFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1085 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1088 if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
1089 if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(PhotonCandidate->GetPhotonPhi(),fEventPlaneAngle)) continue;
1090 if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1091 !((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1092 fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1094 if(fIsFromMBHeader){
1095 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1096 if (fDoPhotonQA > 0){
1097 hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1098 hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1102 if(fInputEvent->IsA()==AliESDEvent::Class())
1103 ProcessTruePhotonCandidates(PhotonCandidate);
1104 if(fInputEvent->IsA()==AliAODEvent::Class())
1105 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1107 if (fIsFromMBHeader && fDoPhotonQA == 2){
1108 if (fIsHeavyIon && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1109 fPtGamma = PhotonCandidate->Pt();
1110 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1111 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1112 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1113 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1114 tESDConvGammaPtDcazCat[fiCut]->Fill();
1115 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1116 fPtGamma = PhotonCandidate->Pt();
1117 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1118 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1119 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1120 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1121 tESDConvGammaPtDcazCat[fiCut]->Fill();
1124 } else if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1125 ((AliConversionCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1127 GammaCandidatesStepOne->Add(PhotonCandidate);
1128 } else if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1129 ((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1130 GammaCandidatesStepTwo->Add(PhotonCandidate);
1133 if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
1134 for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1135 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1136 if(!PhotonCandidate) continue;
1137 fIsFromMBHeader = kTRUE;
1138 if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1139 Int_t isPosFromMBHeader
1140 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1141 Int_t isNegFromMBHeader
1142 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1143 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1145 if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1146 if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1147 fGammaCandidates->Add(PhotonCandidate);
1148 if(fIsFromMBHeader){
1149 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1150 if (fDoPhotonQA > 0){
1151 hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1152 hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1157 if(fInputEvent->IsA()==AliESDEvent::Class())
1158 ProcessTruePhotonCandidates(PhotonCandidate);
1159 if(fInputEvent->IsA()==AliAODEvent::Class())
1160 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1161 } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1163 if (fIsFromMBHeader && fDoPhotonQA == 2){
1164 if (fIsHeavyIon && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1165 fPtGamma = PhotonCandidate->Pt();
1166 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1167 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1168 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1169 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1170 tESDConvGammaPtDcazCat[fiCut]->Fill();
1171 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1172 fPtGamma = PhotonCandidate->Pt();
1173 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1174 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1175 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1176 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1177 tESDConvGammaPtDcazCat[fiCut]->Fill();
1182 if(((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1183 for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1184 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1185 if(!PhotonCandidate) continue;
1186 fIsFromMBHeader = kTRUE;
1187 if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1188 Int_t isPosFromMBHeader
1189 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1190 Int_t isNegFromMBHeader
1191 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1192 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1194 if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
1195 fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1196 if(fIsFromMBHeader){
1197 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1198 if (fDoPhotonQA > 0){
1199 hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1200 hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1204 if(fInputEvent->IsA()==AliESDEvent::Class())
1205 ProcessTruePhotonCandidates(PhotonCandidate);
1206 if(fInputEvent->IsA()==AliAODEvent::Class())
1207 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1209 if (fIsFromMBHeader){
1210 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1211 fPtGamma = PhotonCandidate->Pt();
1212 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1213 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1214 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1215 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1216 tESDConvGammaPtDcazCat[fiCut]->Fill();
1217 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1218 fPtGamma = PhotonCandidate->Pt();
1219 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1220 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1221 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1222 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1223 tESDConvGammaPtDcazCat[fiCut]->Fill();
1229 delete GammaCandidatesStepOne;
1230 GammaCandidatesStepOne = 0x0;
1231 delete GammaCandidatesStepTwo;
1232 GammaCandidatesStepTwo = 0x0;
1235 //________________________________________________________________________
1236 void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1239 Double_t magField = fInputEvent->GetMagneticField();
1240 if( magField < 0.0 ){
1247 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1248 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1249 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
1252 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1253 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1255 if(posDaughter->GetMother() != negDaughter->GetMother()){
1256 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1260 else if(posDaughter->GetMother() == -1){
1261 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1266 if(pdgCode[0]!=11 || pdgCode[1]!=11){
1268 return; //One Particle is not a electron
1270 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
1272 return; // Same Charge
1275 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
1276 AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1277 AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1278 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1280 if(Photon->GetPdgCode() != 22){
1281 hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1283 return; // Mother is no Photon
1286 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
1288 return;// check if the daughters come from a conversion
1290 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1295 if(fIsFromMBHeader)hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1296 hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1297 if(Photon->IsPrimary()){
1298 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1299 if(fIsFromMBHeader){
1301 hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1302 hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1304 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1307 if(fIsFromMBHeader){
1308 hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1310 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1311 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1313 hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1315 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1316 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1318 hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1320 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1321 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1328 //________________________________________________________________________
1329 void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1332 Double_t magField = fInputEvent->GetMagneticField();
1333 if( magField < 0.0 ){
1340 // Process True Photons
1341 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1342 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
1346 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1347 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1349 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
1350 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1353 else if(posDaughter->GetMother(0) == -1){
1354 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1358 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1360 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1362 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
1363 AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1364 AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1365 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1367 if(Photon->GetPdgCode() != 22){
1368 hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1369 return; // Mother is no Photon
1372 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1377 if(fIsFromMBHeader){
1378 hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1380 hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1381 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
1382 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1383 if(fIsFromMBHeader){
1385 hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1386 hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1389 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1392 if(fIsFromMBHeader){
1394 hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1395 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1396 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
1397 hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1400 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1401 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
1402 hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1405 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1406 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
1412 //________________________________________________________________________
1413 void AliAnalysisTaskGammaConvV1::ProcessAODMCParticles()
1416 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1418 // Loop over all primary MC particle
1419 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
1421 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
1422 if (!particle) continue;
1423 if (!particle->IsPrimary()) continue;
1425 Int_t isMCFromMBHeader = -1;
1426 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1428 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1429 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1432 if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
1433 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
1434 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1435 if(particle->GetMother() >-1){ // Meson Decay Gamma
1436 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
1438 hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1441 hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1444 hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1447 hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1450 hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1453 hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1456 hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1461 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
1463 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
1464 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
1465 if(!tmpDaughter) continue;
1466 if(abs(tmpDaughter->GetPdgCode()) == 11){
1467 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
1470 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1471 if (fDoPhotonQA > 0){
1472 hMCConvGammaR[fiCut]->Fill(rConv);
1473 hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1476 // Converted MC Gamma
1477 if(fDoMesonAnalysis){
1478 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1479 Double_t mesonY = 10.;
1480 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1481 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1483 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1484 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1486 Float_t weightedK0s= 1;
1487 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1488 if (particle->Pt()>0.005){
1489 weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1490 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1493 hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1494 hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1495 hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1497 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1498 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1499 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
1500 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
1501 Float_t weighted= 1;
1502 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1503 if (particle->Pt()>0.005){
1504 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1505 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1508 Double_t mesonY = 10.;
1509 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1510 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1512 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1513 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1516 if(particle->GetPdgCode() == 111){
1517 hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1518 hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1519 if (fDoMesonQA > 0) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1520 } else if(particle->GetPdgCode() == 221){
1521 hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1522 if (fDoMesonQA > 0) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1525 // Check the acceptance for both gammas
1526 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
1527 ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) &&
1528 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
1529 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
1531 if(particle->GetPdgCode() == 111){
1532 hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1533 } else if(particle->GetPdgCode() == 221){
1534 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1541 //________________________________________________________________________
1542 void AliAnalysisTaskGammaConvV1::ProcessMCParticles()
1544 // Loop over all primary MC particle
1545 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
1546 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1547 if (!particle) continue;
1549 Int_t isMCFromMBHeader = -1;
1550 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1552 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1553 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1556 if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
1557 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
1558 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1559 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
1560 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
1562 hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1565 hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1568 hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1571 hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1574 hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1577 hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1580 hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1585 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
1586 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1587 if (fDoPhotonQA > 0){
1588 hMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
1589 hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1591 } // Converted MC Gamma
1592 if(fDoMesonAnalysis){
1593 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1594 Double_t mesonY = 10.;
1595 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1596 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1598 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1599 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1601 Float_t weightedK0s= 1;
1602 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1603 if (particle->Pt()>0.005){
1604 weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1605 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1608 hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1609 hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1610 hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1612 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1613 ->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1614 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
1615 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
1617 Float_t weighted= 1;
1618 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1619 if (particle->Pt()>0.005){
1620 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1621 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1624 Double_t mesonY = 10.;
1625 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1626 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1628 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1629 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1632 if(particle->GetPdgCode() == 111){
1633 hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1634 hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1635 if (fDoMesonQA > 0) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1636 } else if(particle->GetPdgCode() == 221){
1637 hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1638 if (fDoMesonQA > 0) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1641 // Check the acceptance for both gammas
1642 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
1643 ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) &&
1644 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
1645 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
1647 if(particle->GetPdgCode() == 111){
1648 hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1649 } else if(particle->GetPdgCode() == 221){
1650 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1657 //________________________________________________________________________
1658 void AliAnalysisTaskGammaConvV1::CalculatePi0Candidates(){
1660 // Conversion Gammas
1661 if(fGammaCandidates->GetEntries()>1){
1662 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
1663 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
1664 if (gamma0==NULL) continue;
1665 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
1666 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
1667 //Check for same Electron ID
1668 if (gamma1==NULL) continue;
1669 if(gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelPositive() ||
1670 gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelNegative() ||
1671 gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelPositive() ||
1672 gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelNegative() ) continue;
1674 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
1675 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
1677 pi0cand->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
1678 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1679 ->MesonIsSelected(pi0cand,kTRUE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
1680 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1681 if(pi0cand->GetAlpha()<0.1)
1682 hESDMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
1684 if (fDoMesonQA > 0){
1685 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
1686 hESDMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1687 hESDMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1688 if (gamma0->Pt() < gamma1->Pt()){
1689 hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1690 hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1692 hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1693 hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1696 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
1697 hESDMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1698 hESDMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1699 if (gamma0->Pt() < gamma1->Pt()){
1700 hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1701 hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1703 hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1704 hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1708 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
1712 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
1713 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1714 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1715 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1717 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1721 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1722 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1723 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1725 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1728 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1729 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1734 if(fInputEvent->IsA()==AliESDEvent::Class())
1735 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1);
1736 if(fInputEvent->IsA()==AliAODEvent::Class())
1737 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1);
1739 if (fDoMesonQA == 2){
1740 fInvMass = pi0cand->M();
1741 fPt = pi0cand->Pt();
1742 if (abs(gamma0->GetDCAzToPrimVtx()) < abs(gamma1->GetDCAzToPrimVtx())){
1743 fDCAzGammaMin = gamma0->GetDCAzToPrimVtx();
1744 fDCAzGammaMax = gamma1->GetDCAzToPrimVtx();
1746 fDCAzGammaMin = gamma1->GetDCAzToPrimVtx();
1747 fDCAzGammaMax = gamma0->GetDCAzToPrimVtx();
1749 iFlag = pi0cand->GetMesonQuality();
1750 // cout << "gamma 0: " << gamma0->GetV0Index()<< "\t" << gamma0->GetPx() << "\t" << gamma0->GetPy() << "\t" << gamma0->GetPz() << "\t" << endl;
1751 // cout << "gamma 1: " << gamma1->GetV0Index()<< "\t"<< gamma1->GetPx() << "\t" << gamma1->GetPy() << "\t" << gamma1->GetPz() << "\t" << endl;
1752 // cout << "pi0: "<<fInvMass << "\t" << fPt <<"\t" << fDCAzGammaMin << "\t" << fDCAzGammaMax << "\t" << (Int_t)iFlag << "\t" << (Int_t)iMesonMCInfo <<endl;
1753 if (fIsHeavyIon == 1 && fPt > 0.399 && fPt < 20. ) {
1754 if (fInvMass > 0.08 && fInvMass < 0.2) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1755 if ((fInvMass > 0.45 && fInvMass < 0.6) && (fPt > 0.999 && fPt < 20.) )tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1756 } else if (fPt > 0.299 && fPt < 20. ) {
1757 if ( (fInvMass > 0.08 && fInvMass < 0.2) || (fInvMass > 0.45 && fInvMass < 0.6)) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1767 //______________________________________________________________________
1768 void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1770 // Process True Mesons
1771 AliStack *MCStack = fMCEvent->Stack();
1773 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
1774 Bool_t isTruePi0 = kFALSE;
1775 Bool_t isTrueEta = kFALSE;
1776 Bool_t isTruePi0Dalitz = kFALSE;
1777 Bool_t isTrueEtaDalitz = kFALSE;
1778 Bool_t gamma0DalitzCand = kFALSE;
1779 Bool_t gamma1DalitzCand = kFALSE;
1780 Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
1781 Int_t gamma0MotherLabel = -1;
1782 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1783 // Daughters Gamma 0
1784 TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
1785 TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
1786 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
1787 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1788 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1789 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1790 gamma0MotherLabel=gammaMC0->GetFirstMother();
1793 if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate
1794 gamma0DalitzCand = kTRUE;
1795 gamma0MotherLabel=-111;
1797 if(gammaMC0->GetPdgCode() ==221){ // Dalitz candidate
1798 gamma0DalitzCand = kTRUE;
1799 gamma0MotherLabel=-221;
1803 if(TrueGammaCandidate1->GetV0Index()<fInputEvent->GetNumberOfV0s()){
1804 Int_t gamma1MCLabel = TrueGammaCandidate1->GetMCParticleLabel(MCStack);
1805 Int_t gamma1MotherLabel = -1;
1806 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1807 // Daughters Gamma 1
1808 TParticle * negativeMC = (TParticle*)TrueGammaCandidate1->GetNegativeMCDaughter(MCStack);
1809 TParticle * positiveMC = (TParticle*)TrueGammaCandidate1->GetPositiveMCDaughter(MCStack);
1810 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
1811 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1812 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1813 if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
1814 gamma1MotherLabel=gammaMC1->GetFirstMother();
1817 if(gammaMC1->GetPdgCode() ==111 ){ // Dalitz candidate
1818 gamma1DalitzCand = kTRUE;
1819 gamma1MotherLabel=-111;
1821 if(gammaMC1->GetPdgCode() ==221){ // Dalitz candidate
1822 gamma1DalitzCand = kTRUE;
1823 gamma1MotherLabel=-221;
1827 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1828 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
1831 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
1836 //Identify Dalitz candidate
1837 if (gamma1DalitzCand || gamma0DalitzCand){
1838 if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){
1839 if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE;
1840 if (gamma0MotherLabel == -221) isTrueEtaDalitz = kTRUE;
1842 if (gamma1DalitzCand && gamma1MCLabel >=0 && gamma1MCLabel==gamma0MotherLabel){
1843 if (gamma1MotherLabel == -111) isTruePi0Dalitz = kTRUE;
1844 if (gamma1MotherLabel == -221) isTrueEtaDalitz = kTRUE;
1849 if(isTruePi0 || isTrueEta){// True Pion or Eta
1850 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1851 if (fDoMesonQA > 0){
1853 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
1854 hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1855 hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
1856 if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
1857 hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1858 hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1860 hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1861 hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1864 } else if (isTrueEta){
1865 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
1866 hESDTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1867 hESDTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
1868 if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
1869 hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1870 hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1872 hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1873 hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1878 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
1879 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetMother(0);
1880 Float_t weightedSec= 1;
1881 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1882 weightedSec= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),secMotherLabel, fMCStack, fInputEvent)/2.; //invariant mass is additive thus the weight for the daughters has to be devide by two for the K0s at a certain pt
1883 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1885 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1887 if (secMotherLabel >-1){
1888 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1890 hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1891 if (fDoMesonQA > 0)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
1892 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1894 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221){
1896 hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1897 if (fDoMesonQA > 0)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
1898 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1901 }else{ // Only primary pi0 for efficiency calculation
1903 Float_t weighted= 1;
1904 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
1905 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
1906 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
1907 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
1910 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1911 hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1912 pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1915 if (fDoMesonQA > 0){
1916 if(isTruePi0){ // Only primary pi0 for resolution
1917 hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1919 if (isTrueEta){ // Only primary eta for resolution
1920 hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1924 } else if(!isTruePi0 && !isTrueEta){ // Background
1925 if (fDoMesonQA > 0){
1926 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
1927 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1929 } else { // No photon or without mother
1930 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1933 if( isTruePi0Dalitz || isTrueEtaDalitz ){
1936 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1937 } else if (gamma0DalitzCand || gamma1DalitzCand){
1938 if (fDoMesonQA > 0)hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1944 //______________________________________________________________________
1945 void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1948 // Process True Mesons
1949 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1950 Bool_t isTruePi0 = kFALSE;
1951 Bool_t isTrueEta = kFALSE;
1952 Bool_t isTruePi0Dalitz = kFALSE;
1953 Bool_t isTrueEtaDalitz = kFALSE;
1954 Bool_t gamma0DalitzCand = kFALSE;
1955 Bool_t gamma1DalitzCand = kFALSE;
1957 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
1958 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
1961 Int_t gamma0MCLabel = -1;
1962 Int_t gamma0MotherLabel = -1;
1963 if(!positiveMC||!negativeMC)
1966 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
1967 gamma0MCLabel = positiveMC->GetMother();
1970 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1971 // Daughters Gamma 0
1972 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
1973 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1974 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
1975 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1976 gamma0MotherLabel=gammaMC0->GetMother();
1979 if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate
1980 gamma0DalitzCand = kTRUE;
1981 gamma0MotherLabel=-111;
1983 if(gammaMC0->GetPdgCode() ==221){ // Dalitz candidate
1984 gamma0DalitzCand = kTRUE;
1985 gamma0MotherLabel=-221;
1989 positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelPositive()));
1990 negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelNegative()));
1992 Int_t gamma1MCLabel = -1;
1993 Int_t gamma1MotherLabel = -1;
1994 if(!positiveMC||!negativeMC)
1997 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
1998 gamma1MCLabel = positiveMC->GetMother();
2000 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2001 // Daughters Gamma 1
2002 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2003 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2004 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
2005 if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
2006 gamma1MotherLabel=gammaMC1->GetMother();
2009 if(gammaMC1->GetPdgCode() ==111 ){ // Dalitz candidate
2010 gamma1DalitzCand = kTRUE;
2011 gamma1MotherLabel=-111;
2013 if(gammaMC1->GetPdgCode() ==221){ // Dalitz candidate
2014 gamma1DalitzCand = kTRUE;
2015 gamma1MotherLabel=-221;
2019 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2020 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2023 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2028 //Identify Dalitz candidate
2029 if (gamma1DalitzCand || gamma0DalitzCand){
2030 if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){
2031 if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE;
2032 if (gamma0MotherLabel == -221) isTrueEtaDalitz = kTRUE;
2034 if (gamma1DalitzCand && gamma1MCLabel >=0 && gamma1MCLabel==gamma0MotherLabel){
2035 if (gamma1MotherLabel == -111) isTruePi0Dalitz = kTRUE;
2036 if (gamma1MotherLabel == -221) isTrueEtaDalitz = kTRUE;
2040 if(isTruePi0 || isTrueEta){// True Pion or Eta
2041 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2042 if (fDoMesonQA > 0){
2044 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2045 hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
2046 hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2047 if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
2048 hESDTruePi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2049 hESDTruePi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2051 hESDTruePi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2052 hESDTruePi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2055 } else if (isTrueEta){
2056 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2057 hESDTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
2058 hESDTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2059 if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
2060 hESDTrueEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2061 hESDTrueEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2063 hESDTrueEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2064 hESDTrueEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2069 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2070 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2071 Float_t weightedSec= 1;
2072 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2073 weightedSec= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),secMotherLabel, 0x0, fInputEvent)/2.; //invariant mass is additive thus the weight for the daughters has to be devide by two for the K0s at a certain pt
2074 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2076 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2078 if (secMotherLabel >-1){
2079 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2081 hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2082 if (fDoMesonQA > 0)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
2083 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2085 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221){
2087 hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2088 if (fDoMesonQA > 0)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
2089 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2092 }else{ // Only primary pi0 for efficiency calculation
2093 Float_t weighted= 1;
2095 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2096 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2097 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2098 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2101 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2102 hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2103 pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2105 if (fDoMesonQA > 0){
2106 if(isTruePi0){ // Only primary pi0 for resolution
2107 hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2108 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2111 if (isTrueEta){ // Only primary eta for resolution
2112 hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2113 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2117 } else if(!isTruePi0 && !isTrueEta) { // Background
2118 if (fDoMesonQA > 0){
2119 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2120 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2122 } else { // No photon or without mother
2123 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2126 if( isTruePi0Dalitz || isTrueEtaDalitz ){
2129 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2130 } else if (gamma0DalitzCand || gamma1DalitzCand){
2131 if (fDoMesonQA > 0)hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2135 //________________________________________________________________________
2136 void AliAnalysisTaskGammaConvV1::CalculateBackground(){
2138 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2141 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2142 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2144 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2147 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2149 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2150 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2151 for(Int_t iCurrent2=iCurrent+1;iCurrent2<fGammaCandidates->GetEntries();iCurrent2++){
2152 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2153 AliAODConversionPhoton currentEventGoodV02 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent2));
2155 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGProbability()){
2156 AliAODConversionMother *backgroundCandidateProb = new AliAODConversionMother(¤tEventGoodV0,¤tEventGoodV02);
2157 Double_t massBGprob = backgroundCandidateProb->M();
2158 if(massBGprob>0.1 && massBGprob<0.14){
2159 if(fRandom.Rndm()>fBGHandler[fiCut]->GetBGProb(zbin,mbin)){
2160 delete backgroundCandidateProb;
2164 delete backgroundCandidateProb;
2165 backgroundCandidateProb = 0x0;
2168 RotateParticle(¤tEventGoodV02);
2169 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,¤tEventGoodV02);
2170 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2171 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2172 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2173 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2174 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2175 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2177 delete backgroundCandidate;
2178 backgroundCandidate = 0x0;
2183 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2185 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2186 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2187 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2188 if(fMoveParticleAccordingToVertex == kTRUE){
2189 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2192 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2193 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2194 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2195 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2196 if(fMoveParticleAccordingToVertex == kTRUE){
2197 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2200 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2203 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2204 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2205 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2206 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2207 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2208 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2209 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2211 delete backgroundCandidate;
2212 backgroundCandidate = 0x0;
2218 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2219 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2220 if(previousEventV0s){
2221 if(fMoveParticleAccordingToVertex == kTRUE){
2222 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2224 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2225 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2226 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2228 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2230 if(fMoveParticleAccordingToVertex == kTRUE){
2231 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2234 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2238 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2239 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2240 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2241 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2242 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2243 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2244 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2246 delete backgroundCandidate;
2247 backgroundCandidate = 0x0;
2255 //________________________________________________________________________
2256 void AliAnalysisTaskGammaConvV1::CalculateBackgroundRP(){
2258 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2260 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2261 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2263 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2268 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2269 // Correct for the number of rotations
2270 // BG is for rotation the same, except for factor NRotations
2271 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
2273 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2275 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2276 if (gamma0==NULL) continue;
2277 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
2278 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
2279 if (gamma1 == NULL) continue;
2280 if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
2281 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2283 RotateParticle(gamma1);
2285 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2286 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2287 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2288 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
2289 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2290 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2291 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2299 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
2301 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
2303 if(previousEventGammas){
2304 // test weighted background
2305 Double_t weight=1.0;
2306 // Correct for the number of eventmixing:
2307 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
2308 // real combinations (since you cannot combine a photon with its own)
2309 // but BG leads to N_{a}*N_{b} combinations
2310 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
2312 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2314 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2316 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
2318 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
2320 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2321 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2322 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2323 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
2324 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2325 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2326 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2334 //________________________________________________________________________
2335 void AliAnalysisTaskGammaConvV1::RotateParticle(AliAODConversionPhoton *gamma){
2336 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
2337 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
2338 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
2339 gamma->RotateZ(rotationValue);
2342 //________________________________________________________________________
2343 void AliAnalysisTaskGammaConvV1::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
2345 previousEventEP=previousEventEP+TMath::Pi();
2346 thisEventEP=thisEventEP+TMath::Pi();
2347 Double_t rotationValue= thisEventEP-previousEventEP;
2348 gamma->RotateZ(rotationValue);
2351 //________________________________________________________________________
2352 void AliAnalysisTaskGammaConvV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
2353 //see header file for documentation
2355 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
2356 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
2357 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
2359 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
2360 particle->SetConversionPoint(movedPlace);
2362 //________________________________________________________________________
2363 void AliAnalysisTaskGammaConvV1::UpdateEventByEventData(){
2364 //see header file for documentation
2365 if(fGammaCandidates->GetEntries() >0 ){
2366 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2367 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
2369 else{ // means we use #V0s for multiplicity
2370 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
2376 //________________________________________________________________________
2377 void AliAnalysisTaskGammaConvV1::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
2379 // Combinatorial Bck = 0 ee, 1 ep,i 2 ek, 3 ep, 4 emu, 5 pipi, 6 pik, 7 pip, 8 pimu, 9 kk, 10 kp, 11 kmu, 12 pp, 13 pmu, 14 mumu, 15 Rest
2380 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
2381 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
2382 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
2383 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
2384 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
2385 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
2386 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
2387 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
2388 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
2389 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
2390 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
2391 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
2392 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
2393 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
2394 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
2395 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
2396 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
2397 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
2398 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
2399 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
2400 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
2401 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
2402 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
2403 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
2404 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
2405 else {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
2407 //________________________________________________________________________
2408 void AliAnalysisTaskGammaConvV1::RelabelAODPhotonCandidates(Bool_t mode){
2410 // Relabeling For AOD Event
2412 // MCLabel -> AODMCLabel
2415 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
2416 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
2417 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
2418 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
2421 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
2422 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
2423 if(!PhotonCandidate) continue;
2424 if(!mode){// Back to ESD Labels
2425 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
2426 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
2427 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
2428 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
2431 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
2432 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
2433 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
2434 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
2436 Bool_t AODLabelPos = kFALSE;
2437 Bool_t AODLabelNeg = kFALSE;
2439 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
2440 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
2442 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
2443 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
2444 PhotonCandidate->SetLabelPositive(i);
2445 AODLabelPos = kTRUE;
2449 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
2450 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
2451 PhotonCandidate->SetLabelNegative(i);
2452 AODLabelNeg = kTRUE;
2455 if(AODLabelNeg && AODLabelPos){
2459 if(!AODLabelPos || !AODLabelNeg){
2460 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
2466 delete[] fMCStackPos;
2467 delete[] fMCStackNeg;
2468 delete[] fESDArrayPos;
2469 delete[] fESDArrayNeg;
2473 void AliAnalysisTaskGammaConvV1::SetLogBinningXTH2(TH2* histoRebin){
2474 TAxis *axisafter = histoRebin->GetXaxis();
2475 Int_t bins = axisafter->GetNbins();
2476 Double_t from = axisafter->GetXmin();
2477 Double_t to = axisafter->GetXmax();
2478 Double_t *newbins = new Double_t[bins+1];
2480 Double_t factor = TMath::Power(to/from, 1./bins);
2481 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
2482 axisafter->Set(bins, newbins);
2487 //________________________________________________________________________
2488 void AliAnalysisTaskGammaConvV1::Terminate(const Option_t *)
2491 //fOutputContainer->Print(); // Will crash on GRID