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