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