]> 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
- changed trigger handling for conversion task
[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{
1281
1390f698 1282 Double_t magField = fInputEvent->GetMagneticField();
1283 if( magField < 0.0 ){
1284 magField = 1.0;
1285 }
1286 else {
1287 magField = -1.0;
1288 }
1289
ae947965 1290 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1291 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1292 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
4803eb1f 1293 iPhotonMCInfo = 0;
ae947965 1294
1295 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1296 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1297
1298 if(posDaughter->GetMother() != negDaughter->GetMother()){
1299 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
4803eb1f 1300 iPhotonMCInfo = 1;
ae947965 1301 return;
1302 }
1303 else if(posDaughter->GetMother() == -1){
1304 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
4803eb1f 1305 iPhotonMCInfo = 1;
ae947965 1306 return;
1307 }
1308
4803eb1f 1309 if(pdgCode[0]!=11 || pdgCode[1]!=11){
1310 iPhotonMCInfo = 1;
1311 return; //One Particle is not a electron
1312 }
1313 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
1314 iPhotonMCInfo = 1;
1315 return; // Same Charge
1316 }
1317
1390f698 1318 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
1319 AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1320 AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1321 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1322
1323 if(Photon->GetPdgCode() != 22){
1324 hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1325 iPhotonMCInfo = 1;
1326 return; // Mother is no Photon
1327 }
1328
4803eb1f 1329 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
1330 iPhotonMCInfo = 1;
1331 return;// check if the daughters come from a conversion
1332 }
ae947965 1333 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1334
1390f698 1335
1336
ae947965 1337 // True Photon
f315320f 1338 if(fIsFromMBHeader){
1339 hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1340 if (fDoPhotonQA > 0) hESDTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1341 }
1390f698 1342 hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
4803eb1f 1343 if(Photon->IsPrimary()){
ae947965 1344 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1345 if(fIsFromMBHeader){
4803eb1f 1346 iPhotonMCInfo = 6;
ae947965 1347 hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
ae4f2cfb 1348 hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
ae947965 1349 }
ae947965 1350 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1351 }
1352 else{
1353 if(fIsFromMBHeader){
1354 hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
4803eb1f 1355 iPhotonMCInfo = 2;
1356 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1357 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1358 iPhotonMCInfo = 5;
1359 hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1360 }
ae947965 1361 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1362 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
4803eb1f 1363 iPhotonMCInfo = 4;
ae947965 1364 hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1365 }
4803eb1f 1366 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1367 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1368 iPhotonMCInfo = 3;
1369 }
ae947965 1370 }
1371 }
4803eb1f 1372
2bb2434e 1373}
1374//________________________________________________________________________
1375void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1376{
1390f698 1377
1378 Double_t magField = fInputEvent->GetMagneticField();
1379 if( magField < 0.0 ){
1380 magField = 1.0;
1381 }
1382 else {
1383 magField = -1.0;
1384 }
1385
2bb2434e 1386 // Process True Photons
ae947965 1387 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1388 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
2bb2434e 1389
4803eb1f 1390 iPhotonMCInfo = 0;
1391
2bb2434e 1392 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
e5b6e8a6 1393 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
4803eb1f 1394 iPhotonMCInfo = 1;
e5b6e8a6 1395 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
ae947965 1396 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
ca91a3e1 1397 return;
1398 }
1399 else if(posDaughter->GetMother(0) == -1){
ae947965 1400 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2bb2434e 1401 return;
1402 }
e5b6e8a6 1403
1404 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1390f698 1405
2bb2434e 1406 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
e5b6e8a6 1407
ae947965 1408 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
1390f698 1409 AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1410 AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1411 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1412
1413 if(Photon->GetPdgCode() != 22){
1414 hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1415 return; // Mother is no Photon
1416 }
1417
1418 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
2bb2434e 1419
1390f698 1420
1421
ca91a3e1 1422 // True Photon
f315320f 1423 if(fIsFromMBHeader){
1424 hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1425 if (fDoPhotonQA > 0) hESDTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1390f698 1426 }
1427 hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
ae947965 1428 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
ca91a3e1 1429 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
a280ac15 1430 if(fIsFromMBHeader){
4803eb1f 1431 iPhotonMCInfo = 6;
ae4f2cfb 1432 hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1433 hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1434
e5b6e8a6 1435 }
e5b6e8a6 1436 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
ca91a3e1 1437 }
1438 else{
a280ac15 1439 if(fIsFromMBHeader){
4803eb1f 1440 iPhotonMCInfo = 2;
e5b6e8a6 1441 hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
4803eb1f 1442 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1443 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
1444 hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1445 iPhotonMCInfo = 5;
1446 }
ae947965 1447 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1448 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
e5b6e8a6 1449 hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
4803eb1f 1450 iPhotonMCInfo = 4;
1451 }
1452 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1453 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
1454 iPhotonMCInfo = 3;
e5b6e8a6 1455 }
ca91a3e1 1456 }
1457 }
2bb2434e 1458}
1459//________________________________________________________________________
ae947965 1460void AliAnalysisTaskGammaConvV1::ProcessAODMCParticles()
1461{
1462
1463 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1464
1465 // Loop over all primary MC particle
1466 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
1467
1468 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
1469 if (!particle) continue;
1470 if (!particle->IsPrimary()) continue;
1471
ae947965 1472 Int_t isMCFromMBHeader = -1;
1473 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1474 isMCFromMBHeader
1475 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1476 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
ae947965 1477 }
ae4f2cfb 1478
1479 if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
ae947965 1480 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
1481 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1482 if(particle->GetMother() >-1){ // Meson Decay Gamma
1483 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
1484 case 111: // Pi0
1485 hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1486 break;
1487 case 113: // Rho0
1488 hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1489 break;
1490 case 221: // Eta
1491 hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1492 break;
1493 case 223: // Omega
1494 hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1495 break;
1496 case 331: // Eta'
1497 hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1498 break;
1499 case 333: // Phi
1500 hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1501 break;
1502 case 3212: // Sigma
1503 hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1504 break;
1505 }
1506 }
1507 }
1508 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
1509 Double_t rConv = 0;
1510 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
1511 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
1512 if(!tmpDaughter) continue;
1513 if(abs(tmpDaughter->GetPdgCode()) == 11){
1514 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
1515 }
1516 }
1517 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
ae4f2cfb 1518 if (fDoPhotonQA > 0){
ae947965 1519 hMCConvGammaR[fiCut]->Fill(rConv);
1520 hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1521 }
ae947965 1522 }
1523 // Converted MC Gamma
1524 if(fDoMesonAnalysis){
ae4f2cfb 1525 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
ae947965 1526 Double_t mesonY = 10.;
1527 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1528 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1529 } else{
4803eb1f 1530 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1531 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
ae947965 1532 }
1533 Float_t weightedK0s= 1;
1534 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1535 if (particle->Pt()>0.005){
1536 weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1537 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1538 }
1539 }
1540 hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1541 hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1542 hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1543 }
4803eb1f 1544 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1545 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
ae947965 1546 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
1547 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
1548 Float_t weighted= 1;
1549 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1550 if (particle->Pt()>0.005){
1551 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
d0a4ea74
FB		 1552// if(particle->GetPdgCode() == 221){
1553// cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1554// }
ae947965 1555 }
1556 }
1557 Double_t mesonY = 10.;
1558 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1559 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1560 } else{
4803eb1f 1561 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1562 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
ae947965 1563 }
1564
1565 if(particle->GetPdgCode() == 111){
1566 hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1567 hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
ae4f2cfb 1568 if (fDoMesonQA > 0) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
ae947965 1569 } else if(particle->GetPdgCode() == 221){
1570 hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
d0a4ea74 1571 hMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
ae4f2cfb 1572 if (fDoMesonQA > 0) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
ae947965 1573 }
1574
1575 // Check the acceptance for both gammas
1576 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
ae4f2cfb 1577 ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) &&
1578 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
1579 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
ae947965 1580
1581 if(particle->GetPdgCode() == 111){
1582 hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1583 } else if(particle->GetPdgCode() == 221){
1584 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1585 }
1586 }
1587 }
1588 }
1589 }
d9d6352b 1590
ae947965 1591}
1592//________________________________________________________________________
2bb2434e 1593void AliAnalysisTaskGammaConvV1::ProcessMCParticles()
1594{
2bb2434e 1595 // Loop over all primary MC particle
1596 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
1597 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1598 if (!particle) continue;
1599
a280ac15 1600 Int_t isMCFromMBHeader = -1;
ca91a3e1 1601 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
a280ac15 1602 isMCFromMBHeader
ae947965 1603 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
a280ac15 1604 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
ca91a3e1 1605 }
1606
ae4f2cfb 1607 if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
ca91a3e1 1608 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
1609 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1610 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
1611 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
1612 case 111: // Pi0
1613 hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1614 break;
1615 case 113: // Rho0
1616 hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1617 break;
1618 case 221: // Eta
1619 hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1620 break;
1621 case 223: // Omega
1622 hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1623 break;
1624 case 331: // Eta'
1625 hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1626 break;
1627 case 333: // Phi
1628 hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1629 break;
e5b6e8a6 1630 case 3212: // Sigma
a280ac15 1631 hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
e5b6e8a6 1632 break;
ca91a3e1 1633 }
1634 }
1635 }
1636 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
1637 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
ae4f2cfb 1638 if (fDoPhotonQA > 0){
0a2b2b4b 1639 hMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
1640 hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1641 }
ca91a3e1 1642 } // Converted MC Gamma
1643 if(fDoMesonAnalysis){
ae4f2cfb 1644 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
ae947965 1645 Double_t mesonY = 10.;
1646 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1647 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1648 } else{
4803eb1f 1649 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1650 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
ae947965 1651 }
1652 Float_t weightedK0s= 1;
1653 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1654 if (particle->Pt()>0.005){
1655 weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1656 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1657 }
1658 }
d9d6352b 1659 if (fMCStack->IsPhysicalPrimary(i)){
1660 hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1661 hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1662 hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1663 }
ae947965 1664 }
4803eb1f 1665 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1666 ->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
e5b6e8a6 1667 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
1668 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
1669
a280ac15 1670 Float_t weighted= 1;
ae947965 1671 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
a280ac15 1672 if (particle->Pt()>0.005){
ae947965 1673 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
d0a4ea74
FB		 1674// if(particle->GetPdgCode() == 221){
1675// cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1676// }
a280ac15 1677 }
1678 }
0a2b2b4b 1679 Double_t mesonY = 10.;
1680 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
11c1e680 1681 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
0a2b2b4b 1682 } else{
4803eb1f 1683 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1684 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
0a2b2b4b 1685 }
1686
a280ac15 1687 if(particle->GetPdgCode() == 111){
1688 hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
ae947965 1689 hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
ae4f2cfb 1690 if (fDoMesonQA > 0) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
a280ac15 1691 } else if(particle->GetPdgCode() == 221){
1692 hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
d0a4ea74 1693 hMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
ae4f2cfb 1694 if (fDoMesonQA > 0) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
ae947965 1695 }
e5b6e8a6 1696
ca91a3e1 1697 // Check the acceptance for both gammas
e5b6e8a6 1698 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
ae4f2cfb 1699 ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) &&
1700 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
1701 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
0a2b2b4b 1702
a280ac15 1703 if(particle->GetPdgCode() == 111){
1704 hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1705 } else if(particle->GetPdgCode() == 221){
1706 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1707 }
ca91a3e1 1708 }
1709 }
1710 }
2bb2434e 1711 }
d9d6352b 1712
1713 if (fDoMesonQA){
1714 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
1715 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1716 if (!particle) continue;
1717
1718 Int_t isMCFromMBHeader = -1;
1719 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1720 isMCFromMBHeader
1721 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1722 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1723 }
1724
1725 if(fDoMesonAnalysis){
1726 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1727 ->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1728 Float_t weighted= 1;
1729 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1730 if (particle->Pt()>0.005){
1731 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1732 // if(particle->GetPdgCode() == 221){
1733 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1734 // }
1735 }
1736 }
1737
1738 if(particle->GetPdgCode() == 111){
1739 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
1740 Int_t source = GetSourceClassification(111,pdgCode);
1741 hMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
1742 hMCSecPi0Source[fiCut]->Fill(pdgCode);
1743 } else if(particle->GetPdgCode() == 221){
1744 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
1745 hMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1746 hMCSecEtaSource[fiCut]->Fill(pdgCode);
1747 }
1748 }
1749 }
1750 }
1751 }
2bb2434e 1752}
1753//________________________________________________________________________
1754void AliAnalysisTaskGammaConvV1::CalculatePi0Candidates(){
1755
1756 // Conversion Gammas
a280ac15 1757 if(fGammaCandidates->GetEntries()>1){
1758 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
1759 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
0a2b2b4b 1760 if (gamma0==NULL) continue;
a280ac15 1761 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
1762 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
2bb2434e 1763 //Check for same Electron ID
0a2b2b4b 1764 if (gamma1==NULL) continue;
2bb2434e 1765 if(gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelPositive() ||
1766 gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelNegative() ||
1767 gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelPositive() ||
1768 gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelNegative() ) continue;
1769
1770 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
1771 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
1772
4803eb1f 1773 pi0cand->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
1774 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1775 ->MesonIsSelected(pi0cand,kTRUE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2bb2434e 1776 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
e5b6e8a6 1777 if(pi0cand->GetAlpha()<0.1)
2bb2434e 1778 hESDMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
ae4f2cfb 1779
1780 if (fDoMesonQA > 0){
d8b864f8 1781 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
bacaa826 1782 hESDMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
ae4f2cfb 1783 hESDMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
ca9152d4
FB		 1784 hESDMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
1785
ae4f2cfb 1786 }
d8b864f8 1787 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
bacaa826 1788 hESDMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
ae4f2cfb 1789 hESDMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
ca9152d4 1790 hESDMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
ae4f2cfb 1791 }
1792 }
e5b6e8a6 1793 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
1794 Int_t zbin = 0;
1795 Int_t mbin = 0;
a280ac15 1796
e5b6e8a6 1797 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
1798 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1799 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
4803eb1f 1800 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
e5b6e8a6 1801 } else {
a280ac15 1802 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
e5b6e8a6 1803 }
1804 }
1805 else{
1806 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1807 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
4803eb1f 1808 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
e5b6e8a6 1809 } else {
a280ac15 1810 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
e5b6e8a6 1811 }
1812 }
1813 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1814 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2bb2434e 1815 }
ae947965 1816
1817
4803eb1f 1818 if(fIsMC){
ae947965 1819 if(fInputEvent->IsA()==AliESDEvent::Class())
1820 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1);
1821 if(fInputEvent->IsA()==AliAODEvent::Class())
1822 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1);
2bb2434e 1823 }
ae4f2cfb 1824 if (fDoMesonQA == 2){
4803eb1f 1825 fInvMass = pi0cand->M();
1826 fPt = pi0cand->Pt();
1827 if (abs(gamma0->GetDCAzToPrimVtx()) < abs(gamma1->GetDCAzToPrimVtx())){
1828 fDCAzGammaMin = gamma0->GetDCAzToPrimVtx();
1829 fDCAzGammaMax = gamma1->GetDCAzToPrimVtx();
1830 } else {
1831 fDCAzGammaMin = gamma1->GetDCAzToPrimVtx();
1832 fDCAzGammaMax = gamma0->GetDCAzToPrimVtx();
1833 }
1834 iFlag = pi0cand->GetMesonQuality();
1835// cout << "gamma 0: " << gamma0->GetV0Index()<< "\t" << gamma0->GetPx() << "\t" << gamma0->GetPy() << "\t" << gamma0->GetPz() << "\t" << endl;
1836// cout << "gamma 1: " << gamma1->GetV0Index()<< "\t"<< gamma1->GetPx() << "\t" << gamma1->GetPy() << "\t" << gamma1->GetPz() << "\t" << endl;
1837// cout << "pi0: "<<fInvMass << "\t" << fPt <<"\t" << fDCAzGammaMin << "\t" << fDCAzGammaMax << "\t" << (Int_t)iFlag << "\t" << (Int_t)iMesonMCInfo <<endl;
39e8c2ce 1838 if (fIsHeavyIon == 1 && fPt > 0.399 && fPt < 20. ) {
1839 if (fInvMass > 0.08 && fInvMass < 0.2) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1840 if ((fInvMass > 0.45 && fInvMass < 0.6) && (fPt > 0.999 && fPt < 20.) )tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1841 } else if (fPt > 0.299 && fPt < 20. ) {
4803eb1f 1842 if ( (fInvMass > 0.08 && fInvMass < 0.2) || (fInvMass > 0.45 && fInvMass < 0.6)) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1843 }
1844 }
2bb2434e 1845 }
1846 delete pi0cand;
1847 pi0cand=0x0;
1848 }
1849 }
1850 }
1851}
1852//______________________________________________________________________
1853void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1854{
1855 // Process True Mesons
1856 AliStack *MCStack = fMCEvent->Stack();
4803eb1f 1857 iMesonMCInfo = 0;
e5b6e8a6 1858 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2bb2434e 1859 Bool_t isTruePi0 = kFALSE;
1860 Bool_t isTrueEta = kFALSE;
86eaf9ae 1861 Bool_t isTruePi0Dalitz = kFALSE;
1862 Bool_t isTrueEtaDalitz = kFALSE;
1863 Bool_t gamma0DalitzCand = kFALSE;
1864 Bool_t gamma1DalitzCand = kFALSE;
2bb2434e 1865 Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
1866 Int_t gamma0MotherLabel = -1;
1867 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1868 // Daughters Gamma 0
1869 TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
1870 TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
1871 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
e5b6e8a6 1872 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2bb2434e 1873 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1874 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1875 gamma0MotherLabel=gammaMC0->GetFirstMother();
1876 }
1877 }
86eaf9ae 1878 if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate
1879 gamma0DalitzCand = kTRUE;
2bb2434e 1880 gamma0MotherLabel=-111;
1881 }
86eaf9ae 1882 if(gammaMC0->GetPdgCode() ==221){ // Dalitz candidate
1883 gamma0DalitzCand = kTRUE;
2bb2434e 1884 gamma0MotherLabel=-221;
1885 }
1886 }
1887 }
e5b6e8a6 1888 if(TrueGammaCandidate1->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2bb2434e 1889 Int_t gamma1MCLabel = TrueGammaCandidate1->GetMCParticleLabel(MCStack);
1890 Int_t gamma1MotherLabel = -1;
1891 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1892 // Daughters Gamma 1
1893 TParticle * negativeMC = (TParticle*)TrueGammaCandidate1->GetNegativeMCDaughter(MCStack);
1894 TParticle * positiveMC = (TParticle*)TrueGammaCandidate1->GetPositiveMCDaughter(MCStack);
1895 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
e5b6e8a6 1896 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2bb2434e 1897 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1898 if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
1899 gamma1MotherLabel=gammaMC1->GetFirstMother();
1900 }
1901 }
86eaf9ae 1902 if(gammaMC1->GetPdgCode() ==111 ){ // Dalitz candidate
1903 gamma1DalitzCand = kTRUE;
1904 gamma1MotherLabel=-111;
2bb2434e 1905 }
86eaf9ae 1906 if(gammaMC1->GetPdgCode() ==221){ // Dalitz candidate
1907 gamma1DalitzCand = kTRUE;
1908 gamma1MotherLabel=-221;
2bb2434e 1909 }
1910 }
1911 }
1912 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1913 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
1914 isTruePi0=kTRUE;
1915 }
1916 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
1917 isTrueEta=kTRUE;
1918 }
1919 }
86eaf9ae 1920
1921 //Identify Dalitz candidate
1922 if (gamma1DalitzCand || gamma0DalitzCand){
1923 if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){
1924 if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE;
1925 if (gamma0MotherLabel == -221) isTrueEtaDalitz = kTRUE;
1926 }
1927 if (gamma1DalitzCand && gamma1MCLabel >=0 && gamma1MCLabel==gamma0MotherLabel){
1928 if (gamma1MotherLabel == -111) isTruePi0Dalitz = kTRUE;
1929 if (gamma1MotherLabel == -221) isTrueEtaDalitz = kTRUE;
1930 }
1931 }
1932
1933
e5b6e8a6 1934 if(isTruePi0 || isTrueEta){// True Pion or Eta
4803eb1f 1935 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
ae4f2cfb 1936 if (fDoMesonQA > 0){
1937 if (isTruePi0){
d8b864f8
FB		 1938 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
1939 hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1940 hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
ca9152d4 1941 hESDTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
d8b864f8 1942 }
ae4f2cfb 1943 } else if (isTrueEta){
d8b864f8
FB		 1944 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
1945 hESDTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1946 hESDTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
ca9152d4 1947 hESDTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
ae4f2cfb 1948 }
1949 }
1950 }
e5b6e8a6 1951 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
ae947965 1952 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetMother(0);
1953 Float_t weightedSec= 1;
1954 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1955 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
1956 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1957 }
1958 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
4803eb1f 1959 iMesonMCInfo = 2;
ae947965 1960 if (secMotherLabel >-1){
1961 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
4803eb1f 1962 iMesonMCInfo = 4;
ae947965 1963 hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
ae4f2cfb 1964 if (fDoMesonQA > 0)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
ae947965 1965 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
e5b6e8a6 1966 }
ae947965 1967 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221){
4803eb1f 1968 iMesonMCInfo = 3;
ae947965 1969 hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
ae4f2cfb 1970 if (fDoMesonQA > 0)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
ae947965 1971 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
ca91a3e1 1972 }
d9d6352b 1973 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==3122){
1974 iMesonMCInfo = 7;
1975 hESDTrueSecondaryMotherFromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1976 if (fDoMesonQA > 0)hESDTrueLambdaWithPi0DaughterMCPt[fiCut]
1977 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1978 }
ca91a3e1 1979 }
0a2b2b4b 1980 }else{ // Only primary pi0 for efficiency calculation
4803eb1f 1981 iMesonMCInfo = 6;
a280ac15 1982 Float_t weighted= 1;
ae947965 1983 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
a280ac15 1984 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
ae947965 1985 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
1986// cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
a280ac15 1987 }
1988 }
1989 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
526074e4 1990 hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1991 pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
ae4f2cfb 1992
1993
1994 if (fDoMesonQA > 0){
0a2b2b4b 1995 if(isTruePi0){ // Only primary pi0 for resolution
1996 hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1997 }
1998 if (isTrueEta){ // Only primary eta for resolution
1999 hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2000 }
ca91a3e1 2001 }
2002 }
86eaf9ae 2003 } else if(!isTruePi0 && !isTrueEta){ // Background
ae4f2cfb 2004 if (fDoMesonQA > 0){
86eaf9ae 2005 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2006 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2007 iMesonMCInfo = 1;
2008 } else { // No photon or without mother
2009 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2010 }
2bb2434e 2011 }
86eaf9ae 2012 if( isTruePi0Dalitz || isTrueEtaDalitz ){
2bb2434e 2013 // Dalitz
4803eb1f 2014 iMesonMCInfo = 5;
2bb2434e 2015 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
86eaf9ae 2016 } else if (gamma0DalitzCand || gamma1DalitzCand){
ae4f2cfb 2017 if (fDoMesonQA > 0)hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
86eaf9ae 2018 }
2bb2434e 2019 }
2020 }
2021 }
2022}
ae947965 2023//______________________________________________________________________
2024void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
2025{
2026
2027 // Process True Mesons
2028 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2029 Bool_t isTruePi0 = kFALSE;
2030 Bool_t isTrueEta = kFALSE;
86eaf9ae 2031 Bool_t isTruePi0Dalitz = kFALSE;
2032 Bool_t isTrueEtaDalitz = kFALSE;
2033 Bool_t gamma0DalitzCand = kFALSE;
2034 Bool_t gamma1DalitzCand = kFALSE;
ae947965 2035
2036 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
2037 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
2bb2434e 2038
4803eb1f 2039 iMesonMCInfo = 0;
ae947965 2040 Int_t gamma0MCLabel = -1;
2041 Int_t gamma0MotherLabel = -1;
2042 if(!positiveMC||!negativeMC)
2043 return;
2044
2045 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
2046 gamma0MCLabel = positiveMC->GetMother();
2047 }
2048
2049 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2050 // Daughters Gamma 0
2051 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2052 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
86eaf9ae 2053 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
ae947965 2054 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
2055 gamma0MotherLabel=gammaMC0->GetMother();
2056 }
2057 }
86eaf9ae 2058 if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate
2059 gamma0DalitzCand = kTRUE;
ae947965 2060 gamma0MotherLabel=-111;
2061 }
86eaf9ae 2062 if(gammaMC0->GetPdgCode() ==221){ // Dalitz candidate
2063 gamma0DalitzCand = kTRUE;
ae947965 2064 gamma0MotherLabel=-221;
2065 }
2066 }
2067 }
2068 positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelPositive()));
2069 negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelNegative()));
2070
2071 Int_t gamma1MCLabel = -1;
2072 Int_t gamma1MotherLabel = -1;
2073 if(!positiveMC||!negativeMC)
2074 return;
2075
2076 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
2077 gamma1MCLabel = positiveMC->GetMother();
2078 }
2079 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2080 // Daughters Gamma 1
2081 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2082 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
86eaf9ae 2083 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
ae947965 2084 if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
2085 gamma1MotherLabel=gammaMC1->GetMother();
2086 }
2087 }
86eaf9ae 2088 if(gammaMC1->GetPdgCode() ==111 ){ // Dalitz candidate
2089 gamma1DalitzCand = kTRUE;
2090 gamma1MotherLabel=-111;
ae947965 2091 }
86eaf9ae 2092 if(gammaMC1->GetPdgCode() ==221){ // Dalitz candidate
2093 gamma1DalitzCand = kTRUE;
ae947965 2094 gamma1MotherLabel=-221;
2095 }
2096 }
2097 }
2098 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2099 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2100 isTruePi0=kTRUE;
2101 }
2102 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2103 isTrueEta=kTRUE;
2104 }
2105 }
86eaf9ae 2106
2107 //Identify Dalitz candidate
2108 if (gamma1DalitzCand || gamma0DalitzCand){
2109 if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){
2110 if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE;
2111 if (gamma0MotherLabel == -221) isTrueEtaDalitz = kTRUE;
2112 }
2113 if (gamma1DalitzCand && gamma1MCLabel >=0 && gamma1MCLabel==gamma0MotherLabel){
2114 if (gamma1MotherLabel == -111) isTruePi0Dalitz = kTRUE;
2115 if (gamma1MotherLabel == -221) isTrueEtaDalitz = kTRUE;
2116 }
2117 }
2118
ae947965 2119 if(isTruePi0 || isTrueEta){// True Pion or Eta
2120 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
ae4f2cfb 2121 if (fDoMesonQA > 0){
2122 if (isTruePi0){
d8b864f8
FB		 2123 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2124 hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
2125 hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
ca9152d4 2126 hESDTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
ae4f2cfb 2127 }
2128 } else if (isTrueEta){
d8b864f8
FB		 2129 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2130 hESDTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
2131 hESDTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
ca9152d4 2132 hESDTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
ae4f2cfb 2133 }
ae4f2cfb 2134 }
2135 }
ae947965 2136 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2137 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2138 Float_t weightedSec= 1;
2139 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2140 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
2141 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2142 }
2143 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
4803eb1f 2144 iMesonMCInfo = 2;
ae947965 2145 if (secMotherLabel >-1){
2146 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
4803eb1f 2147 iMesonMCInfo = 4;
ae947965 2148 hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
ae4f2cfb 2149 if (fDoMesonQA > 0)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
ae947965 2150 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2151 }
2152 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221){
4803eb1f 2153 iMesonMCInfo = 3;
ae947965 2154 hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
ae4f2cfb 2155 if (fDoMesonQA > 0)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
ae947965 2156 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2157 }
d9d6352b 2158 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122){
2159 iMesonMCInfo = 7;
2160 hESDTrueSecondaryMotherFromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2161 if (fDoMesonQA > 0)hESDTrueLambdaWithPi0DaughterMCPt[fiCut]
2162 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2163 }
ae947965 2164 }
2165 }else{ // Only primary pi0 for efficiency calculation
2166 Float_t weighted= 1;
4803eb1f 2167 iMesonMCInfo = 6;
ae947965 2168 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2169 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2170 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2171 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2172 }
2173 }
2174 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
4803eb1f 2175 hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2176 pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2177
ae4f2cfb 2178 if (fDoMesonQA > 0){
ae947965 2179 if(isTruePi0){ // Only primary pi0 for resolution
2180 hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2181 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
ae4f2cfb 2182
ae947965 2183 }
2184 if (isTrueEta){ // Only primary eta for resolution
2185 hESDTruePrimaryEtaMCPtResolPt[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 }
86eaf9ae 2190 } else if(!isTruePi0 && !isTrueEta) { // Background
ae4f2cfb 2191 if (fDoMesonQA > 0){
86eaf9ae 2192 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2193 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2194 iMesonMCInfo = 1;
2195 } else { // No photon or without mother
2196 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2197 }
ae947965 2198 }
86eaf9ae 2199 if( isTruePi0Dalitz || isTrueEtaDalitz ){
ae947965 2200 // Dalitz
4803eb1f 2201 iMesonMCInfo = 5;
ae947965 2202 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
86eaf9ae 2203 } else if (gamma0DalitzCand || gamma1DalitzCand){
ae4f2cfb 2204 if (fDoMesonQA > 0)hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
ae947965 2205 }
2206 }
2207}
2bb2434e 2208//________________________________________________________________________
2209void AliAnalysisTaskGammaConvV1::CalculateBackground(){
2210
e5b6e8a6 2211 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2bb2434e 2212 Int_t mbin = 0;
2213
ca91a3e1 2214 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
4803eb1f 2215 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2bb2434e 2216 } else {
a280ac15 2217 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2bb2434e 2218 }
2219
ca91a3e1 2220 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2bb2434e 2221
a280ac15 2222 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2223 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2224 for(Int_t iCurrent2=iCurrent+1;iCurrent2<fGammaCandidates->GetEntries();iCurrent2++){
e5b6e8a6 2225 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
a280ac15 2226 AliAODConversionPhoton currentEventGoodV02 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent2));
2bb2434e 2227
ca91a3e1 2228 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGProbability()){
2bb2434e 2229 AliAODConversionMother *backgroundCandidateProb = new AliAODConversionMother(&currentEventGoodV0,&currentEventGoodV02);
2230 Double_t massBGprob = backgroundCandidateProb->M();
2231 if(massBGprob>0.1 && massBGprob<0.14){
2232 if(fRandom.Rndm()>fBGHandler[fiCut]->GetBGProb(zbin,mbin)){
2233 delete backgroundCandidateProb;
2234 continue;
2235 }
2236 }
2237 delete backgroundCandidateProb;
2238 backgroundCandidateProb = 0x0;
2239 }
2240
2241 RotateParticle(&currentEventGoodV02);
2242 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&currentEventGoodV02);
4803eb1f 2243 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2244 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2245 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2bb2434e 2246 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
e5b6e8a6 2247 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2bb2434e 2248 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2249 }
2250 delete backgroundCandidate;
2251 backgroundCandidate = 0x0;
2252 }
2253 }
2254 }
ca91a3e1 2255 }else{
2bb2434e 2256 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2257
ca91a3e1 2258 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2bb2434e 2259 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2260 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2261 if(fMoveParticleAccordingToVertex == kTRUE){
2262 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2263 }
2264
a280ac15 2265 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2266 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2bb2434e 2267 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2268 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2269 if(fMoveParticleAccordingToVertex == kTRUE){
2270 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2271 }
ca9152d4 2272 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
ae4f2cfb 2273 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2274 }
2bb2434e 2275
2276 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
4803eb1f 2277 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2278 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2279 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2bb2434e 2280 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
e5b6e8a6 2281 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2bb2434e 2282 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2283 }
2284 delete backgroundCandidate;
2285 backgroundCandidate = 0x0;
2286 }
2287 }
2288 }
2289 }
2290 else{
2291 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2292 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2293 if(previousEventV0s){
2294 if(fMoveParticleAccordingToVertex == kTRUE){
2295 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2296 }
a280ac15 2297 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2298 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2bb2434e 2299 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2300
2301 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2302
2303 if(fMoveParticleAccordingToVertex == kTRUE){
2304 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2305 }
ca9152d4 2306 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
ae4f2cfb 2307 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2308 }
2309
2bb2434e 2310
2311 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
4803eb1f 2312 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2313 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2314 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2bb2434e 2315 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
e5b6e8a6 2316 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2bb2434e 2317 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2318 }
2319 delete backgroundCandidate;
2320 backgroundCandidate = 0x0;
2321 }
2322 }
2323 }
2324 }
2325 }
2326 }
2327}
e5b6e8a6 2328//________________________________________________________________________
2329void AliAnalysisTaskGammaConvV1::CalculateBackgroundRP(){
2330
2331 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2332 Int_t mbin = 0;
2333 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
4803eb1f 2334 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
e5b6e8a6 2335 } else {
a280ac15 2336 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
e5b6e8a6 2337 }
2338
2339
2340 //Rotation Method
2341 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2342 // Correct for the number of rotations
2343 // BG is for rotation the same, except for factor NRotations
2344 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
2345
a280ac15 2346 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
e5b6e8a6 2347
a280ac15 2348 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
0a2b2b4b 2349 if (gamma0==NULL) continue;
a280ac15 2350 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
2351 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
0a2b2b4b 2352 if (gamma1 == NULL) continue;
e5b6e8a6 2353 if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
2354 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2355
2356 RotateParticle(gamma1);
2357
2358 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
4803eb1f 2359 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2360 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2361 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
e5b6e8a6 2362 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2363 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2364 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
e5b6e8a6 2365 }
2366 }
2367 }
2368 }
2369 }
2370 else{
2371 // Do Event Mixing
a280ac15 2372 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
e5b6e8a6 2373
a280ac15 2374 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
e5b6e8a6 2375
2376 if(previousEventGammas){
2377 // test weighted background
2378 Double_t weight=1.0;
2379 // Correct for the number of eventmixing:
2380 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
2381 // real combinations (since you cannot combine a photon with its own)
2382 // but BG leads to N_{a}*N_{b} combinations
a280ac15 2383 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
e5b6e8a6 2384
a280ac15 2385 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
e5b6e8a6 2386
a280ac15 2387 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
e5b6e8a6 2388
2389 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
ca91a3e1 2390
e5b6e8a6 2391 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
2392
2393 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
4803eb1f 2394 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2395 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2396 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
e5b6e8a6 2397 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2398 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2399 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
e5b6e8a6 2400 }
2401 }
2402 }
2403 }
2404 }
2405 }
2406}
2bb2434e 2407//________________________________________________________________________
2408void AliAnalysisTaskGammaConvV1::RotateParticle(AliAODConversionPhoton *gamma){
ca91a3e1 2409 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
2bb2434e 2410 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
2411 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
2412 gamma->RotateZ(rotationValue);
2413}
ae4f2cfb 2414
2415//________________________________________________________________________
2416void AliAnalysisTaskGammaConvV1::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
2417
2418 previousEventEP=previousEventEP+TMath::Pi();
2419 thisEventEP=thisEventEP+TMath::Pi();
2420 Double_t rotationValue= thisEventEP-previousEventEP;
2421 gamma->RotateZ(rotationValue);
2422}
2423
2bb2434e 2424//________________________________________________________________________
2425void AliAnalysisTaskGammaConvV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
2426 //see header file for documentation
2427
e5b6e8a6 2428 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
2429 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
2430 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
2bb2434e 2431
2432 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
2433 particle->SetConversionPoint(movedPlace);
2434}
2435//________________________________________________________________________
2436void AliAnalysisTaskGammaConvV1::UpdateEventByEventData(){
2437 //see header file for documentation
a280ac15 2438 if(fGammaCandidates->GetEntries() >0 ){
ca91a3e1 2439 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
ae4f2cfb 2440 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
2bb2434e 2441 }
2442 else{ // means we use #V0s for multiplicity
ae4f2cfb 2443 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
2bb2434e 2444 }
2445 }
2446}
2447
2bb2434e 2448
2bb2434e 2449//________________________________________________________________________
ae947965 2450void AliAnalysisTaskGammaConvV1::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
2451{
2452 // 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
2453 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
2454 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
2455 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
2456 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
2457 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
2458 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
2459 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
2460 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
2461 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
2462 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
2463 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
2464 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
2465 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
2466 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
2467 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
2468 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
2469 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
2470 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
2471 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
2472 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
2473 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
2474 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
2475 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
2476 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
2477 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
2478 else {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
2479}
2480//________________________________________________________________________
2481void AliAnalysisTaskGammaConvV1::RelabelAODPhotonCandidates(Bool_t mode){
2482
2483 // Relabeling For AOD Event
2484 // ESDiD -> AODiD
2485 // MCLabel -> AODMCLabel
2486
2487 if(mode){
2488 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
2489 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
1186afd2 2490 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
2491 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
ae947965 2492 }
2493
2494 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
2495 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
2496 if(!PhotonCandidate) continue;
2497 if(!mode){// Back to ESD Labels
2498 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
2499 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
1186afd2 2500 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
2501 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
ae947965 2502 continue;
2503 }
2504 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
2505 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
1186afd2 2506 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
2507 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
ae947965 2508
2509 Bool_t AODLabelPos = kFALSE;
2510 Bool_t AODLabelNeg = kFALSE;
2511
2512 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
2513 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
2514 if(!AODLabelPos){
2515 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
2516 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
1186afd2 2517 PhotonCandidate->SetLabelPositive(i);
ae947965 2518 AODLabelPos = kTRUE;
2519 }
2520 }
2521 if(!AODLabelNeg){
2522 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
2523 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
1186afd2 2524 PhotonCandidate->SetLabelNegative(i);
ae947965 2525 AODLabelNeg = kTRUE;
2526 }
2527 }
2528 if(AODLabelNeg && AODLabelPos){
2529 break;
2530 }
1186afd2 2531 }
ae947965 2532 if(!AODLabelPos || !AODLabelNeg){
1186afd2 2533 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
ae947965 2534 }
2535 }
2536
1186afd2 2537
ae947965 2538 if(!mode){
2539 delete[] fMCStackPos;
2540 delete[] fMCStackNeg;
1186afd2 2541 delete[] fESDArrayPos;
2542 delete[] fESDArrayNeg;
ae947965 2543 }
2544}
d8b864f8
FB		 2545
2546void AliAnalysisTaskGammaConvV1::SetLogBinningXTH2(TH2* histoRebin){
2547 TAxis *axisafter = histoRebin->GetXaxis();
2548 Int_t bins = axisafter->GetNbins();
2549 Double_t from = axisafter->GetXmin();
2550 Double_t to = axisafter->GetXmax();
2551 Double_t *newbins = new Double_t[bins+1];
2552 newbins[0] = from;
2553 Double_t factor = TMath::Power(to/from, 1./bins);
2554 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
2555 axisafter->Set(bins, newbins);
2556 delete [] newbins;
2557
2558}
2559
ae947965 2560//________________________________________________________________________
2bb2434e 2561void AliAnalysisTaskGammaConvV1::Terminate(const Option_t *)
2562{
e5b6e8a6 2563
a280ac15 2564 //fOutputContainer->Print(); // Will crash on GRID
2bb2434e 2565}
d9d6352b 2566
2567//________________________________________________________________________
2568Int_t AliAnalysisTaskGammaConvV1::GetSourceClassification(Int_t daughter, Int_t pdgCode){
2569
2570 if (daughter == 111) {
2571 if (abs(pdgCode) == 310) return 1; // k0s
2572 else if (abs(pdgCode) == 3122) return 2; // Lambda
2573 else if (abs(pdgCode) == 130) return 3; // K0L
2574 else if (abs(pdgCode) == 2212) return 4; // proton
2575 else if (abs(pdgCode) == 2112) return 5; // neutron
2576 else if (abs(pdgCode) == 211) return 6; // pion
2577 else if (abs(pdgCode) == 321) return 7; // kaon
2578 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
2579 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112 ) return 9; // Sigma
2580 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114 ) return 10; // Delta
2581 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323 ) return 11; // K*
2582 else return 15;
2583 }
2584 return 15;
2585
2586}