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