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"
57 ClassImp(AliAnalysisTaskGammaConvV1)
59 //________________________________________________________________________
60 AliAnalysisTaskGammaConvV1::AliAnalysisTaskGammaConvV1(): AliAnalysisTaskSE(),
74 fTrueMotherRapList(NULL),
76 fHeaderNameList(NULL),
79 fGammaCandidates(NULL),
81 fConversionCuts(NULL),
84 hESDConvGammaPt(NULL),
85 tESDConvGammaPtDcazCat(NULL),
92 hESDMotherInvMassPt(NULL),
93 sESDMotherInvMassPtZM(NULL),
94 hESDMotherBackInvMassPt(NULL),
95 sESDMotherBackInvMassPtZM(NULL),
96 hESDMotherInvMassEalpha(NULL),
99 hMCDecayGammaPi0Pt(NULL),
100 hMCDecayGammaRhoPt(NULL),
101 hMCDecayGammaEtaPt(NULL),
102 hMCDecayGammaOmegaPt(NULL),
103 hMCDecayGammaEtapPt(NULL),
104 hMCDecayGammaPhiPt(NULL),
105 hMCDecayGammaSigmaPt(NULL),
106 hMCConvGammaPt(NULL),
108 hMCConvGammaEta(NULL),
109 hMCConvGammaRSPt(NULL),
110 hMCConvGammaRSR(NULL),
111 hMCConvGammaRSEta(NULL),
113 hMCPi0WOWeightPt(NULL),
120 hMCK0sWOWeightPt(NULL),
122 hESDTrueMotherInvMassPt(NULL),
123 hESDTruePrimaryMotherInvMassPt(NULL),
124 hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
125 pESDTruePrimaryMotherWeightsInvMassPt(NULL),
126 hESDTruePrimaryPi0MCPtResolPt(NULL),
127 hESDTruePrimaryEtaMCPtResolPt(NULL),
128 hESDTrueSecondaryMotherInvMassPt(NULL),
129 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
130 hESDTrueK0sWithPi0DaughterMCPt(NULL),
131 hESDTrueSecondaryMotherFromEtaInvMassPt(NULL),
132 hESDTrueEtaWithPi0DaughterMCPt(NULL),
133 hESDTrueBckGGInvMassPt(NULL),
134 hESDTrueBckContInvMassPt(NULL),
135 hESDTrueMotherDalitzInvMassPt(NULL),
136 hESDTrueConvGammaPt(NULL),
137 hESDCombinatorialPt(NULL),
138 hESDTruePrimaryConvGammaPt(NULL),
139 hESDTruePrimaryConvGammaESDPtMCPt(NULL),
140 hESDTruePrimaryConvGammaRSESDPtMCPt(NULL),
141 hESDTrueSecondaryConvGammaPt(NULL),
142 hESDTrueSecondaryConvGammaFromXFromK0sPt(NULL),
143 hESDTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
144 hESDTrueDalitzPsiPairDeltaPhi(NULL),
145 hESDTrueGammaPsiPairDeltaPhi(NULL),
147 hNGoodESDTracks(NULL),
148 hNGammaCandidates(NULL),
151 tESDMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
159 fnGammaCandidates(0),
170 fMoveParticleAccordingToVertex(kTRUE),
172 fDoMesonAnalysis(kTRUE),
175 fIsFromMBHeader(kTRUE),
181 //________________________________________________________________________
182 AliAnalysisTaskGammaConvV1::AliAnalysisTaskGammaConvV1(const char *name):
183 AliAnalysisTaskSE(name),
194 fPhotonDCAList(NULL),
197 fTrueMotherRapList(NULL),
199 fHeaderNameList(NULL),
202 fGammaCandidates(NULL),
204 fConversionCuts(NULL),
205 fMesonCutArray(NULL),
207 hESDConvGammaPt(NULL),
208 tESDConvGammaPtDcazCat(NULL),
215 hESDMotherInvMassPt(NULL),
216 sESDMotherInvMassPtZM(NULL),
217 hESDMotherBackInvMassPt(NULL),
218 sESDMotherBackInvMassPtZM(NULL),
219 hESDMotherInvMassEalpha(NULL),
222 hMCDecayGammaPi0Pt(NULL),
223 hMCDecayGammaRhoPt(NULL),
224 hMCDecayGammaEtaPt(NULL),
225 hMCDecayGammaOmegaPt(NULL),
226 hMCDecayGammaEtapPt(NULL),
227 hMCDecayGammaPhiPt(NULL),
228 hMCDecayGammaSigmaPt(NULL),
229 hMCConvGammaPt(NULL),
231 hMCConvGammaEta(NULL),
232 hMCConvGammaRSPt(NULL),
233 hMCConvGammaRSR(NULL),
234 hMCConvGammaRSEta(NULL),
236 hMCPi0WOWeightPt(NULL),
243 hMCK0sWOWeightPt(NULL),
245 hESDTrueMotherInvMassPt(NULL),
246 hESDTruePrimaryMotherInvMassPt(NULL),
247 hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
248 pESDTruePrimaryMotherWeightsInvMassPt(NULL),
249 hESDTruePrimaryPi0MCPtResolPt(NULL),
250 hESDTruePrimaryEtaMCPtResolPt(NULL),
251 hESDTrueSecondaryMotherInvMassPt(NULL),
252 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
253 hESDTrueK0sWithPi0DaughterMCPt(NULL),
254 hESDTrueSecondaryMotherFromEtaInvMassPt(NULL),
255 hESDTrueEtaWithPi0DaughterMCPt(NULL),
256 hESDTrueBckGGInvMassPt(NULL),
257 hESDTrueBckContInvMassPt(NULL),
258 hESDTrueMotherDalitzInvMassPt(NULL),
259 hESDTrueConvGammaPt(NULL),
260 hESDCombinatorialPt(NULL),
261 hESDTruePrimaryConvGammaPt(NULL),
262 hESDTruePrimaryConvGammaESDPtMCPt(NULL),
263 hESDTruePrimaryConvGammaRSESDPtMCPt(NULL),
264 hESDTrueSecondaryConvGammaPt(NULL),
265 hESDTrueSecondaryConvGammaFromXFromK0sPt(NULL),
266 hESDTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
267 hESDTrueDalitzPsiPairDeltaPhi(NULL),
268 hESDTrueGammaPsiPairDeltaPhi(NULL),
270 hNGoodESDTracks(NULL),
271 hNGammaCandidates(NULL),
274 tESDMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
282 fnGammaCandidates(0),
293 fMoveParticleAccordingToVertex(kTRUE),
295 fDoMesonAnalysis(kTRUE),
298 fIsFromMBHeader(kTRUE),
301 // Define output slots here
302 DefineOutput(1, TList::Class());
305 AliAnalysisTaskGammaConvV1::~AliAnalysisTaskGammaConvV1()
307 if(fGammaCandidates){
308 delete fGammaCandidates;
309 fGammaCandidates = 0x0;
316 delete[] fBGHandlerRP;
320 //___________________________________________________________
321 void AliAnalysisTaskGammaConvV1::InitBack(){
323 const Int_t nDim = 4;
324 Int_t nBins[nDim] = {800,250,7,4};
325 Double_t xMin[nDim] = {0,0, 0,0};
326 Double_t xMax[nDim] = {0.8,25,7,4};
328 sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
329 sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
331 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
332 fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
333 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
334 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
335 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
336 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
338 Int_t collisionSystem = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(0,1));
339 Int_t centMin = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(1,1));
340 Int_t centMax = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(2,1));
342 if(collisionSystem == 1 || collisionSystem == 2 ||
343 collisionSystem == 5 || collisionSystem == 8 ||
344 collisionSystem == 9){
345 centMin = centMin*10;
346 centMax = centMax*10;
348 else if(collisionSystem == 3 || collisionSystem == 6){
352 else if(collisionSystem == 4 || collisionSystem == 7){
353 centMin = ((centMin*5)+45);
354 centMax = ((centMax*5)+45);
357 fBackList[iCut] = new TList();
358 fBackList[iCut]->SetName(Form("%s_%s Back histograms",cutstring.Data(),cutstringMeson.Data()));
359 fBackList[iCut]->SetOwner(kTRUE);
360 fCutFolder[iCut]->Add(fBackList[iCut]);
362 sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
363 fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
365 fMotherList[iCut] = new TList();
366 fMotherList[iCut]->SetName(Form("%s_%s Mother histograms",cutstring.Data(),cutstringMeson.Data()));
367 fMotherList[iCut]->SetOwner(kTRUE);
368 fCutFolder[iCut]->Add(fMotherList[iCut]);
370 sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
371 fMotherList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
373 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
374 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
375 collisionSystem,centMin,centMax,
376 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
377 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity());
378 fBGHandlerRP[iCut] = NULL;
381 fBGHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
382 ((AliConversionCuts*)fCutArray->At(fiCut))->IsHeavyIon(),
383 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
384 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
385 fBGHandler[iCut] = NULL;
390 //________________________________________________________________________
391 void AliAnalysisTaskGammaConvV1::UserCreateOutputObjects()
395 if(fOutputContainer != NULL){
396 delete fOutputContainer;
397 fOutputContainer = NULL;
399 if(fOutputContainer == NULL){
400 fOutputContainer = new TList();
401 fOutputContainer->SetOwner(kTRUE);
404 // Array of current cut's gammas
405 fGammaCandidates = new TList();
407 fCutFolder = new TList*[fnCuts];
408 fESDList = new TList*[fnCuts];
409 fBackList = new TList*[fnCuts];
410 fMotherList = new TList*[fnCuts];
411 hNEvents = new TH1I*[fnCuts];
412 hNGoodESDTracks = new TH1I*[fnCuts];
413 hNGammaCandidates = new TH1I*[fnCuts];
414 hNV0Tracks = new TH1I*[fnCuts];
415 hEtaShift = new TProfile*[fnCuts];
416 hESDConvGammaPt = new TH1F*[fnCuts];
419 fPhotonDCAList = new TList*[fnCuts];
420 tESDConvGammaPtDcazCat = new TTree*[fnCuts];
423 if(fDoMesonAnalysis){
424 hESDMotherInvMassPt = new TH2F*[fnCuts];
425 hESDMotherBackInvMassPt = new TH2F*[fnCuts];
426 hESDMotherInvMassEalpha = new TH2F*[fnCuts];
428 fMesonDCAList = new TList*[fnCuts];
429 tESDMesonsInvMassPtDcazMinDcazMaxFlag = new TTree*[fnCuts];
433 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
435 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
436 TString cutstringMeson = "NoMesonCut";
437 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
439 fCutFolder[iCut] = new TList();
440 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s",cutstring.Data(),cutstringMeson.Data()));
441 fCutFolder[iCut]->SetOwner(kTRUE);
442 fOutputContainer->Add(fCutFolder[iCut]);
443 fESDList[iCut] = new TList();
444 fESDList[iCut]->SetName(Form("%s_%s ESD histograms",cutstring.Data(),cutstringMeson.Data()));
445 fESDList[iCut]->SetOwner(kTRUE);
446 fCutFolder[iCut]->Add(fESDList[iCut]);
448 hNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
449 hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
450 hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
451 hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
452 if (((AliConversionCuts*)fCutArray->At(iCut))->IsSpecialTrigger() == 4 ){
453 TString TriggerNames = "Not Trigger: ";
454 TriggerNames = TriggerNames+ ( (AliConversionCuts*)fCutArray->At(iCut))->GetSpecialTriggerName();
455 hNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
457 hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
459 hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
460 hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
461 hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
462 hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
463 hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
464 fESDList[iCut]->Add(hNEvents[iCut]);
465 if(fIsHeavyIon) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
466 else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
467 fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
468 if(fIsHeavyIon) hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
469 else hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
470 fESDList[iCut]->Add(hNGammaCandidates[iCut]);
471 if(fIsHeavyIon) hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
472 else hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2000,0,2000);
473 fESDList[iCut]->Add(hNV0Tracks[iCut]);
474 hEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
475 fESDList[iCut]->Add(hEtaShift[iCut]);
476 hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
477 fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
480 fPhotonDCAList[iCut] = new TList();
481 fPhotonDCAList[iCut]->SetName(Form("%s_%s Photon DCA tree",cutstring.Data(),cutstringMeson.Data()));
482 fPhotonDCAList[iCut]->SetOwner(kTRUE);
483 fCutFolder[iCut]->Add(fPhotonDCAList[iCut]);
485 tESDConvGammaPtDcazCat[iCut] = new TTree("ESD_ConvGamma_Pt_Dcaz_R_Eta","ESD_ConvGamma_Pt_Dcaz_R_Eta_Cat");
486 tESDConvGammaPtDcazCat[iCut]->Branch("Pt",&fPtGamma,"fPtGamma/F");
487 tESDConvGammaPtDcazCat[iCut]->Branch("DcaZPhoton",&fDCAzPhoton,"fDCAzPhoton/F");
488 // tESDConvGammaPtDcazCat[iCut]->Branch("R",&fRConvPhoton,"fRConvPhoton/F");
489 // tESDConvGammaPtDcazCat[iCut]->Branch("Eta",&fEtaPhoton,"fEtaPhoton/F");
491 tESDConvGammaPtDcazCat[iCut]->Branch("cat",&iCatPhoton,"iCatPhoton/b");
493 tESDConvGammaPtDcazCat[iCut]->Branch("photonMCInfo",&iPhotonMCInfo,"iPhotonMCInfo/b");
495 fPhotonDCAList[iCut]->Add(tESDConvGammaPtDcazCat[iCut]);
498 if(fDoMesonAnalysis){
499 hESDMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
500 fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
501 hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
502 fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
503 hESDMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
504 fESDList[iCut]->Add(hESDMotherInvMassEalpha[iCut]);
506 fMesonDCAList[iCut] = new TList();
507 fMesonDCAList[iCut]->SetName(Form("%s_%s Meson DCA tree",cutstring.Data(),cutstringMeson.Data()));
508 fMesonDCAList[iCut]->SetOwner(kTRUE);
509 fCutFolder[iCut]->Add(fMesonDCAList[iCut]);
511 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut] = new TTree("ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag","ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag");
512 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("InvMass",&fInvMass,"fInvMass/F");
513 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("Pt",&fPt,"fPt/F");
514 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMin",&fDCAzGammaMin,"fDCAzGammaMin/F");
515 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMax",&fDCAzGammaMax,"fDCAzGammaMax/F");
516 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("kind",&iFlag,"iFlag/b");
518 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("mesonMCInfo",&iMesonMCInfo,"iMesonMCInfo/b");
520 fMesonDCAList[iCut]->Add(tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]);
527 if(fDoMesonAnalysis){
528 InitBack(); // Init Background Handler
533 fMCList = new TList*[fnCuts];
535 fTrueList = new TList*[fnCuts];
536 // Selected Header List
537 fHeaderNameList = new TList*[fnCuts];
538 hMCHeaders = new TH1I*[fnCuts];
539 hMCAllGammaPt = new TH1F*[fnCuts];
540 hMCDecayGammaPi0Pt = new TH1F*[fnCuts];
541 hMCDecayGammaRhoPt = new TH1F*[fnCuts];
542 hMCDecayGammaEtaPt = new TH1F*[fnCuts];
543 hMCDecayGammaOmegaPt = new TH1F*[fnCuts];
544 hMCDecayGammaEtapPt = new TH1F*[fnCuts];
545 hMCDecayGammaPhiPt = new TH1F*[fnCuts];
546 hMCDecayGammaSigmaPt = new TH1F*[fnCuts];
547 hMCConvGammaPt = new TH1F*[fnCuts];
548 hMCConvGammaRSPt = new TH1F*[fnCuts];
549 hESDTrueConvGammaPt = new TH1F*[fnCuts];
551 hESDCombinatorialPt = new TH2F*[fnCuts];
552 hESDTruePrimaryConvGammaPt = new TH1F*[fnCuts];
553 hESDTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
554 hESDTruePrimaryConvGammaRSESDPtMCPt = new TH2F*[fnCuts];
555 hESDTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
556 hESDTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
557 hESDTrueSecondaryConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
559 hESDTrueDalitzPsiPairDeltaPhi= new TH2F*[fnCuts];
560 hESDTrueGammaPsiPairDeltaPhi= new TH2F*[fnCuts];
563 hMCConvGammaR = new TH1F*[fnCuts];
564 hMCConvGammaEta = new TH1F*[fnCuts];
565 hMCConvGammaRSR = new TH1F*[fnCuts];
566 hMCConvGammaRSEta = new TH1F*[fnCuts];
569 if(fDoMesonAnalysis){
570 hMCPi0Pt = new TH1F*[fnCuts];
571 hMCPi0WOWeightPt = new TH1F*[fnCuts];
572 hMCEtaPt = new TH1F*[fnCuts];
573 hMCPi0InAccPt = new TH1F*[fnCuts];
574 hMCEtaInAccPt = new TH1F*[fnCuts];
576 hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
577 hESDTruePrimaryMotherInvMassPt = new TH2F*[fnCuts];
578 hESDTruePrimaryMotherW0WeightingInvMassPt = new TH2F*[fnCuts];
579 pESDTruePrimaryMotherWeightsInvMassPt = new TProfile2D*[fnCuts];
580 hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
581 hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
582 hESDTrueSecondaryMotherFromEtaInvMassPt = new TH2F*[fnCuts];
584 hMCPi0PtY = new TH2F*[fnCuts];
585 hMCEtaPtY = new TH2F*[fnCuts];
586 hMCK0sPt = new TH1F*[fnCuts];
587 hMCK0sWOWeightPt = new TH1F*[fnCuts];
588 hMCK0sPtY = new TH2F*[fnCuts];
589 hESDTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
590 hESDTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
591 hESDTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
592 hESDTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
593 hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
594 hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
595 hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
596 fTrueMotherRapList = new TList*[fnCuts];
600 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
601 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
602 TString cutstringMeson = "NoMesonCut";
603 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
605 fMCList[iCut] = new TList();
606 fMCList[iCut]->SetName(Form("%s_%s MC histograms",cutstring.Data(),cutstringMeson.Data()));
607 fMCList[iCut]->SetOwner(kTRUE);
608 fCutFolder[iCut]->Add(fMCList[iCut]);
609 hMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
610 fMCList[iCut]->Add(hMCHeaders[iCut]);
611 hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
612 fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
613 hMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
614 fMCList[iCut]->Add(hMCDecayGammaPi0Pt[iCut]);
615 hMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
616 fMCList[iCut]->Add(hMCDecayGammaRhoPt[iCut]);
617 hMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
618 fMCList[iCut]->Add(hMCDecayGammaEtaPt[iCut]);
619 hMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
620 fMCList[iCut]->Add(hMCDecayGammaOmegaPt[iCut]);
621 hMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
622 fMCList[iCut]->Add(hMCDecayGammaEtapPt[iCut]);
623 hMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
624 fMCList[iCut]->Add(hMCDecayGammaPhiPt[iCut]);
625 hMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
626 fMCList[iCut]->Add(hMCDecayGammaSigmaPt[iCut]);
627 hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
628 fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
629 hMCConvGammaRSPt[iCut] = new TH1F("MC_ConvGamma_RS_Pt","MC_ConvGamma_RS_Pt",250,0,25);
630 fMCList[iCut]->Add(hMCConvGammaRSPt[iCut]);
633 hMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
634 fMCList[iCut]->Add(hMCConvGammaR[iCut]);
635 hMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",100,-4,4);
636 fMCList[iCut]->Add(hMCConvGammaEta[iCut]);
637 hMCConvGammaRSR[iCut] = new TH1F("MC_ConvGamma_RS_R","MC_ConvGamma_RS_R",800,0,200);
638 fMCList[iCut]->Add(hMCConvGammaRSR[iCut]);
639 hMCConvGammaRSEta[iCut] = new TH1F("MC_ConvGamma_RS_Eta","MC_ConvGamma_RS_Eta",100,-4,4);
640 fMCList[iCut]->Add(hMCConvGammaRSEta[iCut]);
643 if(fDoMesonAnalysis){
644 hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
645 hMCPi0Pt[iCut]->Sumw2();
646 fMCList[iCut]->Add(hMCPi0Pt[iCut]);
647 hMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
648 hMCPi0WOWeightPt[iCut]->Sumw2();
649 fMCList[iCut]->Add(hMCPi0WOWeightPt[iCut]);
651 hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
652 hMCEtaPt[iCut]->Sumw2();
653 fMCList[iCut]->Add(hMCEtaPt[iCut]);
654 hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
655 hMCPi0InAccPt[iCut]->Sumw2();
656 fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
657 hMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
658 hMCEtaInAccPt[iCut]->Sumw2();
659 fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
661 hMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",250,0,25,20,-1,1);
662 hMCPi0PtY[iCut]->Sumw2();
663 fMCList[iCut]->Add(hMCPi0PtY[iCut]);
664 hMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",250,0,25,20,-1,1);
665 hMCEtaPtY[iCut]->Sumw2();
666 fMCList[iCut]->Add(hMCEtaPtY[iCut]);
667 hMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",250,0,25);
668 hMCK0sPt[iCut]->Sumw2();
669 fMCList[iCut]->Add(hMCK0sPt[iCut]);
670 hMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",250,0,25);
671 hMCK0sWOWeightPt[iCut]->Sumw2();
672 fMCList[iCut]->Add(hMCK0sWOWeightPt[iCut]);
673 hMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",250,0,25,20,-1,1);
674 hMCK0sPtY[iCut]->Sumw2();
675 fMCList[iCut]->Add(hMCK0sPtY[iCut]);
680 fTrueList[iCut] = new TList();
681 fTrueList[iCut]->SetName(Form("%s_%s True histograms",cutstring.Data(),cutstringMeson.Data()));
682 fTrueList[iCut]->SetOwner(kTRUE);
683 fCutFolder[iCut]->Add(fTrueList[iCut]);
685 hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
686 fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
688 hESDCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
689 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
690 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
691 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
692 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
693 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
694 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
695 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
696 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
697 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
698 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
699 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
700 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
701 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
702 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
703 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
704 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
705 fTrueList[iCut]->Add(hESDCombinatorialPt[iCut]);
706 hESDTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
707 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaPt[iCut]);
708 hESDTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
709 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaPt[iCut]);
711 hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]
712 = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
713 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
714 hESDTrueSecondaryConvGammaFromXFromLambdaPt[iCut]
715 = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
716 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
718 hESDTrueDalitzPsiPairDeltaPhi[iCut]
719 = new TH2F("ESD_TrueDalitzPsiPairDeltaPhi_Pt", "ESD_TrueDalitzPsiPairDeltaPhi_Pt",400,-2,2,400,-2,2);
720 fTrueList[iCut]->Add(hESDTrueDalitzPsiPairDeltaPhi[iCut]);
722 hESDTrueGammaPsiPairDeltaPhi[iCut]
723 = new TH2F("ESD_TrueGammaPsiPairDeltaPhi_Pt", "ESD_TrueGammaPsiPairDeltaPhi_Pt",200,-2,2,400,-2,2);
724 fTrueList[iCut]->Add(hESDTrueGammaPsiPairDeltaPhi[iCut]);
727 hESDTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
728 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaESDPtMCPt[iCut]);
729 hESDTruePrimaryConvGammaRSESDPtMCPt[iCut]
730 = new TH2F("ESD_TruePrimaryConvGammaESD_RS_PtMCPt", "ESD_TruePrimaryConvGammaESD_RS_PtMCPt",250,0,25,250,0,25);
731 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaRSESDPtMCPt[iCut]);
733 if(fDoMesonAnalysis){
734 hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
735 fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
736 hESDTruePrimaryMotherInvMassPt[iCut]
737 = new TH2F("ESD_TruePrimaryMother_InvMass_Pt", "ESD_TruePrimaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
738 hESDTruePrimaryMotherInvMassPt[iCut]->Sumw2();
739 fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassPt[iCut]);
740 hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]
741 = new TH2F("ESD_TruePrimaryMotherW0Weights_InvMass_Pt", "ESD_TruePrimaryMotherW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
742 hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]->Sumw2();
743 fTrueList[iCut]->Add(hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]);
744 pESDTruePrimaryMotherWeightsInvMassPt[iCut]
745 = new TProfile2D("ESD_TruePrimaryMotherWeights_InvMass_Pt", "ESD_TruePrimaryMotherWeights_InvMass_Pt", 800,0,0.8,250,0,25);
746 pESDTruePrimaryMotherWeightsInvMassPt[iCut]->Sumw2();
747 fTrueList[iCut]->Add(pESDTruePrimaryMotherWeightsInvMassPt[iCut]);
748 hESDTrueSecondaryMotherInvMassPt[iCut]
749 = new TH2F("ESD_TrueSecondaryMother_InvMass_Pt", "ESD_TrueSecondaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
750 hESDTrueSecondaryMotherInvMassPt[iCut]->Sumw2();
751 fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
752 hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]
753 = new TH2F("ESD_TrueSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueSecondaryMotherFromK0s_InvMass_Pt",800,0,0.8,250,0,25);
754 hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]->Sumw2();
755 fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
756 hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]
757 = new TH2F("ESD_TrueSecondaryMotherFromEta_InvMass_Pt","ESD_TrueSecondaryMotherFromEta_InvMass_Pt",800,0,0.8,250,0,25);
758 fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]);
761 hESDTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0,25,1000,-1.,1.);
762 hESDTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
763 fTrueList[iCut]->Add(hESDTruePrimaryPi0MCPtResolPt[iCut]);
764 hESDTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0,25,1000,-1.,1.);
765 hESDTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
766 fTrueList[iCut]->Add(hESDTruePrimaryEtaMCPtResolPt[iCut]);
767 hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
768 fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
769 hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
770 fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
771 hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueDalitz_InvMass_Pt","ESD_TrueDalitz_InvMass_Pt",800,0,0.8,250,0,25);
772 fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
773 hESDTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
774 fTrueList[iCut]->Add(hESDTrueK0sWithPi0DaughterMCPt[iCut]);
775 hESDTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
776 fTrueList[iCut]->Add(hESDTrueEtaWithPi0DaughterMCPt[iCut]);
782 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
783 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
786 if((AliConversionCuts*)fV0Reader->GetConversionCuts())
787 if(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
788 fOutputContainer->Add(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
790 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
791 if(!((AliConversionCuts*)fCutArray->At(iCut))) continue;
792 if(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms()){
793 fCutFolder[iCut]->Add(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms());
795 if(fDoMesonAnalysis){
796 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
797 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
798 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
802 PostData(1, fOutputContainer);
804 //_____________________________________________________________________________
805 Bool_t AliAnalysisTaskGammaConvV1::Notify()
807 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
808 if(!((AliConversionCuts*)fCutArray->At(iCut))->GetDoEtaShift()){
809 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
810 continue; // No Eta Shift requested, continue
812 if(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
813 ((AliConversionCuts*)fCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
814 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
815 ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
819 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
820 (((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift());
821 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
822 ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
828 //_____________________________________________________________________________
829 void AliAnalysisTaskGammaConvV1::UserExec(Option_t *)
832 // Called for each event
834 Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
835 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
836 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
837 hNEvents[iCut]->Fill(eventQuality);
842 if(fIsMC) fMCEvent = MCEvent();
843 if(fMCEvent == NULL) fIsMC = kFALSE;
845 fInputEvent = InputEvent();
847 if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
848 fMCStack = fMCEvent->Stack();
849 if(fMCStack == NULL) fIsMC = kFALSE;
852 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
854 // ------------------- BeginEvent ----------------------------
856 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
857 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
858 fV0Reader->RelabelAODs(kTRUE);
860 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
862 Int_t eventNotAccepted =
863 ((AliConversionCuts*)fCutArray->At(iCut))
864 ->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
865 if(eventNotAccepted){
866 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
867 hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
871 if(eventQuality != 0){// Event Not Accepted
872 // cout << "event rejected due to: " <<eventQuality << endl;
873 hNEvents[iCut]->Fill(eventQuality);
877 hNEvents[iCut]->Fill(eventQuality); // Should be 0 here
878 hNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
879 if(((AliConversionCuts*)fCutArray->At(iCut))->IsHeavyIon() == 2) hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
880 else hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
883 // Process MC Particle
884 if(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection() != 0){
885 if(fInputEvent->IsA()==AliESDEvent::Class()){
886 ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
887 ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
890 else if(fInputEvent->IsA()==AliAODEvent::Class()){
891 ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
892 ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
896 if(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader()){
897 for(Int_t i = 0;i<(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
898 TString nameBin= hMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
899 if (nameBin.CompareTo("")== 0){
900 TString nameHeader = ((TObjString*)((TList*)((AliConversionCuts*)fCutArray->At(iCut))
901 ->GetAcceptedHeader())->At(i))->GetString();
902 hMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
909 if(fInputEvent->IsA()==AliESDEvent::Class())
910 ProcessMCParticles();
911 if(fInputEvent->IsA()==AliAODEvent::Class())
912 ProcessAODMCParticles();
915 ProcessPhotonCandidates(); // Process this cuts gammas
917 hNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
918 if(fDoMesonAnalysis){ // Meson Analysis
919 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
920 fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
921 fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
922 fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
923 fUnsmearedE = new Double_t[fGammaCandidates->GetEntries()];
925 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
926 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
927 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
928 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
929 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
930 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
934 CalculatePi0Candidates(); // Combine Gammas
935 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
936 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
937 CalculateBackground(); // Combinatorial Background
938 UpdateEventByEventData(); // Store Event for mixed Events
941 CalculateBackgroundRP(); // Combinatorial Background
942 fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
945 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
946 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
947 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
948 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
949 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
950 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
952 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
953 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
954 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
955 delete[] fUnsmearedE; fUnsmearedE = 0x0;
958 fGammaCandidates->Clear(); // delete this cuts good gammas
961 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
962 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
963 fV0Reader->RelabelAODs(kFALSE);
966 PostData(1, fOutputContainer);
968 //________________________________________________________________________
969 void AliAnalysisTaskGammaConvV1::ProcessPhotonCandidates()
972 TList *GammaCandidatesStepOne = new TList();
973 TList *GammaCandidatesStepTwo = new TList();
974 // Loop over Photon Candidates allocated by ReaderV1
975 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
976 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
977 if(!PhotonCandidate) continue;
978 fIsFromMBHeader = kTRUE;
979 if(fIsMC && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
980 Int_t isPosFromMBHeader
981 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
982 if(isPosFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
983 Int_t isNegFromMBHeader
984 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
985 if(isNegFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
987 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
990 if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
991 if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
992 !((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
993 fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
996 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
999 if(fInputEvent->IsA()==AliESDEvent::Class())
1000 ProcessTruePhotonCandidates(PhotonCandidate);
1001 if(fInputEvent->IsA()==AliAODEvent::Class())
1002 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1004 if (fIsFromMBHeader && fDoPhotonQA){
1005 if (fIsHeavyIon && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1006 fPtGamma = PhotonCandidate->Pt();
1007 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1008 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1009 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1010 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1011 tESDConvGammaPtDcazCat[fiCut]->Fill();
1012 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1013 fPtGamma = PhotonCandidate->Pt();
1014 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1015 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1016 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1017 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1018 tESDConvGammaPtDcazCat[fiCut]->Fill();
1021 } else if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1022 ((AliConversionCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1024 GammaCandidatesStepOne->Add(PhotonCandidate);
1025 } else if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1026 ((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1027 GammaCandidatesStepTwo->Add(PhotonCandidate);
1030 if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
1031 for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1032 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1033 if(!PhotonCandidate) continue;
1034 fIsFromMBHeader = kTRUE;
1035 if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1036 Int_t isPosFromMBHeader
1037 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1038 Int_t isNegFromMBHeader
1039 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1040 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1042 if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1043 if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1044 fGammaCandidates->Add(PhotonCandidate);
1045 if(fIsFromMBHeader){
1046 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1050 if(fInputEvent->IsA()==AliESDEvent::Class())
1051 ProcessTruePhotonCandidates(PhotonCandidate);
1052 if(fInputEvent->IsA()==AliAODEvent::Class())
1053 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1054 } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1056 if (fIsFromMBHeader && fDoPhotonQA){
1057 if (fIsHeavyIon && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1058 fPtGamma = PhotonCandidate->Pt();
1059 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1060 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1061 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1062 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1063 tESDConvGammaPtDcazCat[fiCut]->Fill();
1064 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1065 fPtGamma = PhotonCandidate->Pt();
1066 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1067 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1068 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1069 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1070 tESDConvGammaPtDcazCat[fiCut]->Fill();
1075 if(((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1076 for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1077 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1078 if(!PhotonCandidate) continue;
1079 fIsFromMBHeader = kTRUE;
1080 if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1081 Int_t isPosFromMBHeader
1082 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1083 Int_t isNegFromMBHeader
1084 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1085 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1087 if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
1088 fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1089 if(fIsFromMBHeader){
1090 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1093 if(fInputEvent->IsA()==AliESDEvent::Class())
1094 ProcessTruePhotonCandidates(PhotonCandidate);
1095 if(fInputEvent->IsA()==AliAODEvent::Class())
1096 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1098 if (fIsFromMBHeader){
1099 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1100 fPtGamma = PhotonCandidate->Pt();
1101 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1102 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1103 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1104 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1105 tESDConvGammaPtDcazCat[fiCut]->Fill();
1106 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1107 fPtGamma = PhotonCandidate->Pt();
1108 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1109 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1110 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1111 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1112 tESDConvGammaPtDcazCat[fiCut]->Fill();
1118 delete GammaCandidatesStepOne;
1119 GammaCandidatesStepOne = 0x0;
1120 delete GammaCandidatesStepTwo;
1121 GammaCandidatesStepTwo = 0x0;
1124 //________________________________________________________________________
1125 void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1128 Double_t magField = fInputEvent->GetMagneticField();
1129 if( magField < 0.0 ){
1136 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1137 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1138 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
1141 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1142 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1144 if(posDaughter->GetMother() != negDaughter->GetMother()){
1145 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1149 else if(posDaughter->GetMother() == -1){
1150 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1155 if(pdgCode[0]!=11 || pdgCode[1]!=11){
1157 return; //One Particle is not a electron
1159 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
1161 return; // Same Charge
1164 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
1165 AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1166 AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1167 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1169 if(Photon->GetPdgCode() != 22){
1170 hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1172 return; // Mother is no Photon
1175 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
1177 return;// check if the daughters come from a conversion
1179 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1184 if(fIsFromMBHeader)hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1185 hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1186 if(Photon->IsPrimary()){
1187 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1188 if(fIsFromMBHeader){
1190 hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1191 hESDTruePrimaryConvGammaRSESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1193 hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1194 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1197 if(fIsFromMBHeader){
1198 hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1200 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1201 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1203 hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1205 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1206 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1208 hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1210 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1211 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1218 //________________________________________________________________________
1219 void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1222 Double_t magField = fInputEvent->GetMagneticField();
1223 if( magField < 0.0 ){
1230 // Process True Photons
1231 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1232 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
1236 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1237 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1239 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
1240 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1243 else if(posDaughter->GetMother(0) == -1){
1244 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1248 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1250 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1252 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
1253 AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1254 AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1255 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1257 if(Photon->GetPdgCode() != 22){
1258 hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1259 return; // Mother is no Photon
1262 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1267 if(fIsFromMBHeader){
1268 hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1270 hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1271 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
1272 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1273 if(fIsFromMBHeader){
1275 hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1276 hESDTruePrimaryConvGammaRSESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1278 hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1279 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1282 if(fIsFromMBHeader){
1284 hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1285 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1286 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
1287 hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1290 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1291 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
1292 hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1295 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1296 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
1302 //________________________________________________________________________
1303 void AliAnalysisTaskGammaConvV1::ProcessAODMCParticles()
1306 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1308 // Loop over all primary MC particle
1309 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
1311 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
1312 if (!particle) continue;
1313 if (!particle->IsPrimary()) continue;
1315 Bool_t mcIsFromMB = kTRUE;
1316 Int_t isMCFromMBHeader = -1;
1317 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1319 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1320 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1321 if(isMCFromMBHeader != 2) mcIsFromMB = kFALSE;
1324 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
1325 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1326 if(particle->GetMother() >-1){ // Meson Decay Gamma
1327 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
1329 hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1332 hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1335 hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1338 hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1341 hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1344 hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1347 hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1352 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
1354 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
1355 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
1356 if(!tmpDaughter) continue;
1357 if(abs(tmpDaughter->GetPdgCode()) == 11){
1358 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
1361 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1363 hMCConvGammaR[fiCut]->Fill(rConv);
1364 hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1367 hMCConvGammaRSPt[fiCut]->Fill(particle->Pt());
1369 hMCConvGammaRSR[fiCut]->Fill(rConv);
1370 hMCConvGammaRSEta[fiCut]->Fill(particle->Eta());
1374 // Converted MC Gamma
1375 if(fDoMesonAnalysis){
1376 if(particle->GetPdgCode() == 310 && fDoMesonQA){
1377 Double_t mesonY = 10.;
1378 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1379 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1381 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1382 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1384 Float_t weightedK0s= 1;
1385 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1386 if (particle->Pt()>0.005){
1387 weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1388 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1391 hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1392 hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1393 hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1395 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1396 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1397 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
1398 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
1399 Float_t weighted= 1;
1400 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1401 if (particle->Pt()>0.005){
1402 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1403 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1406 Double_t mesonY = 10.;
1407 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1408 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1410 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1411 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1414 if(particle->GetPdgCode() == 111){
1415 hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1416 hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1417 if (fDoMesonQA) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1418 } else if(particle->GetPdgCode() == 221){
1419 hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1420 if (fDoMesonQA) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1423 // Check the acceptance for both gammas
1424 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
1425 ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) ){
1427 if(particle->GetPdgCode() == 111){
1428 hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1429 } else if(particle->GetPdgCode() == 221){
1430 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1437 //________________________________________________________________________
1438 void AliAnalysisTaskGammaConvV1::ProcessMCParticles()
1440 // Loop over all primary MC particle
1441 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
1442 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1443 if (!particle) continue;
1445 Bool_t mcIsFromMB = kTRUE;
1446 Int_t isMCFromMBHeader = -1;
1447 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1449 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1450 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1451 if(isMCFromMBHeader != 2) mcIsFromMB = kFALSE;
1454 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
1455 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1456 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
1457 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
1459 hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1462 hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1465 hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1468 hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1471 hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1474 hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1477 hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1482 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
1483 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1485 hMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
1486 hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1489 hMCConvGammaRSPt[fiCut]->Fill(particle->Pt());
1491 hMCConvGammaRSR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
1492 hMCConvGammaRSEta[fiCut]->Fill(particle->Eta());
1495 } // Converted MC Gamma
1496 if(fDoMesonAnalysis){
1497 if(particle->GetPdgCode() == 310 && fDoMesonQA){
1498 Double_t mesonY = 10.;
1499 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1500 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1502 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1503 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1505 Float_t weightedK0s= 1;
1506 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1507 if (particle->Pt()>0.005){
1508 weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1509 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1512 hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1513 hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1514 hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1516 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1517 ->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1518 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
1519 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
1521 Float_t weighted= 1;
1522 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1523 if (particle->Pt()>0.005){
1524 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1525 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1528 Double_t mesonY = 10.;
1529 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1530 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1532 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1533 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1536 if(particle->GetPdgCode() == 111){
1537 hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1538 hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1539 if (fDoMesonQA) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1540 } else if(particle->GetPdgCode() == 221){
1541 hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1542 if (fDoMesonQA) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1545 // Check the acceptance for both gammas
1546 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
1547 ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) ){
1549 if(particle->GetPdgCode() == 111){
1550 hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1551 } else if(particle->GetPdgCode() == 221){
1552 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1559 //________________________________________________________________________
1560 void AliAnalysisTaskGammaConvV1::CalculatePi0Candidates(){
1562 // Conversion Gammas
1563 if(fGammaCandidates->GetEntries()>1){
1564 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
1565 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
1566 if (gamma0==NULL) continue;
1567 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
1568 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
1569 //Check for same Electron ID
1570 if (gamma1==NULL) continue;
1571 if(gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelPositive() ||
1572 gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelNegative() ||
1573 gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelPositive() ||
1574 gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelNegative() ) continue;
1576 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
1577 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
1579 pi0cand->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
1580 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1581 ->MesonIsSelected(pi0cand,kTRUE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
1582 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1583 if(pi0cand->GetAlpha()<0.1)
1584 hESDMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
1585 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
1589 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
1590 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1591 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1592 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1594 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1598 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1599 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1600 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1602 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1605 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1606 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1611 if(fInputEvent->IsA()==AliESDEvent::Class())
1612 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1);
1613 if(fInputEvent->IsA()==AliAODEvent::Class())
1614 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1);
1617 fInvMass = pi0cand->M();
1618 fPt = pi0cand->Pt();
1619 if (abs(gamma0->GetDCAzToPrimVtx()) < abs(gamma1->GetDCAzToPrimVtx())){
1620 fDCAzGammaMin = gamma0->GetDCAzToPrimVtx();
1621 fDCAzGammaMax = gamma1->GetDCAzToPrimVtx();
1623 fDCAzGammaMin = gamma1->GetDCAzToPrimVtx();
1624 fDCAzGammaMax = gamma0->GetDCAzToPrimVtx();
1626 iFlag = pi0cand->GetMesonQuality();
1627 // cout << "gamma 0: " << gamma0->GetV0Index()<< "\t" << gamma0->GetPx() << "\t" << gamma0->GetPy() << "\t" << gamma0->GetPz() << "\t" << endl;
1628 // cout << "gamma 1: " << gamma1->GetV0Index()<< "\t"<< gamma1->GetPx() << "\t" << gamma1->GetPy() << "\t" << gamma1->GetPz() << "\t" << endl;
1629 // cout << "pi0: "<<fInvMass << "\t" << fPt <<"\t" << fDCAzGammaMin << "\t" << fDCAzGammaMax << "\t" << (Int_t)iFlag << "\t" << (Int_t)iMesonMCInfo <<endl;
1630 if (fIsHeavyIon == 1 && fPt > 0.399 && fPt < 20. ) {
1631 if (fInvMass > 0.08 && fInvMass < 0.2) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1632 if ((fInvMass > 0.45 && fInvMass < 0.6) && (fPt > 0.999 && fPt < 20.) )tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1633 } else if (fPt > 0.299 && fPt < 20. ) {
1634 if ( (fInvMass > 0.08 && fInvMass < 0.2) || (fInvMass > 0.45 && fInvMass < 0.6)) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1644 //______________________________________________________________________
1645 void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1647 // Process True Mesons
1648 AliStack *MCStack = fMCEvent->Stack();
1650 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
1651 Bool_t isTruePi0 = kFALSE;
1652 Bool_t isTrueEta = kFALSE;
1653 Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
1654 Int_t gamma0MotherLabel = -1;
1655 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1656 // Daughters Gamma 0
1657 TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
1658 TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
1659 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
1660 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1661 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1662 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1663 gamma0MotherLabel=gammaMC0->GetFirstMother();
1666 if(gammaMC0->GetPdgCode() ==111){ // Conversion but Pi0 Mother
1667 gamma0MotherLabel=-111;
1669 if(gammaMC0->GetPdgCode() ==221){ // Conversion but Eta Mother
1670 gamma0MotherLabel=-221;
1674 if(TrueGammaCandidate1->GetV0Index()<fInputEvent->GetNumberOfV0s()){
1675 Int_t gamma1MCLabel = TrueGammaCandidate1->GetMCParticleLabel(MCStack);
1676 Int_t gamma1MotherLabel = -1;
1677 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1678 // Daughters Gamma 1
1679 TParticle * negativeMC = (TParticle*)TrueGammaCandidate1->GetNegativeMCDaughter(MCStack);
1680 TParticle * positiveMC = (TParticle*)TrueGammaCandidate1->GetPositiveMCDaughter(MCStack);
1681 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
1682 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1683 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1684 if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
1685 gamma1MotherLabel=gammaMC1->GetFirstMother();
1688 if(gammaMC1->GetPdgCode() ==111){ // Conversion but Pi0 Mother
1689 gamma1MotherLabel=-111;
1691 if(gammaMC1->GetPdgCode() ==221){ // Conversion but Eta Mother
1692 gamma1MotherLabel=-221;
1696 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1697 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
1700 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
1704 if(isTruePi0 || isTrueEta){// True Pion or Eta
1705 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1706 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
1707 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetMother(0);
1708 Float_t weightedSec= 1;
1709 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1710 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
1711 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1713 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1715 if (secMotherLabel >-1){
1716 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1718 hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1719 if (fDoMesonQA)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
1720 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1722 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221){
1724 hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1725 if (fDoMesonQA)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
1726 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1729 }else{ // Only primary pi0 for efficiency calculation
1731 Float_t weighted= 1;
1732 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
1733 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
1734 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
1735 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
1738 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1739 hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1740 pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1742 if(isTruePi0){ // Only primary pi0 for resolution
1743 hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1745 if (isTrueEta){ // Only primary eta for resolution
1746 hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1751 else if(!isTruePi0 && !isTrueEta && fDoMesonQA){ // Background
1752 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
1753 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1755 } else { // No photon or without mother
1756 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1758 if((gamma0MotherLabel==-111 || gamma1MotherLabel==-111 || gamma0MotherLabel==-221 || gamma1MotherLabel==-221) ){
1761 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1767 //______________________________________________________________________
1768 void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1771 // Process True Mesons
1772 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1773 Bool_t isTruePi0 = kFALSE;
1774 Bool_t isTrueEta = kFALSE;
1776 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
1777 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
1780 Int_t gamma0MCLabel = -1;
1781 Int_t gamma0MotherLabel = -1;
1782 if(!positiveMC||!negativeMC)
1785 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
1786 gamma0MCLabel = positiveMC->GetMother();
1789 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1790 // Daughters Gamma 0
1791 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
1792 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1793 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ... // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1794 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1795 gamma0MotherLabel=gammaMC0->GetMother();
1798 if(gammaMC0->GetPdgCode() ==111){ // Conversion but Pi0 Mother
1799 gamma0MotherLabel=-111;
1801 if(gammaMC0->GetPdgCode() ==221){ // Conversion but Eta Mother
1802 gamma0MotherLabel=-221;
1806 positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelPositive()));
1807 negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelNegative()));
1809 Int_t gamma1MCLabel = -1;
1810 Int_t gamma1MotherLabel = -1;
1811 if(!positiveMC||!negativeMC)
1814 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
1815 gamma1MCLabel = positiveMC->GetMother();
1817 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1818 // Daughters Gamma 1
1819 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
1820 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1821 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ... // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1822 if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
1823 gamma1MotherLabel=gammaMC1->GetMother();
1826 if(gammaMC1->GetPdgCode() ==111){ // Conversion but Pi0 Mother
1827 gamma1MotherLabel=-111;
1829 if(gammaMC1->GetPdgCode() ==221){ // Conversion but Eta Mother
1830 gamma1MotherLabel=-221;
1834 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1835 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
1838 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
1842 if(isTruePi0 || isTrueEta){// True Pion or Eta
1843 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1845 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
1846 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
1847 Float_t weightedSec= 1;
1848 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
1849 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
1850 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1852 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1854 if (secMotherLabel >-1){
1855 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
1857 hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1858 if (fDoMesonQA)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
1859 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
1861 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221){
1863 hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1864 if (fDoMesonQA)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
1865 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
1868 }else{ // Only primary pi0 for efficiency calculation
1869 Float_t weighted= 1;
1871 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
1872 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
1873 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
1874 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
1877 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1878 hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1879 pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1882 if(isTruePi0){ // Only primary pi0 for resolution
1883 hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
1884 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
1886 if (isTrueEta){ // Only primary eta for resolution
1887 hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
1888 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
1893 else if(!isTruePi0 && !isTrueEta && fDoMesonQA){ // Background
1894 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
1896 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1897 } else { // No photon or without mother
1898 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1900 if((gamma0MotherLabel==-111 || gamma1MotherLabel==-111 || gamma0MotherLabel==-221 || gamma1MotherLabel==-221) ){
1903 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1907 //________________________________________________________________________
1908 void AliAnalysisTaskGammaConvV1::CalculateBackground(){
1910 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1913 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1914 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1916 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1919 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
1921 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
1922 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
1923 for(Int_t iCurrent2=iCurrent+1;iCurrent2<fGammaCandidates->GetEntries();iCurrent2++){
1924 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
1925 AliAODConversionPhoton currentEventGoodV02 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent2));
1927 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGProbability()){
1928 AliAODConversionMother *backgroundCandidateProb = new AliAODConversionMother(¤tEventGoodV0,¤tEventGoodV02);
1929 Double_t massBGprob = backgroundCandidateProb->M();
1930 if(massBGprob>0.1 && massBGprob<0.14){
1931 if(fRandom.Rndm()>fBGHandler[fiCut]->GetBGProb(zbin,mbin)){
1932 delete backgroundCandidateProb;
1936 delete backgroundCandidateProb;
1937 backgroundCandidateProb = 0x0;
1940 RotateParticle(¤tEventGoodV02);
1941 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,¤tEventGoodV02);
1942 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
1943 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1944 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
1945 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1946 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1947 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1949 delete backgroundCandidate;
1950 backgroundCandidate = 0x0;
1955 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
1957 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1958 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
1959 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
1960 if(fMoveParticleAccordingToVertex == kTRUE){
1961 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
1964 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
1965 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
1966 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
1967 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
1968 if(fMoveParticleAccordingToVertex == kTRUE){
1969 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
1972 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
1973 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
1974 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1975 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
1976 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1977 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1978 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1980 delete backgroundCandidate;
1981 backgroundCandidate = 0x0;
1987 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
1988 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
1989 if(previousEventV0s){
1990 if(fMoveParticleAccordingToVertex == kTRUE){
1991 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
1993 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
1994 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
1995 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
1997 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
1999 if(fMoveParticleAccordingToVertex == kTRUE){
2000 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2003 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2004 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2005 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2006 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2007 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2008 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2009 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2011 delete backgroundCandidate;
2012 backgroundCandidate = 0x0;
2020 //________________________________________________________________________
2021 void AliAnalysisTaskGammaConvV1::CalculateBackgroundRP(){
2023 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2025 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2026 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2028 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2033 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2034 // Correct for the number of rotations
2035 // BG is for rotation the same, except for factor NRotations
2036 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
2038 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2040 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2041 if (gamma0==NULL) continue;
2042 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
2043 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
2044 if (gamma1 == NULL) continue;
2045 if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
2046 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2048 RotateParticle(gamma1);
2050 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2051 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2052 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2053 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
2054 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2055 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2056 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2064 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
2066 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
2068 if(previousEventGammas){
2069 // test weighted background
2070 Double_t weight=1.0;
2071 // Correct for the number of eventmixing:
2072 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
2073 // real combinations (since you cannot combine a photon with its own)
2074 // but BG leads to N_{a}*N_{b} combinations
2075 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
2077 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2079 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2081 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
2083 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
2085 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2086 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2087 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2088 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
2089 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2090 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2091 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2099 //________________________________________________________________________
2100 void AliAnalysisTaskGammaConvV1::RotateParticle(AliAODConversionPhoton *gamma){
2101 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
2102 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
2103 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
2104 gamma->RotateZ(rotationValue);
2106 //________________________________________________________________________
2107 void AliAnalysisTaskGammaConvV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
2108 //see header file for documentation
2110 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
2111 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
2112 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
2114 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
2115 particle->SetConversionPoint(movedPlace);
2117 //________________________________________________________________________
2118 void AliAnalysisTaskGammaConvV1::UpdateEventByEventData(){
2119 //see header file for documentation
2120 if(fGammaCandidates->GetEntries() >0 ){
2121 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2122 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks());
2124 else{ // means we use #V0s for multiplicity
2125 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries());
2131 //________________________________________________________________________
2132 void AliAnalysisTaskGammaConvV1::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
2134 // 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
2135 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
2136 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
2137 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
2138 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
2139 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
2140 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
2141 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
2142 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
2143 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
2144 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
2145 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
2146 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
2147 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
2148 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
2149 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
2150 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
2151 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
2152 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
2153 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
2154 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
2155 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
2156 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
2157 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
2158 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
2159 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
2160 else {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
2162 //________________________________________________________________________
2163 void AliAnalysisTaskGammaConvV1::RelabelAODPhotonCandidates(Bool_t mode){
2165 // Relabeling For AOD Event
2167 // MCLabel -> AODMCLabel
2170 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
2171 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
2172 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
2173 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
2176 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
2177 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
2178 if(!PhotonCandidate) continue;
2179 if(!mode){// Back to ESD Labels
2180 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
2181 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
2182 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
2183 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
2186 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
2187 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
2188 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
2189 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
2191 Bool_t AODLabelPos = kFALSE;
2192 Bool_t AODLabelNeg = kFALSE;
2194 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
2195 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
2197 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
2198 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
2199 PhotonCandidate->SetLabelPositive(i);
2200 AODLabelPos = kTRUE;
2204 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
2205 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
2206 PhotonCandidate->SetLabelNegative(i);
2207 AODLabelNeg = kTRUE;
2210 if(AODLabelNeg && AODLabelPos){
2214 if(!AODLabelPos || !AODLabelNeg){
2215 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
2221 delete[] fMCStackPos;
2222 delete[] fMCStackNeg;
2223 delete[] fESDArrayPos;
2224 delete[] fESDArrayNeg;
2227 //________________________________________________________________________
2228 void AliAnalysisTaskGammaConvV1::Terminate(const Option_t *)
2231 //fOutputContainer->Print(); // Will crash on GRID