]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/GammaConv/AliAnalysisTaskGammaConvV1.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
including AOD compatibility
[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliAnalysisTaskGammaConvV1.cxx
CommitLineData
2bb2434e 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
0a2b2b4b 4 * Author: Martin Wilde, Daniel Lohner, Friederike Bock *
2bb2434e 5 * Version 1.0 *
6 * *
0a2b2b4b 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 *
10 * *
2bb2434e 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 **************************************************************************/
19
20////////////////////////////////////////////////
21//---------------------------------------------
ae947965 22
2bb2434e 23// Class used to do analysis on conversion pairs
24//---------------------------------------------
25///////////////////////////////////////////////
26#include "TChain.h"
27#include "TTree.h"
28#include "TH1F.h"
29#include "TH2F.h"
30#include "TH3F.h"
31#include "THnSparse.h"
32#include "TCanvas.h"
33#include "TNtuple.h"
34#include "AliAnalysisTask.h"
35#include "AliAnalysisManager.h"
36#include "AliESDEvent.h"
37#include "AliESDInputHandler.h"
38#include "AliMCEventHandler.h"
39#include "AliMCEvent.h"
40#include "AliMCParticle.h"
41#include "AliCentrality.h"
42#include "AliESDVZERO.h"
43#include "AliESDpid.h"
44#include "AliAnalysisTaskGammaConvV1.h"
45#include "AliVParticle.h"
46#include "AliESDtrackCuts.h"
47#include "AliKFVertex.h"
48#include "AliV0ReaderV1.h"
ca91a3e1 49#include "AliGenCocktailEventHeader.h"
e5b6e8a6 50#include "AliConversionAODBGHandlerRP.h"
ae947965 51#include "AliAODMCParticle.h"
52#include "AliAODMCHeader.h"
2bb2434e 53
54ClassImp(AliAnalysisTaskGammaConvV1)
55
56//________________________________________________________________________
57AliAnalysisTaskGammaConvV1::AliAnalysisTaskGammaConvV1(): AliAnalysisTaskSE(),
58 fV0Reader(NULL),
59 fBGHandler(NULL),
e5b6e8a6 60 fBGHandlerRP(NULL),
61 fInputEvent(NULL),
2bb2434e 62 fMCEvent(NULL),
63 fMCStack(NULL),
64 fCutFolder(NULL),
65 fESDList(NULL),
66 fBackList(NULL),
ca91a3e1 67 fMotherList(NULL),
0a2b2b4b 68 fMotherRapList(NULL),
2bb2434e 69 fTrueList(NULL),
0a2b2b4b 70 fTrueMotherRapList(NULL),
2bb2434e 71 fMCList(NULL),
ca91a3e1 72 fHeaderNameList(NULL),
ae947965 73 fTriggerNameList(NULL),
2bb2434e 74 fOutputContainer(0),
75 fReaderGammas(NULL),
a280ac15 76 fGammaCandidates(NULL),
2bb2434e 77 fCutArray(NULL),
78 fConversionCuts(NULL),
ca91a3e1 79 fMesonCutArray(NULL),
80 fMesonCuts(NULL),
2bb2434e 81 hESDConvGammaPt(NULL),
e5b6e8a6 82 hESDConvGammaR(NULL),
2bb2434e 83 hESDMotherInvMassPt(NULL),
84 sESDMotherInvMassPtZM(NULL),
0a2b2b4b 85 sESDMotherInvMassPtY(NULL),
2bb2434e 86 hESDMotherBackInvMassPt(NULL),
87 sESDMotherBackInvMassPtZM(NULL),
88 hESDMotherInvMassEalpha(NULL),
89 hMCAllGammaPt(NULL),
2bb2434e 90 hMCDecayGammaPi0Pt(NULL),
2bb2434e 91 hMCDecayGammaRhoPt(NULL),
2bb2434e 92 hMCDecayGammaEtaPt(NULL),
2bb2434e 93 hMCDecayGammaOmegaPt(NULL),
2bb2434e 94 hMCDecayGammaEtapPt(NULL),
2bb2434e 95 hMCDecayGammaPhiPt(NULL),
e5b6e8a6 96 hMCDecayGammaSigmaPt(NULL),
2bb2434e 97 hMCConvGammaPt(NULL),
ca91a3e1 98 hMCConvGammaR(NULL),
99 hMCConvGammaEta(NULL),
e5b6e8a6 100 hMCConvGammaRSPt(NULL),
101 hMCConvGammaRSR(NULL),
102 hMCConvGammaRSEta(NULL),
2bb2434e 103 hMCPi0Pt(NULL),
ae947965 104 hMCPi0WOWeightPt(NULL),
2bb2434e 105 hMCEtaPt(NULL),
106 hMCPi0InAccPt(NULL),
107 hMCEtaInAccPt(NULL),
0a2b2b4b 108 hMCPi0PtY(NULL),
109 hMCEtaPtY(NULL),
ae947965 110 hMCK0sPt(NULL),
111 hMCK0sWOWeightPt(NULL),
112 hMCK0sPtY(NULL),
2bb2434e 113 hESDTrueMotherInvMassPt(NULL),
a280ac15 114 hESDTruePrimaryMotherInvMassPt(NULL),
526074e4 115 hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
116 pESDTruePrimaryMotherWeightsInvMassPt(NULL),
0a2b2b4b 117 hESDTruePrimaryPi0MCPtResolPt(NULL),
118 hESDTruePrimaryEtaMCPtResolPt(NULL),
119 sESDTruePrimaryMotherInvMassPtY(NULL),
2bb2434e 120 hESDTrueSecondaryMotherInvMassPt(NULL),
2bb2434e 121 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
e5b6e8a6 122 hESDTrueK0sWithPi0DaughterMCPt(NULL),
123 hESDTrueSecondaryMotherFromEtaInvMassPt(NULL),
124 hESDTrueEtaWithPi0DaughterMCPt(NULL),
2bb2434e 125 hESDTrueBckGGInvMassPt(NULL),
126 hESDTrueBckContInvMassPt(NULL),
127 hESDTrueMotherDalitzInvMassPt(NULL),
2bb2434e 128 hESDTrueConvGammaPt(NULL),
e5b6e8a6 129 hESDCombinatorialPt(NULL),
2bb2434e 130 hESDTruePrimaryConvGammaPt(NULL),
ca91a3e1 131 hESDTruePrimaryConvGammaR(NULL),
132 hESDTruePrimaryConvGammaEta(NULL),
2bb2434e 133 hESDTruePrimaryConvGammaESDPtMCPt(NULL),
e5b6e8a6 134 hESDTruePrimaryConvGammaRSESDPtMCPt(NULL),
2bb2434e 135 hESDTrueSecondaryConvGammaPt(NULL),
e5b6e8a6 136 hESDTrueSecondaryConvGammaR(NULL),
2bb2434e 137 hESDTrueSecondaryConvGammaFromXFromK0sPt(NULL),
2bb2434e 138 hNEvents(NULL),
139 hNGoodESDTracks(NULL),
a280ac15 140 hNGammaCandidates(NULL),
2bb2434e 141 hNV0Tracks(NULL),
ae947965 142 hEtaShift(NULL),
2bb2434e 143 fRandom(0),
a280ac15 144 fnGammaCandidates(0),
2bb2434e 145 fUnsmearedPx(NULL),
146 fUnsmearedPy(NULL),
147 fUnsmearedPz(NULL),
148 fUnsmearedE(NULL),
ae947965 149 fMCStackPos(NULL),
150 fMCStackNeg(NULL),
e5b6e8a6 151 fnCuts(0),
152 fiCut(0),
153 fNumberOfESDTracks(0),
154 fMoveParticleAccordingToVertex(kTRUE),
2bb2434e 155 fIsHeavyIon(kFALSE),
e5b6e8a6 156 fDoMesonAnalysis(kTRUE),
0a2b2b4b 157 fDoMesonQA(kFALSE),
158 fDoPhotonQA(kFALSE),
ae947965 159 fIsFromMBHeader(kTRUE),
160 fIsMC(kFALSE)
2bb2434e 161{
a280ac15 162
2bb2434e 163}
164
165//________________________________________________________________________
166AliAnalysisTaskGammaConvV1::AliAnalysisTaskGammaConvV1(const char *name):
167 AliAnalysisTaskSE(name),
168 fV0Reader(NULL),
169 fBGHandler(NULL),
e5b6e8a6 170 fBGHandlerRP(NULL),
171 fInputEvent(NULL),
2bb2434e 172 fMCEvent(NULL),
173 fMCStack(NULL),
174 fCutFolder(NULL),
175 fESDList(NULL),
176 fBackList(NULL),
ca91a3e1 177 fMotherList(NULL),
0a2b2b4b 178 fMotherRapList(NULL),
2bb2434e 179 fTrueList(NULL),
0a2b2b4b 180 fTrueMotherRapList(NULL),
2bb2434e 181 fMCList(NULL),
ca91a3e1 182 fHeaderNameList(NULL),
ae947965 183 fTriggerNameList(NULL),
2bb2434e 184 fOutputContainer(0),
185 fReaderGammas(NULL),
a280ac15 186 fGammaCandidates(NULL),
2bb2434e 187 fCutArray(NULL),
188 fConversionCuts(NULL),
ca91a3e1 189 fMesonCutArray(NULL),
190 fMesonCuts(NULL),
2bb2434e 191 hESDConvGammaPt(NULL),
e5b6e8a6 192 hESDConvGammaR(NULL),
2bb2434e 193 hESDMotherInvMassPt(NULL),
194 sESDMotherInvMassPtZM(NULL),
0a2b2b4b 195 sESDMotherInvMassPtY(NULL),
2bb2434e 196 hESDMotherBackInvMassPt(NULL),
197 sESDMotherBackInvMassPtZM(NULL),
198 hESDMotherInvMassEalpha(NULL),
199 hMCAllGammaPt(NULL),
2bb2434e 200 hMCDecayGammaPi0Pt(NULL),
2bb2434e 201 hMCDecayGammaRhoPt(NULL),
2bb2434e 202 hMCDecayGammaEtaPt(NULL),
2bb2434e 203 hMCDecayGammaOmegaPt(NULL),
2bb2434e 204 hMCDecayGammaEtapPt(NULL),
2bb2434e 205 hMCDecayGammaPhiPt(NULL),
e5b6e8a6 206 hMCDecayGammaSigmaPt(NULL),
2bb2434e 207 hMCConvGammaPt(NULL),
ca91a3e1 208 hMCConvGammaR(NULL),
209 hMCConvGammaEta(NULL),
e5b6e8a6 210 hMCConvGammaRSPt(NULL),
211 hMCConvGammaRSR(NULL),
212 hMCConvGammaRSEta(NULL),
2bb2434e 213 hMCPi0Pt(NULL),
ae947965 214 hMCPi0WOWeightPt(NULL),
2bb2434e 215 hMCEtaPt(NULL),
216 hMCPi0InAccPt(NULL),
217 hMCEtaInAccPt(NULL),
0a2b2b4b 218 hMCPi0PtY(NULL),
219 hMCEtaPtY(NULL),
ae947965 220 hMCK0sPt(NULL),
221 hMCK0sWOWeightPt(NULL),
222 hMCK0sPtY(NULL),
2bb2434e 223 hESDTrueMotherInvMassPt(NULL),
a280ac15 224 hESDTruePrimaryMotherInvMassPt(NULL),
526074e4 225 hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
226 pESDTruePrimaryMotherWeightsInvMassPt(NULL),
0a2b2b4b 227 hESDTruePrimaryPi0MCPtResolPt(NULL),
228 hESDTruePrimaryEtaMCPtResolPt(NULL),
229 sESDTruePrimaryMotherInvMassPtY(NULL),
2bb2434e 230 hESDTrueSecondaryMotherInvMassPt(NULL),
2bb2434e 231 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
e5b6e8a6 232 hESDTrueK0sWithPi0DaughterMCPt(NULL),
233 hESDTrueSecondaryMotherFromEtaInvMassPt(NULL),
234 hESDTrueEtaWithPi0DaughterMCPt(NULL),
2bb2434e 235 hESDTrueBckGGInvMassPt(NULL),
236 hESDTrueBckContInvMassPt(NULL),
237 hESDTrueMotherDalitzInvMassPt(NULL),
2bb2434e 238 hESDTrueConvGammaPt(NULL),
e5b6e8a6 239 hESDCombinatorialPt(NULL),
2bb2434e 240 hESDTruePrimaryConvGammaPt(NULL),
ca91a3e1 241 hESDTruePrimaryConvGammaR(NULL),
242 hESDTruePrimaryConvGammaEta(NULL),
2bb2434e 243 hESDTruePrimaryConvGammaESDPtMCPt(NULL),
e5b6e8a6 244 hESDTruePrimaryConvGammaRSESDPtMCPt(NULL),
2bb2434e 245 hESDTrueSecondaryConvGammaPt(NULL),
e5b6e8a6 246 hESDTrueSecondaryConvGammaR(NULL),
2bb2434e 247 hESDTrueSecondaryConvGammaFromXFromK0sPt(NULL),
2bb2434e 248 hNEvents(NULL),
249 hNGoodESDTracks(NULL),
a280ac15 250 hNGammaCandidates(NULL),
2bb2434e 251 hNV0Tracks(NULL),
ae947965 252 hEtaShift(NULL),
2bb2434e 253 fRandom(0),
a280ac15 254 fnGammaCandidates(0),
2bb2434e 255 fUnsmearedPx(NULL),
256 fUnsmearedPy(NULL),
257 fUnsmearedPz(NULL),
258 fUnsmearedE(NULL),
ae947965 259 fMCStackPos(NULL),
260 fMCStackNeg(NULL),
e5b6e8a6 261 fnCuts(0),
262 fiCut(0),
263 fNumberOfESDTracks(0),
264 fMoveParticleAccordingToVertex(kTRUE),
2bb2434e 265 fIsHeavyIon(kFALSE),
e5b6e8a6 266 fDoMesonAnalysis(kTRUE),
0a2b2b4b 267 fDoMesonQA(kFALSE),
268 fDoPhotonQA(kFALSE),
ae947965 269 fIsFromMBHeader(kTRUE),
270 fIsMC(kFALSE)
2bb2434e 271{
a280ac15 272 // Define output slots here
2bb2434e 273 DefineOutput(1, TList::Class());
274}
275
276AliAnalysisTaskGammaConvV1::~AliAnalysisTaskGammaConvV1()
277{
a280ac15 278 if(fGammaCandidates){
279 delete fGammaCandidates;
280 fGammaCandidates = 0x0;
2bb2434e 281 }
282 if(fBGHandler){
283 delete[] fBGHandler;
284 fBGHandler = 0x0;
285 }
e5b6e8a6 286 if(fBGHandlerRP){
287 delete[] fBGHandlerRP;
288 fBGHandlerRP = 0x0;
289 }
2bb2434e 290}
291//___________________________________________________________
292void AliAnalysisTaskGammaConvV1::InitBack(){
293
2bb2434e 294 const Int_t nDim = 4;
11c1e680 295 Int_t nBins[nDim] = {800,250,7,4};
2bb2434e 296 Double_t xMin[nDim] = {0,0, 0,0};
11c1e680 297 Double_t xMax[nDim] = {0.8,25,7,4};
2bb2434e 298
299 sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
300 sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
301
302 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
e5b6e8a6 303 fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
2bb2434e 304 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
e5b6e8a6 305 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
306 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
307 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
11c1e680 308
309 Int_t collisionSystem = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(0,1));
310 Int_t centMin = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(1,1));
311 Int_t centMax = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(2,1));
312
313 if(collisionSystem == 1 || collisionSystem == 2 ||
314 collisionSystem == 5 || collisionSystem == 8 ||
315 collisionSystem == 9){
316 centMin = centMin*10;
317 centMax = centMax*10;
318 }
319 else if(collisionSystem == 3 || collisionSystem == 6){
320 centMin = centMin*5;
321 centMax = centMax*5;
322 }
323 else if(collisionSystem == 4 || collisionSystem == 7){
324 centMin = ((centMin*5)+45);
325 centMax = ((centMax*5)+45);
326 }
327
e5b6e8a6 328 fBackList[iCut] = new TList();
329 fBackList[iCut]->SetName(Form("%s_%s Back histograms",cutstring.Data(),cutstringMeson.Data()));
330 fBackList[iCut]->SetOwner(kTRUE);
331 fCutFolder[iCut]->Add(fBackList[iCut]);
332
333 sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
e5b6e8a6 334 fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
335
336 fMotherList[iCut] = new TList();
337 fMotherList[iCut]->SetName(Form("%s_%s Mother histograms",cutstring.Data(),cutstringMeson.Data()));
338 fMotherList[iCut]->SetOwner(kTRUE);
339 fCutFolder[iCut]->Add(fMotherList[iCut]);
340
341 sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
e5b6e8a6 342 fMotherList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
343
344 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
11c1e680 345 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
346 collisionSystem,centMin,centMax,
347 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
348 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity());
349 fBGHandlerRP[iCut] = NULL;
e5b6e8a6 350 }
351 else{
352 fBGHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
353 ((AliConversionCuts*)fCutArray->At(fiCut))->IsHeavyIon(),
354 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
355 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
356 fBGHandler[iCut] = NULL;
357 }
2bb2434e 358 }
359 }
360}
361//________________________________________________________________________
362void AliAnalysisTaskGammaConvV1::UserCreateOutputObjects()
363{
364
365 // Create histograms
366 if(fOutputContainer != NULL){
367 delete fOutputContainer;
368 fOutputContainer = NULL;
369 }
370 if(fOutputContainer == NULL){
371 fOutputContainer = new TList();
372 fOutputContainer->SetOwner(kTRUE);
373 }
374
375 // Array of current cut's gammas
a280ac15 376 fGammaCandidates = new TList();
2bb2434e 377
378 fCutFolder = new TList*[fnCuts];
379 fESDList = new TList*[fnCuts];
380 fBackList = new TList*[fnCuts];
ca91a3e1 381 fMotherList = new TList*[fnCuts];
ae947965 382 fTriggerNameList = new TList*[fnCuts];
2bb2434e 383 hNEvents = new TH1I*[fnCuts];
384 hNGoodESDTracks = new TH1I*[fnCuts];
a280ac15 385 hNGammaCandidates = new TH1I*[fnCuts];
ca91a3e1 386 hNV0Tracks = new TH1I*[fnCuts];
ae947965 387 hEtaShift = new TH1F*[fnCuts];
0a2b2b4b 388 hESDConvGammaPt = new TH1F*[fnCuts];
ae947965 389
0a2b2b4b 390 if (fDoPhotonQA){
391 hESDConvGammaR = new TH1F*[fnCuts];
392 }
393 const Int_t nDim = 3;
394 Int_t nBins[nDim] = {800,250,40};
395 Double_t xMin[nDim] = {0,0, -1};
396 Double_t xMax[nDim] = {0.8,25,1};
ca91a3e1 397
2bb2434e 398 if(fDoMesonAnalysis){
399 hESDMotherInvMassPt = new TH2F*[fnCuts];
400 hESDMotherBackInvMassPt = new TH2F*[fnCuts];
401 hESDMotherInvMassEalpha = new TH2F*[fnCuts];
0a2b2b4b 402 if (fDoMesonQA){
403 fMotherRapList = new TList*[fnCuts];
404 sESDMotherInvMassPtY = new THnSparseF*[fnCuts];
405 }
2bb2434e 406 }
0a2b2b4b 407
2bb2434e 408 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
409
410 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
e5b6e8a6 411 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
412
2bb2434e 413 fCutFolder[iCut] = new TList();
ca91a3e1 414 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s",cutstring.Data(),cutstringMeson.Data()));
2bb2434e 415 fCutFolder[iCut]->SetOwner(kTRUE);
416 fOutputContainer->Add(fCutFolder[iCut]);
417 fESDList[iCut] = new TList();
ca91a3e1 418 fESDList[iCut]->SetName(Form("%s_%s ESD histograms",cutstring.Data(),cutstringMeson.Data()));
2bb2434e 419 fESDList[iCut]->SetOwner(kTRUE);
a280ac15 420 fCutFolder[iCut]->Add(fESDList[iCut]);
2bb2434e 421
e5b6e8a6 422 hNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
423 hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
424 hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
425 hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
426 hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
427 hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
428 hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
429 hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
430 hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
431 hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
2bb2434e 432 fESDList[iCut]->Add(hNEvents[iCut]);
433 if(fIsHeavyIon) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",3000,0,3000);
434 else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
435 fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
a280ac15 436 if(fIsHeavyIon) hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
437 else hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
438 fESDList[iCut]->Add(hNGammaCandidates[iCut]);
e5b6e8a6 439 if(fIsHeavyIon) hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
2bb2434e 440 else hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2000,0,2000);
441 fESDList[iCut]->Add(hNV0Tracks[iCut]);
ae947965 442 hEtaShift[iCut] = new TH1F("Eta Shift","Eta Shift",1, -0.5,0.5);
443 fESDList[iCut]->Add(hEtaShift[iCut]);
2bb2434e 444 hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
445 fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
0a2b2b4b 446
447 if (fDoPhotonQA){
448 hESDConvGammaR[iCut] = new TH1F("ESD_ConvGamma_R","ESD_ConvGamma_R",800,0,200);
449 fESDList[iCut]->Add(hESDConvGammaR[iCut]);
450 }
2bb2434e 451
452 if(fDoMesonAnalysis){
e5b6e8a6 453 hESDMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
2bb2434e 454 fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
e5b6e8a6 455 hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
2bb2434e 456 fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
e5b6e8a6 457 hESDMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
2bb2434e 458 fESDList[iCut]->Add(hESDMotherInvMassEalpha[iCut]);
0a2b2b4b 459 if (fDoMesonQA){
460 fMotherRapList[iCut] = new TList();
461 fMotherRapList[iCut]->SetName(Form("%s_%s Mother Y histograms",cutstring.Data(),cutstringMeson.Data()));
462 fMotherRapList[iCut]->SetOwner(kTRUE);
463 fCutFolder[iCut]->Add(fMotherRapList[iCut]);
464 sESDMotherInvMassPtY[iCut] = new THnSparseF("Mother_InvMass_Pt_Y","Mother_InvMass_Pt_Y",nDim,nBins,xMin,xMax);
465 fMotherRapList[iCut]->Add(sESDMotherInvMassPtY[iCut]);
466 }
2bb2434e 467 }
468
0a2b2b4b 469
2bb2434e 470 }
2bb2434e 471 if(fDoMesonAnalysis){
472 InitBack(); // Init Background Handler
473 }
474
ae947965 475 if(fIsMC){
2bb2434e 476 // MC Histogramms
477 fMCList = new TList*[fnCuts];
478 // True Histogramms
479 fTrueList = new TList*[fnCuts];
ca91a3e1 480 // Selected Header List
481 fHeaderNameList = new TList*[fnCuts];
ae947965 482
2bb2434e 483 hMCAllGammaPt = new TH1F*[fnCuts];
2bb2434e 484 hMCDecayGammaPi0Pt = new TH1F*[fnCuts];
2bb2434e 485 hMCDecayGammaRhoPt = new TH1F*[fnCuts];
ca91a3e1 486 hMCDecayGammaEtaPt = new TH1F*[fnCuts];
2bb2434e 487 hMCDecayGammaOmegaPt = new TH1F*[fnCuts];
2bb2434e 488 hMCDecayGammaEtapPt = new TH1F*[fnCuts];
2bb2434e 489 hMCDecayGammaPhiPt = new TH1F*[fnCuts];
e5b6e8a6 490 hMCDecayGammaSigmaPt = new TH1F*[fnCuts];
2bb2434e 491 hMCConvGammaPt = new TH1F*[fnCuts];
e5b6e8a6 492 hMCConvGammaRSPt = new TH1F*[fnCuts];
2bb2434e 493 hESDTrueConvGammaPt = new TH1F*[fnCuts];
e5b6e8a6 494
495 hESDCombinatorialPt = new TH2F*[fnCuts];
ca91a3e1 496 hESDTruePrimaryConvGammaPt = new TH1F*[fnCuts];
2bb2434e 497 hESDTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
e5b6e8a6 498 hESDTruePrimaryConvGammaRSESDPtMCPt = new TH2F*[fnCuts];
2bb2434e 499 hESDTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
0a2b2b4b 500
2bb2434e 501 hESDTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
ca91a3e1 502
0a2b2b4b 503 if (fDoPhotonQA){
504 hMCConvGammaR = new TH1F*[fnCuts];
505 hMCConvGammaEta = new TH1F*[fnCuts];
506 hMCConvGammaRSR = new TH1F*[fnCuts];
507 hMCConvGammaRSEta = new TH1F*[fnCuts];
508 hESDTruePrimaryConvGammaR = new TH1F*[fnCuts];
509 hESDTruePrimaryConvGammaEta = new TH1F*[fnCuts];
510 hESDTrueSecondaryConvGammaR = new TH1F*[fnCuts];
511 }
512
2bb2434e 513 if(fDoMesonAnalysis){
514 hMCPi0Pt = new TH1F*[fnCuts];
ae947965 515 hMCPi0WOWeightPt = new TH1F*[fnCuts];
2bb2434e 516 hMCEtaPt = new TH1F*[fnCuts];
517 hMCPi0InAccPt = new TH1F*[fnCuts];
518 hMCEtaInAccPt = new TH1F*[fnCuts];
2bb2434e 519
520 hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
a280ac15 521 hESDTruePrimaryMotherInvMassPt = new TH2F*[fnCuts];
526074e4 522 hESDTruePrimaryMotherW0WeightingInvMassPt = new TH2F*[fnCuts];
523 pESDTruePrimaryMotherWeightsInvMassPt = new TProfile2D*[fnCuts];
2bb2434e 524 hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
2bb2434e 525 hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
e5b6e8a6 526 hESDTrueSecondaryMotherFromEtaInvMassPt = new TH2F*[fnCuts];
0a2b2b4b 527 if (fDoMesonQA){
528 hMCPi0PtY = new TH2F*[fnCuts];
529 hMCEtaPtY = new TH2F*[fnCuts];
ae947965 530 hMCK0sPt = new TH1F*[fnCuts];
531 hMCK0sWOWeightPt = new TH1F*[fnCuts];
532 hMCK0sPtY = new TH2F*[fnCuts];
0a2b2b4b 533 hESDTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
534 hESDTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
535 hESDTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
536 hESDTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
537 hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
538 hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
539 hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
540 fTrueMotherRapList = new TList*[fnCuts];
541 sESDTruePrimaryMotherInvMassPtY = new THnSparseF*[fnCuts];
542 }
2bb2434e 543 }
544
545 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
546 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
e5b6e8a6 547 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
548
549 fMCList[iCut] = new TList();
ca91a3e1 550 fMCList[iCut]->SetName(Form("%s_%s MC histograms",cutstring.Data(),cutstringMeson.Data()));
2bb2434e 551 fMCList[iCut]->SetOwner(kTRUE);
552 fCutFolder[iCut]->Add(fMCList[iCut]);
553
554 hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
555 fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
2bb2434e 556 hMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
557 fMCList[iCut]->Add(hMCDecayGammaPi0Pt[iCut]);
2bb2434e 558 hMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
559 fMCList[iCut]->Add(hMCDecayGammaRhoPt[iCut]);
2bb2434e 560 hMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
561 fMCList[iCut]->Add(hMCDecayGammaEtaPt[iCut]);
2bb2434e 562 hMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
563 fMCList[iCut]->Add(hMCDecayGammaOmegaPt[iCut]);
2bb2434e 564 hMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
565 fMCList[iCut]->Add(hMCDecayGammaEtapPt[iCut]);
2bb2434e 566 hMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
567 fMCList[iCut]->Add(hMCDecayGammaPhiPt[iCut]);
e5b6e8a6 568 hMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
569 fMCList[iCut]->Add(hMCDecayGammaSigmaPt[iCut]);
2bb2434e 570 hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
571 fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
e5b6e8a6 572 hMCConvGammaRSPt[iCut] = new TH1F("MC_ConvGamma_RS_Pt","MC_ConvGamma_RS_Pt",250,0,25);
573 fMCList[iCut]->Add(hMCConvGammaRSPt[iCut]);
0a2b2b4b 574
575 if (fDoPhotonQA){
576 hMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
577 fMCList[iCut]->Add(hMCConvGammaR[iCut]);
578 hMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",100,-4,4);
579 fMCList[iCut]->Add(hMCConvGammaEta[iCut]);
580 hMCConvGammaRSR[iCut] = new TH1F("MC_ConvGamma_RS_R","MC_ConvGamma_RS_R",800,0,200);
581 fMCList[iCut]->Add(hMCConvGammaRSR[iCut]);
582 hMCConvGammaRSEta[iCut] = new TH1F("MC_ConvGamma_RS_Eta","MC_ConvGamma_RS_Eta",100,-4,4);
583 fMCList[iCut]->Add(hMCConvGammaRSEta[iCut]);
584 }
e5b6e8a6 585
2bb2434e 586 if(fDoMesonAnalysis){
587 hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
0a2b2b4b 588 hMCPi0Pt[iCut]->Sumw2();
2bb2434e 589 fMCList[iCut]->Add(hMCPi0Pt[iCut]);
ae947965 590 hMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
591 hMCPi0WOWeightPt[iCut]->Sumw2();
592 fMCList[iCut]->Add(hMCPi0WOWeightPt[iCut]);
593
2bb2434e 594 hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
0a2b2b4b 595 hMCEtaPt[iCut]->Sumw2();
2bb2434e 596 fMCList[iCut]->Add(hMCEtaPt[iCut]);
597 hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
0a2b2b4b 598 hMCPi0InAccPt[iCut]->Sumw2();
2bb2434e 599 fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
600 hMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
0a2b2b4b 601 hMCEtaInAccPt[iCut]->Sumw2();
2bb2434e 602 fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
0a2b2b4b 603 if (fDoMesonQA){
604 hMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",250,0,25,20,-1,1);
605 hMCPi0PtY[iCut]->Sumw2();
606 fMCList[iCut]->Add(hMCPi0PtY[iCut]);
607 hMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",250,0,25,20,-1,1);
608 hMCEtaPtY[iCut]->Sumw2();
609 fMCList[iCut]->Add(hMCEtaPtY[iCut]);
ae947965 610 hMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",250,0,25);
611 hMCK0sPt[iCut]->Sumw2();
612 fMCList[iCut]->Add(hMCK0sPt[iCut]);
613 hMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",250,0,25);
614 hMCK0sWOWeightPt[iCut]->Sumw2();
615 fMCList[iCut]->Add(hMCK0sWOWeightPt[iCut]);
616 hMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",250,0,25,20,-1,1);
617 hMCK0sPtY[iCut]->Sumw2();
618 fMCList[iCut]->Add(hMCK0sPtY[iCut]);
619
0a2b2b4b 620 }
621
2bb2434e 622 }
623 fTrueList[iCut] = new TList();
ca91a3e1 624 fTrueList[iCut]->SetName(Form("%s_%s True histograms",cutstring.Data(),cutstringMeson.Data()));
2bb2434e 625 fTrueList[iCut]->SetOwner(kTRUE);
626 fCutFolder[iCut]->Add(fTrueList[iCut]);
627
628 hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
629 fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
e5b6e8a6 630
631 hESDCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
632 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
633 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
634 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
635 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
636 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
637 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
638 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
639 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
640 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
641 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
642 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
643 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
644 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
645 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
646 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
647 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
648 fTrueList[iCut]->Add(hESDCombinatorialPt[iCut]);
2bb2434e 649 hESDTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
650 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaPt[iCut]);
2bb2434e 651 hESDTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
652 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaPt[iCut]);
0a2b2b4b 653
e5b6e8a6 654 hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]
655 = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
2bb2434e 656 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
2bb2434e 657 hESDTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
658 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaESDPtMCPt[iCut]);
e5b6e8a6 659 hESDTruePrimaryConvGammaRSESDPtMCPt[iCut]
660 = new TH2F("ESD_TruePrimaryConvGammaESD_RS_PtMCPt", "ESD_TruePrimaryConvGammaESD_RS_PtMCPt",250,0,25,250,0,25);
661 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaRSESDPtMCPt[iCut]);
662
0a2b2b4b 663 if (fDoPhotonQA){
664 hESDTruePrimaryConvGammaR[iCut] = new TH1F("ESD_TruePrimaryConvGamma_R","ESD_TruePrimaryConvGamma_R",800,0,200);
665 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaR[iCut]);
666 hESDTrueSecondaryConvGammaR[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_R","ESD_TrueSecondaryConvGamma_R",800,0,200);
667 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaR[iCut]);
668 hESDTruePrimaryConvGammaEta[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Eta","ESD_TruePrimaryConvGamma_Eta",100,-4,4);
669 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaEta[iCut]);
670 }
2bb2434e 671
672 if(fDoMesonAnalysis){
e5b6e8a6 673 hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
2bb2434e 674 fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
a280ac15 675 hESDTruePrimaryMotherInvMassPt[iCut]
676 = new TH2F("ESD_TruePrimaryMother_InvMass_Pt", "ESD_TruePrimaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
0a2b2b4b 677 hESDTruePrimaryMotherInvMassPt[iCut]->Sumw2();
a280ac15 678 fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassPt[iCut]);
526074e4 679 hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]
680 = new TH2F("ESD_TruePrimaryMotherW0Weights_InvMass_Pt", "ESD_TruePrimaryMotherW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
681 hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]->Sumw2();
682 fTrueList[iCut]->Add(hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]);
683 pESDTruePrimaryMotherWeightsInvMassPt[iCut]
684 = new TProfile2D("ESD_TruePrimaryMotherWeights_InvMass_Pt", "ESD_TruePrimaryMotherWeights_InvMass_Pt", 800,0,0.8,250,0,25);
685 pESDTruePrimaryMotherWeightsInvMassPt[iCut]->Sumw2();
686 fTrueList[iCut]->Add(pESDTruePrimaryMotherWeightsInvMassPt[iCut]);
e5b6e8a6 687 hESDTrueSecondaryMotherInvMassPt[iCut]
688 = new TH2F("ESD_TrueSecondaryMother_InvMass_Pt", "ESD_TrueSecondaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
ae947965 689 hESDTrueSecondaryMotherInvMassPt[iCut]->Sumw2();
2bb2434e 690 fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
e5b6e8a6 691 hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]
692 = new TH2F("ESD_TrueSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueSecondaryMotherFromK0s_InvMass_Pt",800,0,0.8,250,0,25);
ae947965 693 hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]->Sumw2();
2bb2434e 694 fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
e5b6e8a6 695 hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]
696 = new TH2F("ESD_TrueSecondaryMotherFromEta_InvMass_Pt","ESD_TrueSecondaryMotherFromEta_InvMass_Pt",800,0,0.8,250,0,25);
697 fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]);
0a2b2b4b 698
699 if (fDoMesonQA){
700 hESDTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0,25,1000,-1.,1.);
701 hESDTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
702 fTrueList[iCut]->Add(hESDTruePrimaryPi0MCPtResolPt[iCut]);
703 hESDTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0,25,1000,-1.,1.);
704 hESDTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
705 fTrueList[iCut]->Add(hESDTruePrimaryEtaMCPtResolPt[iCut]);
706 hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
707 fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
708 hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
709 fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
710 hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueDalitz_InvMass_Pt","ESD_TrueDalitz_InvMass_Pt",800,0,0.8,250,0,25);
711 fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
712 hESDTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
713 fTrueList[iCut]->Add(hESDTrueK0sWithPi0DaughterMCPt[iCut]);
714 hESDTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
715 fTrueList[iCut]->Add(hESDTrueEtaWithPi0DaughterMCPt[iCut]);
716
717 fTrueMotherRapList[iCut] = new TList();
718 fTrueMotherRapList[iCut]->SetName(Form("%s_%s True Mother Y histograms",cutstring.Data(),cutstringMeson.Data()));
719 fTrueMotherRapList[iCut]->SetOwner(kTRUE);
720 fCutFolder[iCut]->Add(fTrueMotherRapList[iCut]);
721 sESDTruePrimaryMotherInvMassPtY[iCut] = new THnSparseF("TruePrimaryMother_InvMass_Pt_Y","TruePrimaryMother_InvMass_Pt_Y",nDim,nBins,xMin,xMax);
722 fTrueMotherRapList[iCut]->Add(sESDTruePrimaryMotherInvMassPtY[iCut]);
723
724 }
ca91a3e1 725 }
a280ac15 726 }
727 }
728
a280ac15 729 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
730 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
e5b6e8a6 731
a280ac15 732 if(fV0Reader)
733 if((AliConversionCuts*)fV0Reader->GetConversionCuts())
734 if(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
735 fOutputContainer->Add(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
e5b6e8a6 736
a280ac15 737 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
738 if(!((AliConversionCuts*)fCutArray->At(iCut))) continue;
739 if(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms()){
740 fCutFolder[iCut]->Add(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms());
741 }
742 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
743 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
744 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
2bb2434e 745 }
746 }
747
748 PostData(1, fOutputContainer);
749}
11c1e680 750//_____________________________________________________________________________
751Bool_t AliAnalysisTaskGammaConvV1::Notify()
752{
ccfa8c0d 753 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
ae947965 754 if(!((AliConversionCuts*)fCutArray->At(iCut))->GetDoEtaShift()){
ae947965 755 hEtaShift[iCut]->Fill(0.,0.);
756 continue; // No Eta Shift requested, continue
757 }
758
ccfa8c0d 759 if(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
ae947965 760 ((AliConversionCuts*)fCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
761 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
762 // hEtaShift[iCut]->Fill(0);
ccfa8c0d 763 ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
764 continue;
765 }
766 else{
767 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
768 (((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift());
ae947965 769 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
770 // hEtaShift[iCut]->Fill(-0.5);
ccfa8c0d 771 ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
11c1e680 772 }
773 }
ccfa8c0d 774
11c1e680 775 return kTRUE;
776}
2bb2434e 777//_____________________________________________________________________________
778void AliAnalysisTaskGammaConvV1::UserExec(Option_t *)
779{
780 //
781 // Called for each event
782 //
2bb2434e 783 Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
e5b6e8a6 784 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
2bb2434e 785 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
786 hNEvents[iCut]->Fill(eventQuality);
787 }
788 return;
789 }
790
ae947965 791 if(fIsMC) fMCEvent = MCEvent();
792 fInputEvent = InputEvent();
793
794 if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){
e5b6e8a6 795 fMCStack = fMCEvent->Stack();
796 }
e5b6e8a6 797
2bb2434e 798 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
ae947965 799 CountTracks(); // Estimate Event Multiplicity
2bb2434e 800
e5b6e8a6 801 // ------------------- BeginEvent ----------------------------
802
ae947965 803 if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class())
804 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
805
2bb2434e 806 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
807 fiCut = iCut;
e5b6e8a6 808
809 Int_t eventNotAccepted =
810 ((AliConversionCuts*)fCutArray->At(iCut))
811 ->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
812 if(eventNotAccepted){
ccfa8c0d 813 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
e5b6e8a6 814 hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
2bb2434e 815 continue;
816 }
e5b6e8a6 817
818 if(eventQuality != 0){// Event Not Accepted
ccfa8c0d 819 // cout << "event rejected due to: " <<eventQuality << endl;
e5b6e8a6 820 hNEvents[iCut]->Fill(eventQuality);
821 continue;
822 }
2bb2434e 823
a280ac15 824 hNEvents[iCut]->Fill(eventQuality); // Should be 0 here
2bb2434e 825 hNGoodESDTracks[iCut]->Fill(fNumberOfESDTracks);
ccfa8c0d 826 if(((AliConversionCuts*)fCutArray->At(iCut))->IsHeavyIon() == 2) hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
827 else hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
e5b6e8a6 828
ae947965 829 if(fMCEvent){
830 // Process MC Particle
ca91a3e1 831 if(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection() != 0){
ae947965 832 if(fInputEvent->IsA()==AliESDEvent::Class()){
833 ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
834 ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
835 fMCEvent);
836 }
837 else if(fInputEvent->IsA()==AliAODEvent::Class()){
838 ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
839 ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
840 fInputEvent);
841 }
ca91a3e1 842 }
ae947965 843 }
844 if(fMCEvent){
845 if(fInputEvent->IsA()==AliESDEvent::Class())
846 ProcessMCParticles();
847 if(fInputEvent->IsA()==AliAODEvent::Class())
848 ProcessAODMCParticles();
2bb2434e 849 }
a280ac15 850
2bb2434e 851 ProcessPhotonCandidates(); // Process this cuts gammas
852
a280ac15 853 hNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
2bb2434e 854 if(fDoMesonAnalysis){ // Meson Analysis
ca91a3e1 855 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fMCEvent){
a280ac15 856 fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
857 fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
858 fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
859 fUnsmearedE = new Double_t[fGammaCandidates->GetEntries()];
860
861 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
862 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
863 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
864 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
865 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
866 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
2bb2434e 867 }
868 }
ca91a3e1 869
2bb2434e 870 CalculatePi0Candidates(); // Combine Gammas
e5b6e8a6 871 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
872 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
873 CalculateBackground(); // Combinatorial Background
874 UpdateEventByEventData(); // Store Event for mixed Events
875 }
876 else{
877 CalculateBackgroundRP(); // Combinatorial Background
a280ac15 878 fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
e5b6e8a6 879 }
880 }
ca91a3e1 881 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fMCEvent){
a280ac15 882 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
883 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
884 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
885 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
886 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
2bb2434e 887 }
888 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
889 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
890 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
891 delete[] fUnsmearedE; fUnsmearedE = 0x0;
892 }
893 }
a280ac15 894 fGammaCandidates->Clear(); // delete this cuts good gammas
ca91a3e1 895 }
e5b6e8a6 896
ae947965 897 if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class())
898 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
899
2bb2434e 900 PostData(1, fOutputContainer);
901}
902//________________________________________________________________________
903void AliAnalysisTaskGammaConvV1::ProcessPhotonCandidates()
904{
905 Int_t nV0 = 0;
a280ac15 906 TList *GammaCandidatesStepOne = new TList();
907 TList *GammaCandidatesStepTwo = new TList();
2bb2434e 908 // Loop over Photon Candidates allocated by ReaderV1
909 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
910 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
911 if(!PhotonCandidate) continue;
a280ac15 912 fIsFromMBHeader = kTRUE;
ca91a3e1 913 if(fMCEvent && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
a280ac15 914 Int_t isPosFromMBHeader
ae947965 915 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
a280ac15 916 if(isPosFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
917 Int_t isNegFromMBHeader
ae947965 918 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
a280ac15 919 if(isNegFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
920
921 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
ca91a3e1 922 }
923
e5b6e8a6 924 if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
ca91a3e1 925 if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
e5b6e8a6 926 !((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
a280ac15 927 fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
e5b6e8a6 928
a280ac15 929 if(fIsFromMBHeader){
e5b6e8a6 930 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
0a2b2b4b 931 if (fDoPhotonQA)hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
e5b6e8a6 932 }
2bb2434e 933 if(fMCEvent){
ae947965 934 if(fInputEvent->IsA()==AliESDEvent::Class())
935 ProcessTruePhotonCandidates(PhotonCandidate);
936 if(fInputEvent->IsA()==AliAODEvent::Class())
937 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
2bb2434e 938 }
939 }
940 else if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
941 ((AliConversionCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
942 nV0++;
a280ac15 943 GammaCandidatesStepOne->Add(PhotonCandidate);
2bb2434e 944 }
ca91a3e1 945 else if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
2bb2434e 946 ((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
a280ac15 947 GammaCandidatesStepTwo->Add(PhotonCandidate);
2bb2434e 948 }
949 }
950 if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
a280ac15 951 for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
952 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
2bb2434e 953 if(!PhotonCandidate) continue;
a280ac15 954 fIsFromMBHeader = kTRUE;
ae947965 955 if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
a280ac15 956 Int_t isPosFromMBHeader
ae947965 957 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
a280ac15 958 Int_t isNegFromMBHeader
ae947965 959 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
a280ac15 960 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
e5b6e8a6 961 }
a280ac15 962 if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
ca91a3e1 963 if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
a280ac15 964 fGammaCandidates->Add(PhotonCandidate);
965 if(fIsFromMBHeader){
e5b6e8a6 966 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
0a2b2b4b 967 if (fDoPhotonQA)hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
e5b6e8a6 968 }
ae947965 969 }
970 if(fMCEvent){
971 if(fInputEvent->IsA()==AliESDEvent::Class())
2bb2434e 972 ProcessTruePhotonCandidates(PhotonCandidate);
ae947965 973 if(fInputEvent->IsA()==AliAODEvent::Class())
974 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
2bb2434e 975 }
a280ac15 976 else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
2bb2434e 977 }
978 }
979 if(((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
a280ac15 980 for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
981 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
2bb2434e 982 if(!PhotonCandidate) continue;
a280ac15 983 fIsFromMBHeader = kTRUE;
ae947965 984 if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
a280ac15 985 Int_t isPosFromMBHeader
ae947965 986 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
a280ac15 987 Int_t isNegFromMBHeader
ae947965 988 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
a280ac15 989 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
e5b6e8a6 990 }
a280ac15 991 if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
992 fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
993 if(fIsFromMBHeader){
e5b6e8a6 994 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
0a2b2b4b 995 if (fDoPhotonQA)hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
e5b6e8a6 996 }
2bb2434e 997 if(fMCEvent){
ae947965 998 if(fInputEvent->IsA()==AliESDEvent::Class())
999 ProcessTruePhotonCandidates(PhotonCandidate);
1000 if(fInputEvent->IsA()==AliAODEvent::Class())
1001 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
2bb2434e 1002 }
1003 }
1004 }
1005
a280ac15 1006 delete GammaCandidatesStepOne;
1007 GammaCandidatesStepOne = 0x0;
1008 delete GammaCandidatesStepTwo;
1009 GammaCandidatesStepTwo = 0x0;
2bb2434e 1010
ae947965 1011}
1012//________________________________________________________________________
1013void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1014{
1015
1016 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1017 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1018 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
1019
1020 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1021 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1022
1023 if(posDaughter->GetMother() != negDaughter->GetMother()){
1024 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1025 return;
1026 }
1027 else if(posDaughter->GetMother() == -1){
1028 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1029 return;
1030 }
1031
1032 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1033
1034 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1035
1036 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5) return;// check if the daughters come from a conversion
1037 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1038
1039 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
1040 if(Photon->GetPdgCode() != 22) return; // Mother is no Photon
1041
1042 // True Photon
1043 if(fIsFromMBHeader)hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1044
1045 if(Photon->IsPrimary()){ // OR ISPHYSICALPRIMARY() ???????
1046 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1047 if(fIsFromMBHeader){
1048 hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1049 if (fDoPhotonQA){
1050 hESDTruePrimaryConvGammaR[fiCut]->Fill(TruePhotonCandidate->GetConversionRadius());
1051 hESDTruePrimaryConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1052 }
1053 hESDTruePrimaryConvGammaRSESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1054 }
1055 hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1056 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1057 }
1058 else{
1059 if(fIsFromMBHeader){
1060 hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1061 if (fDoPhotonQA) hESDTrueSecondaryConvGammaR[fiCut]->Fill(TruePhotonCandidate->GetConversionRadius());
1062 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1063 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1064 hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1065 }
1066 }
1067 }
1068
2bb2434e 1069}
1070//________________________________________________________________________
1071void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1072{
1073 // Process True Photons
ae947965 1074 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1075 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
2bb2434e 1076
1077 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
e5b6e8a6 1078
1079 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1080
1081 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
ae947965 1082 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
ca91a3e1 1083 return;
1084 }
1085 else if(posDaughter->GetMother(0) == -1){
ae947965 1086 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2bb2434e 1087 return;
1088 }
e5b6e8a6 1089
1090 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1091
2bb2434e 1092 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
e5b6e8a6 1093
2bb2434e 1094 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1095
ae947965 1096 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
2bb2434e 1097 if(Photon->GetPdgCode() != 22) return; // Mother is no Photon
1098
ca91a3e1 1099 // True Photon
a280ac15 1100 if(fIsFromMBHeader)hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
ca91a3e1 1101
ae947965 1102 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
ca91a3e1 1103 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
a280ac15 1104 if(fIsFromMBHeader){
e5b6e8a6 1105 hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
0a2b2b4b 1106 if (fDoPhotonQA){
1107 hESDTruePrimaryConvGammaR[fiCut]->Fill(TruePhotonCandidate->GetConversionRadius());
1108 hESDTruePrimaryConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1109 }
e5b6e8a6 1110 hESDTruePrimaryConvGammaRSESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1111 }
1112 hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1113 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
ca91a3e1 1114 }
1115 else{
a280ac15 1116 if(fIsFromMBHeader){
e5b6e8a6 1117 hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
0a2b2b4b 1118 if (fDoPhotonQA) hESDTrueSecondaryConvGammaR[fiCut]->Fill(TruePhotonCandidate->GetConversionRadius());
ae947965 1119 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1120 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
e5b6e8a6 1121 hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1122 }
ca91a3e1 1123 }
1124 }
2bb2434e 1125}
1126//________________________________________________________________________
ae947965 1127void AliAnalysisTaskGammaConvV1::ProcessAODMCParticles()
1128{
1129
1130 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1131
1132 // Loop over all primary MC particle
1133 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
1134
1135 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
1136 if (!particle) continue;
1137 if (!particle->IsPrimary()) continue;
1138
1139 Bool_t mcIsFromMB = kTRUE;
1140 Int_t isMCFromMBHeader = -1;
1141 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1142 isMCFromMBHeader
1143 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1144 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1145 if(isMCFromMBHeader != 2) mcIsFromMB = kFALSE;
1146 }
1147
1148 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
1149 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1150 if(particle->GetMother() >-1){ // Meson Decay Gamma
1151 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
1152 case 111: // Pi0
1153 hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1154 break;
1155 case 113: // Rho0
1156 hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1157 break;
1158 case 221: // Eta
1159 hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1160 break;
1161 case 223: // Omega
1162 hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1163 break;
1164 case 331: // Eta'
1165 hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1166 break;
1167 case 333: // Phi
1168 hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1169 break;
1170 case 3212: // Sigma
1171 hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1172 break;
1173 }
1174 }
1175 }
1176 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
1177 Double_t rConv = 0;
1178 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
1179 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
1180 if(!tmpDaughter) continue;
1181 if(abs(tmpDaughter->GetPdgCode()) == 11){
1182 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
1183 }
1184 }
1185 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1186 if (fDoPhotonQA){
1187 hMCConvGammaR[fiCut]->Fill(rConv);
1188 hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1189 }
1190 if(mcIsFromMB){
1191 hMCConvGammaRSPt[fiCut]->Fill(particle->Pt());
1192 if (fDoPhotonQA){
1193 hMCConvGammaRSR[fiCut]->Fill(rConv);
1194 hMCConvGammaRSEta[fiCut]->Fill(particle->Eta());
1195 }
1196 }
1197 }
1198 // Converted MC Gamma
1199 if(fDoMesonAnalysis){
1200 if(particle->GetPdgCode() == 310 && fDoMesonQA){
1201 Double_t mesonY = 10.;
1202 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1203 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1204 } else{
1205 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1206 }
1207 Float_t weightedK0s= 1;
1208 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1209 if (particle->Pt()>0.005){
1210 weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1211 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1212 }
1213 }
1214 hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1215 hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1216 hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1217 }
1218 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1219 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
1220 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
1221 Float_t weighted= 1;
1222 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1223 if (particle->Pt()>0.005){
1224 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1225 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1226 }
1227 }
1228 Double_t mesonY = 10.;
1229 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1230 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1231 } else{
1232 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1233 }
1234
1235 if(particle->GetPdgCode() == 111){
1236 hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1237 hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1238 if (fDoMesonQA) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1239 } else if(particle->GetPdgCode() == 221){
1240 hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1241 if (fDoMesonQA) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1242 }
1243
1244 // Check the acceptance for both gammas
1245 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
1246 ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) ){
1247
1248 if(particle->GetPdgCode() == 111){
1249 hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1250 } else if(particle->GetPdgCode() == 221){
1251 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1252 }
1253 }
1254 }
1255 }
1256 }
1257}
1258//________________________________________________________________________
2bb2434e 1259void AliAnalysisTaskGammaConvV1::ProcessMCParticles()
1260{
2bb2434e 1261 // Loop over all primary MC particle
1262 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
1263 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1264 if (!particle) continue;
1265
a280ac15 1266 Bool_t mcIsFromMB = kTRUE;
1267 Int_t isMCFromMBHeader = -1;
ca91a3e1 1268 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
a280ac15 1269 isMCFromMBHeader
ae947965 1270 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
a280ac15 1271 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1272 if(isMCFromMBHeader != 2) mcIsFromMB = kFALSE;
ca91a3e1 1273 }
1274
1275 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
1276 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1277 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
1278 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
1279 case 111: // Pi0
1280 hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1281 break;
1282 case 113: // Rho0
1283 hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1284 break;
1285 case 221: // Eta
1286 hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1287 break;
1288 case 223: // Omega
1289 hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1290 break;
1291 case 331: // Eta'
1292 hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1293 break;
1294 case 333: // Phi
1295 hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1296 break;
e5b6e8a6 1297 case 3212: // Sigma
a280ac15 1298 hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
e5b6e8a6 1299 break;
ca91a3e1 1300 }
1301 }
1302 }
1303 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
1304 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
0a2b2b4b 1305 if (fDoPhotonQA){
1306 hMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
1307 hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1308 }
a280ac15 1309 if(mcIsFromMB){
e5b6e8a6 1310 hMCConvGammaRSPt[fiCut]->Fill(particle->Pt());
0a2b2b4b 1311 if (fDoPhotonQA){
1312 hMCConvGammaRSR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
1313 hMCConvGammaRSEta[fiCut]->Fill(particle->Eta());
1314 }
e5b6e8a6 1315 }
ca91a3e1 1316 } // Converted MC Gamma
1317 if(fDoMesonAnalysis){
ae947965 1318 if(particle->GetPdgCode() == 310 && fDoMesonQA){
1319 Double_t mesonY = 10.;
1320 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1321 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1322 } else{
1323 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1324 }
1325 Float_t weightedK0s= 1;
1326 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1327 if (particle->Pt()>0.005){
1328 weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1329 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1330 }
1331 }
1332 hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1333 hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1334 hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1335 }
11c1e680 1336 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
e5b6e8a6 1337 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
1338 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
1339
a280ac15 1340 Float_t weighted= 1;
ae947965 1341 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
a280ac15 1342 if (particle->Pt()>0.005){
ae947965 1343 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1344 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
a280ac15 1345 }
1346 }
0a2b2b4b 1347 Double_t mesonY = 10.;
1348 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
11c1e680 1349 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
0a2b2b4b 1350 } else{
11c1e680 1351 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
0a2b2b4b 1352 }
1353
a280ac15 1354 if(particle->GetPdgCode() == 111){
1355 hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
ae947965 1356 hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
0a2b2b4b 1357 if (fDoMesonQA) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
a280ac15 1358 } else if(particle->GetPdgCode() == 221){
1359 hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
0a2b2b4b 1360 if (fDoMesonQA) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
ae947965 1361 }
e5b6e8a6 1362
ca91a3e1 1363 // Check the acceptance for both gammas
e5b6e8a6 1364 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
1365 ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) ){
0a2b2b4b 1366
a280ac15 1367 if(particle->GetPdgCode() == 111){
1368 hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1369 } else if(particle->GetPdgCode() == 221){
1370 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1371 }
ca91a3e1 1372 }
1373 }
1374 }
2bb2434e 1375 }
1376}
1377//________________________________________________________________________
1378void AliAnalysisTaskGammaConvV1::CalculatePi0Candidates(){
1379
1380 // Conversion Gammas
a280ac15 1381 if(fGammaCandidates->GetEntries()>1){
1382 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
1383 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
0a2b2b4b 1384 if (gamma0==NULL) continue;
a280ac15 1385 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
1386 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
2bb2434e 1387 //Check for same Electron ID
0a2b2b4b 1388 if (gamma1==NULL) continue;
2bb2434e 1389 if(gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelPositive() ||
1390 gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelNegative() ||
1391 gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelPositive() ||
1392 gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelNegative() ) continue;
1393
1394 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
1395 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
1396
11c1e680 1397 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2bb2434e 1398 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
e5b6e8a6 1399 if(pi0cand->GetAlpha()<0.1)
2bb2434e 1400 hESDMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
0a2b2b4b 1401 if (fDoMesonQA){
11c1e680 1402 Double_t sparesFill2[3] = {pi0cand->M(),pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()};
0a2b2b4b 1403 sESDMotherInvMassPtY[fiCut]->Fill(sparesFill2,1);
1404 }
e5b6e8a6 1405 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
1406 Int_t zbin = 0;
1407 Int_t mbin = 0;
a280ac15 1408
e5b6e8a6 1409 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
1410 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1411 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1412 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1413 } else {
a280ac15 1414 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
e5b6e8a6 1415 }
1416 }
1417 else{
1418 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1419 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1420 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1421 } else {
a280ac15 1422 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
e5b6e8a6 1423 }
1424 }
1425 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1426 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2bb2434e 1427 }
ae947965 1428
1429
2bb2434e 1430 if(fMCEvent){
ae947965 1431 if(fInputEvent->IsA()==AliESDEvent::Class())
1432 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1);
1433 if(fInputEvent->IsA()==AliAODEvent::Class())
1434 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1);
2bb2434e 1435 }
1436 }
1437 delete pi0cand;
1438 pi0cand=0x0;
1439 }
1440 }
1441 }
1442}
1443//______________________________________________________________________
1444void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1445{
1446 // Process True Mesons
1447 AliStack *MCStack = fMCEvent->Stack();
1448
e5b6e8a6 1449 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2bb2434e 1450 Bool_t isTruePi0 = kFALSE;
1451 Bool_t isTrueEta = kFALSE;
1452 Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
1453 Int_t gamma0MotherLabel = -1;
1454 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1455 // Daughters Gamma 0
1456 TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
1457 TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
1458 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
e5b6e8a6 1459 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2bb2434e 1460 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1461 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1462 gamma0MotherLabel=gammaMC0->GetFirstMother();
1463 }
1464 }
1465 if(gammaMC0->GetPdgCode() ==111){ // Conversion but Pi0 Mother
1466 gamma0MotherLabel=-111;
1467 }
1468 if(gammaMC0->GetPdgCode() ==221){ // Conversion but Eta Mother
1469 gamma0MotherLabel=-221;
1470 }
1471 }
1472 }
e5b6e8a6 1473 if(TrueGammaCandidate1->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2bb2434e 1474 Int_t gamma1MCLabel = TrueGammaCandidate1->GetMCParticleLabel(MCStack);
1475 Int_t gamma1MotherLabel = -1;
1476 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1477 // Daughters Gamma 1
1478 TParticle * negativeMC = (TParticle*)TrueGammaCandidate1->GetNegativeMCDaughter(MCStack);
1479 TParticle * positiveMC = (TParticle*)TrueGammaCandidate1->GetPositiveMCDaughter(MCStack);
1480 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
e5b6e8a6 1481 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2bb2434e 1482 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1483 if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
1484 gamma1MotherLabel=gammaMC1->GetFirstMother();
1485 }
1486 }
1487 if(gammaMC1->GetPdgCode() ==111){ // Conversion but Pi0 Mother
1488 gamma1MotherLabel=-111;
1489 }
1490 if(gammaMC1->GetPdgCode() ==221){ // Conversion but Eta Mother
1491 gamma1MotherLabel=-221;
1492 }
1493 }
1494 }
1495 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1496 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
1497 isTruePi0=kTRUE;
1498 }
1499 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
1500 isTrueEta=kTRUE;
1501 }
1502 }
e5b6e8a6 1503 if(isTruePi0 || isTrueEta){// True Pion or Eta
ca91a3e1 1504 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
e5b6e8a6 1505
1506 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
ae947965 1507 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetMother(0);
1508 Float_t weightedSec= 1;
1509 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1510 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
1511 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1512 }
1513 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1514
1515 if (secMotherLabel >-1){
1516 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1517 hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
0a2b2b4b 1518 if (fDoMesonQA)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
ae947965 1519 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
e5b6e8a6 1520 }
ae947965 1521 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221){
1522 hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
0a2b2b4b 1523 if (fDoMesonQA)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
ae947965 1524 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
ca91a3e1 1525 }
1526 }
0a2b2b4b 1527 }else{ // Only primary pi0 for efficiency calculation
a280ac15 1528 Float_t weighted= 1;
ae947965 1529 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
a280ac15 1530 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
ae947965 1531 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
1532// cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
a280ac15 1533 }
1534 }
1535 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
526074e4 1536 hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1537 pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
0a2b2b4b 1538 if (fDoMesonQA){
11c1e680 1539 Double_t sparesFill[3] = {Pi0Candidate->M(),Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()};
0a2b2b4b 1540 sESDTruePrimaryMotherInvMassPtY[fiCut]->Fill(sparesFill,1);
1541 if(isTruePi0){ // Only primary pi0 for resolution
1542 hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1543 }
1544 if (isTrueEta){ // Only primary eta for resolution
1545 hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1546 }
ca91a3e1 1547 }
1548 }
2bb2434e 1549 }
0a2b2b4b 1550 else if(!isTruePi0 && !isTrueEta && fDoMesonQA){ // Background
2bb2434e 1551 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
1552 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1553 } else { // No photon or without mother
1554 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1555 }
ca91a3e1 1556 if((gamma0MotherLabel==-111 || gamma1MotherLabel==-111 || gamma0MotherLabel==-221 || gamma1MotherLabel==-221) ){
2bb2434e 1557 // Dalitz
2bb2434e 1558 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1559 }
1560 }
1561 }
1562 }
1563}
ae947965 1564//______________________________________________________________________
1565void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1566{
1567
1568 // Process True Mesons
1569 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1570 Bool_t isTruePi0 = kFALSE;
1571 Bool_t isTrueEta = kFALSE;
1572
1573 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
1574 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
2bb2434e 1575
ae947965 1576 Int_t gamma0MCLabel = -1;
1577 Int_t gamma0MotherLabel = -1;
1578 if(!positiveMC||!negativeMC)
1579 return;
1580
1581 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
1582 gamma0MCLabel = positiveMC->GetMother();
1583 }
1584
1585 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1586 // Daughters Gamma 0
1587 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
1588 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1589 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ... // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1590 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1591 gamma0MotherLabel=gammaMC0->GetMother();
1592 }
1593 }
1594 if(gammaMC0->GetPdgCode() ==111){ // Conversion but Pi0 Mother
1595 gamma0MotherLabel=-111;
1596 }
1597 if(gammaMC0->GetPdgCode() ==221){ // Conversion but Eta Mother
1598 gamma0MotherLabel=-221;
1599 }
1600 }
1601 }
1602 positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelPositive()));
1603 negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelNegative()));
1604
1605 Int_t gamma1MCLabel = -1;
1606 Int_t gamma1MotherLabel = -1;
1607 if(!positiveMC||!negativeMC)
1608 return;
1609
1610 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
1611 gamma1MCLabel = positiveMC->GetMother();
1612 }
1613 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1614 // Daughters Gamma 1
1615 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
1616 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1617 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ... // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1618 if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
1619 gamma1MotherLabel=gammaMC1->GetMother();
1620 }
1621 }
1622 if(gammaMC1->GetPdgCode() ==111){ // Conversion but Pi0 Mother
1623 gamma1MotherLabel=-111;
1624 }
1625 if(gammaMC1->GetPdgCode() ==221){ // Conversion but Eta Mother
1626 gamma1MotherLabel=-221;
1627 }
1628 }
1629 }
1630 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1631 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
1632 isTruePi0=kTRUE;
1633 }
1634 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
1635 isTrueEta=kTRUE;
1636 }
1637 }
1638 if(isTruePi0 || isTrueEta){// True Pion or Eta
1639 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1640
1641 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
1642 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
1643 Float_t weightedSec= 1;
1644 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
1645 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
1646 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1647 }
1648 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1649
1650 if (secMotherLabel >-1){
1651 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
1652 hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1653 if (fDoMesonQA)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
1654 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
1655 }
1656 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221){
1657 hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1658 if (fDoMesonQA)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
1659 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
1660 }
1661 }
1662 }else{ // Only primary pi0 for efficiency calculation
1663 Float_t weighted= 1;
1664 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
1665 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
1666 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
1667 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
1668 }
1669 }
1670 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1671
1672 if (fDoMesonQA){
1673 Double_t sparesFill[3] = {Pi0Candidate->M(),Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()};
1674 sESDTruePrimaryMotherInvMassPtY[fiCut]->Fill(sparesFill,1);
1675 if(isTruePi0){ // Only primary pi0 for resolution
1676 hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
1677 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
1678 }
1679 if (isTrueEta){ // Only primary eta for resolution
1680 hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
1681 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
1682 }
1683 }
1684 }
1685 }
1686 else if(!isTruePi0 && !isTrueEta && fDoMesonQA){ // Background
1687 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
1688 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1689 } else { // No photon or without mother
1690 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1691 }
1692 if((gamma0MotherLabel==-111 || gamma1MotherLabel==-111 || gamma0MotherLabel==-221 || gamma1MotherLabel==-221) ){
1693 // Dalitz
1694 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1695 }
1696 }
1697}
2bb2434e 1698//________________________________________________________________________
1699void AliAnalysisTaskGammaConvV1::CalculateBackground(){
1700
e5b6e8a6 1701 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2bb2434e 1702 Int_t mbin = 0;
1703
ca91a3e1 1704 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2bb2434e 1705 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1706 } else {
a280ac15 1707 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2bb2434e 1708 }
1709
ca91a3e1 1710 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2bb2434e 1711
a280ac15 1712 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
1713 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
1714 for(Int_t iCurrent2=iCurrent+1;iCurrent2<fGammaCandidates->GetEntries();iCurrent2++){
e5b6e8a6 1715 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
a280ac15 1716 AliAODConversionPhoton currentEventGoodV02 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent2));
2bb2434e 1717
ca91a3e1 1718 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGProbability()){
2bb2434e 1719 AliAODConversionMother *backgroundCandidateProb = new AliAODConversionMother(&currentEventGoodV0,&currentEventGoodV02);
1720 Double_t massBGprob = backgroundCandidateProb->M();
1721 if(massBGprob>0.1 && massBGprob<0.14){
1722 if(fRandom.Rndm()>fBGHandler[fiCut]->GetBGProb(zbin,mbin)){
1723 delete backgroundCandidateProb;
1724 continue;
1725 }
1726 }
1727 delete backgroundCandidateProb;
1728 backgroundCandidateProb = 0x0;
1729 }
1730
1731 RotateParticle(&currentEventGoodV02);
1732 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&currentEventGoodV02);
11c1e680 1733 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2bb2434e 1734 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
e5b6e8a6 1735 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2bb2434e 1736 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1737 }
1738 delete backgroundCandidate;
1739 backgroundCandidate = 0x0;
1740 }
1741 }
1742 }
ca91a3e1 1743 }else{
2bb2434e 1744 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
1745
ca91a3e1 1746 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2bb2434e 1747 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
1748 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
1749 if(fMoveParticleAccordingToVertex == kTRUE){
1750 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
1751 }
1752
a280ac15 1753 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
1754 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2bb2434e 1755 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
1756 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
1757 if(fMoveParticleAccordingToVertex == kTRUE){
1758 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
1759 }
1760
1761 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
11c1e680 1762 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2bb2434e 1763 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
e5b6e8a6 1764 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2bb2434e 1765 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1766 }
1767 delete backgroundCandidate;
1768 backgroundCandidate = 0x0;
1769 }
1770 }
1771 }
1772 }
1773 else{
1774 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
1775 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
1776 if(previousEventV0s){
1777 if(fMoveParticleAccordingToVertex == kTRUE){
1778 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
1779 }
a280ac15 1780 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
1781 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2bb2434e 1782 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
1783
1784 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
1785
1786 if(fMoveParticleAccordingToVertex == kTRUE){
1787 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
1788 }
1789
1790 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
1791
11c1e680 1792 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2bb2434e 1793 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
e5b6e8a6 1794 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2bb2434e 1795 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1796 }
1797 delete backgroundCandidate;
1798 backgroundCandidate = 0x0;
1799 }
1800 }
1801 }
1802 }
1803 }
1804 }
1805}
e5b6e8a6 1806//________________________________________________________________________
1807void AliAnalysisTaskGammaConvV1::CalculateBackgroundRP(){
1808
1809 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1810 Int_t mbin = 0;
1811 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1812 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1813 } else {
a280ac15 1814 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
e5b6e8a6 1815 }
1816
1817
1818 //Rotation Method
1819 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
1820 // Correct for the number of rotations
1821 // BG is for rotation the same, except for factor NRotations
1822 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
1823
a280ac15 1824 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
e5b6e8a6 1825
a280ac15 1826 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
0a2b2b4b 1827 if (gamma0==NULL) continue;
a280ac15 1828 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
1829 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
0a2b2b4b 1830 if (gamma1 == NULL) continue;
e5b6e8a6 1831 if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
1832 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
1833
1834 RotateParticle(gamma1);
1835
1836 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
1837
11c1e680 1838 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
e5b6e8a6 1839 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
1840 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
1841 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
e5b6e8a6 1842 }
1843 }
1844 }
1845 }
1846 }
1847 else{
1848 // Do Event Mixing
a280ac15 1849 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
e5b6e8a6 1850
a280ac15 1851 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
e5b6e8a6 1852
1853 if(previousEventGammas){
1854 // test weighted background
1855 Double_t weight=1.0;
1856 // Correct for the number of eventmixing:
1857 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
1858 // real combinations (since you cannot combine a photon with its own)
1859 // but BG leads to N_{a}*N_{b} combinations
a280ac15 1860 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
e5b6e8a6 1861
a280ac15 1862 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
e5b6e8a6 1863
a280ac15 1864 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
e5b6e8a6 1865
1866 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
ca91a3e1 1867
e5b6e8a6 1868 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
1869
1870 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
1871
11c1e680 1872 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
e5b6e8a6 1873 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
1874 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
1875 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
e5b6e8a6 1876 }
1877 }
1878 }
1879 }
1880 }
1881 }
1882}
2bb2434e 1883//________________________________________________________________________
1884void AliAnalysisTaskGammaConvV1::RotateParticle(AliAODConversionPhoton *gamma){
ca91a3e1 1885 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
2bb2434e 1886 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
1887 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
1888 gamma->RotateZ(rotationValue);
1889}
1890//________________________________________________________________________
1891void AliAnalysisTaskGammaConvV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
1892 //see header file for documentation
1893
e5b6e8a6 1894 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
1895 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
1896 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
2bb2434e 1897
1898 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
1899 particle->SetConversionPoint(movedPlace);
1900}
1901//________________________________________________________________________
1902void AliAnalysisTaskGammaConvV1::UpdateEventByEventData(){
1903 //see header file for documentation
a280ac15 1904 if(fGammaCandidates->GetEntries() >0 ){
ca91a3e1 1905 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
a280ac15 1906 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fNumberOfESDTracks);
2bb2434e 1907 }
1908 else{ // means we use #V0s for multiplicity
a280ac15 1909 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries());
2bb2434e 1910 }
1911 }
1912}
1913
1914//________________________________________________________________________
ae947965 1915void AliAnalysisTaskGammaConvV1::CountTracks(){
2bb2434e 1916
ae947965 1917 if(fInputEvent->IsA()==AliESDEvent::Class()){
2bb2434e 1918 // Using standard function for setting Cuts
1919 Bool_t selectPrimaries=kTRUE;
0a2b2b4b 1920 AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
2bb2434e 1921 EsdTrackCuts->SetMaxDCAToVertexZ(2);
1922 EsdTrackCuts->SetEtaRange(-0.8, 0.8);
1923 EsdTrackCuts->SetPtRange(0.15);
ae947965 1924 fNumberOfESDTracks = 0;
1925 for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
1926 AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
1927 if(!curTrack) continue;
1928 // if(fMCEvent && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1929 // if(!((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack)) continue;
1930 // }
1931 if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTracks++;
1932 }
1933 delete EsdTrackCuts;
1934 EsdTrackCuts=0x0;
1935 }
1936 else if(fInputEvent->IsA()==AliAODEvent::Class()){
1937 fNumberOfESDTracks = 0;
1938 for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
1939 AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
1940 if(!curTrack->IsPrimaryCandidate()) continue;
1941 if(abs(curTrack->Eta())>0.8) continue;
1942 if(curTrack->Pt()<0.15) continue;
1943 if(abs(curTrack->ZAtDCA())>2) continue;
1944 fNumberOfESDTracks++;
1945 }
2bb2434e 1946 }
2bb2434e 1947
1948 return;
1949}
1950//________________________________________________________________________
ae947965 1951void AliAnalysisTaskGammaConvV1::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
1952{
1953 // 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
1954 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
1955 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
1956 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
1957 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
1958 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
1959 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
1960 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
1961 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
1962 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
1963 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
1964 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
1965 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
1966 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
1967 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
1968 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
1969 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
1970 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
1971 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
1972 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
1973 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
1974 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
1975 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
1976 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
1977 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
1978 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
1979 else {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
1980}
1981//________________________________________________________________________
1982void AliAnalysisTaskGammaConvV1::RelabelAODPhotonCandidates(Bool_t mode){
1983
1984 // Relabeling For AOD Event
1985 // ESDiD -> AODiD
1986 // MCLabel -> AODMCLabel
1987
1988 if(mode){
1989 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
1990 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
1991 }
1992
1993 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
1994 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
1995 if(!PhotonCandidate) continue;
1996 if(!mode){// Back to ESD Labels
1997 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
1998 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
1999 //PhotonCandidate->IsAODMCLabel(kFALSE);
2000 continue;
2001 }
2002 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
2003 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
2004
2005 Bool_t AODLabelPos = kFALSE;
2006 Bool_t AODLabelNeg = kFALSE;
2007
2008 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
2009 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
2010 if(!AODLabelPos){
2011 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
2012 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
2013 AODLabelPos = kTRUE;
2014 }
2015 }
2016 if(!AODLabelNeg){
2017 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
2018 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
2019 AODLabelNeg = kTRUE;
2020 }
2021 }
2022 if(AODLabelNeg && AODLabelPos){
2023 break;
2024 }
2025 } // Both ESD Tracks have AOD Tracks with Positive IDs
2026 if(!AODLabelPos || !AODLabelNeg){
2027 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
2028 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
2029 if(tempDaughter->GetID()<0){
2030 if(!AODLabelPos){
2031 if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelPositive()){
2032 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
2033 AODLabelPos = kTRUE;
2034 }
2035 }
2036 if(!AODLabelNeg){
2037 if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelNegative()){
2038 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
2039 AODLabelNeg = kTRUE;
2040 }
2041 }
2042 }
2043 if(AODLabelNeg && AODLabelPos){
2044 break;
2045 }
2046 }
2047 if(!AODLabelPos || !AODLabelNeg){
2048 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
2049 }
2050 }
2051 }
2052
2053 if(!mode){
2054 delete[] fMCStackPos;
2055 delete[] fMCStackNeg;
2056 }
2057}
2058//________________________________________________________________________
2bb2434e 2059void AliAnalysisTaskGammaConvV1::Terminate(const Option_t *)
2060{
e5b6e8a6 2061
a280ac15 2062 // Not Executed by GRID on SubJobLevel
2bb2434e 2063 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
a280ac15 2064 if(!((AliConversionCuts*)fCutArray->At(iCut))) continue;
e5b6e8a6 2065 if(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection() == 2 && fMCEvent){
2066 fHeaderNameList[iCut] = new TList();
2067 TString HeaderNames = "Header:";
2068 for(Int_t i = 0;i<(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
2069 HeaderNames = HeaderNames+"_"+ ((TObjString*)((TList*) ( (AliConversionCuts*)fCutArray->At(iCut))
2070 ->GetAcceptedHeader())->At(i))->GetString();
2071 }
2072 fHeaderNameList[iCut]->SetName(HeaderNames);
2073 fHeaderNameList[iCut]->SetOwner(kTRUE);
2074 fCutFolder[iCut]->Add(fHeaderNameList[iCut]);
2075 }
2076 else if(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection() == 0 &&
2077 (((AliConversionCuts*)fCutArray->At(iCut))->GetFoundHeader()) && fMCEvent){
2078 fHeaderNameList[iCut] = new TList();
2079 TString HeaderNames = (((AliConversionCuts*)fCutArray->At(iCut))->GetFoundHeader())[0];
2080 fHeaderNameList[iCut]->SetName(HeaderNames);
2081 fHeaderNameList[iCut]->SetOwner(kTRUE);
2082 fCutFolder[iCut]->Add(fHeaderNameList[iCut]);
2083 }
ae947965 2084 if (((AliConversionCuts*)fCutArray->At(iCut))->IsSpecialTrigger() == 4 ){
2085 fTriggerNameList[iCut] = new TList();
2086 TString TriggerNames = "Trigger: ";
2087 TriggerNames = TriggerNames+ ( (AliConversionCuts*)fCutArray->At(iCut))->GetSpecialTriggerName();
2088 fTriggerNameList[iCut]->SetName(TriggerNames);
2089 fTriggerNameList[iCut]->SetOwner(kTRUE);
2090 fCutFolder[iCut]->Add(fTriggerNameList[iCut]);
2091 }
2bb2434e 2092 }
a280ac15 2093
2094 //fOutputContainer->Print(); // Will crash on GRID
2bb2434e 2095}