]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/GammaConv/AliConversionPhotonCuts.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- changed order of filling validated histograms
[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliConversionPhotonCuts.cxx
CommitLineData
344100c4 1/****************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Authors: Friederike Bock *
5 * Version 1.0 *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 ***************************************************************************/
15
16////////////////////////////////////////////////
17//---------------------------------------------
18// Class handling photon selection cuts for
19// Gamma Conversion analysis
20//---------------------------------------------
21////////////////////////////////////////////////
22
23#include "AliConversionPhotonCuts.h"
24
25#include "AliKFVertex.h"
26#include "AliAODTrack.h"
27#include "AliESDtrack.h"
28#include "AliAnalysisManager.h"
29#include "AliInputEventHandler.h"
30#include "AliMCEventHandler.h"
31#include "AliAODHandler.h"
32#include "AliPIDResponse.h"
33#include "TH1.h"
34#include "TH2.h"
35#include "TF1.h"
36#include "AliStack.h"
37#include "AliAODConversionMother.h"
38#include "TObjString.h"
39#include "AliAODEvent.h"
40#include "AliESDEvent.h"
41#include "AliCentrality.h"
42#include "TList.h"
43#include "TFile.h"
44#include "AliLog.h"
45#include "AliGenCocktailEventHeader.h"
46#include "AliGenDPMjetEventHeader.h"
47#include "AliGenPythiaEventHeader.h"
48#include "AliGenHijingEventHeader.h"
49#include "AliTriggerAnalysis.h"
50#include "AliV0ReaderV1.h"
51#include "AliAODMCParticle.h"
52#include "AliAODMCHeader.h"
53#include "AliTRDTriggerAnalysis.h"
54
55class iostream;
56
57using namespace std;
58
59ClassImp(AliConversionPhotonCuts)
60
61
62const char* AliConversionPhotonCuts::fgkCutNames[AliConversionPhotonCuts::kNCuts] = {
63 "V0FinderType", // 0
64 "EtaCut", // 1
65 "MinRCut", // 2
66 "SinglePtCut", // 3
67 "ClsTPCCut", // 4
68 "ededxSigmaCut", // 5
69 "pidedxSigmaCut", // 6
70 "piMomdedxSigmaCut", // 7
71 "piMaxMomdedxSigmaCut", // 8
72 "LowPRejectionSigmaCut", // 9
73 "TOFelectronPID", // 10
74 "QtMaxCut", // 11
75 "Chi2GammaCut", // 12
76 "PsiPair", // 13
77 "DoPhotonAsymmetryCut", // 14
78 "CosinePointingAngle", // 15
79 "SharedElectronCuts", // 16
80 "RejectToCloseV0s", // 17
81 "DcaRPrimVtx", // 18
82 "DcaZPrimVtx", // 19
83 "EvetPlane" // 20
84};
85
86
87//________________________________________________________________________
88AliConversionPhotonCuts::AliConversionPhotonCuts(const char *name,const char *title) :
89 AliAnalysisCuts(name,title),
90 fHistograms(NULL),
91 fPIDResponse(NULL),
92 fMaxR(200),
93 fMinR(0),
94 fEtaCut(0.9),
95 fEtaCutMin(-0.1),
96 fPtCut(0.02),
97 fSinglePtCut(0),
98 fMaxZ(1000),
99 fMinClsTPC(0.),
100 fMinClsTPCToF(0.),
101 fLineCutZRSlope(0.),
102 fLineCutZValue(0),
103 fLineCutZRSlopeMin(0.),
104 fLineCutZValueMin(0),
105 fChi2CutConversion(1000),
106 fPIDProbabilityCutNegativeParticle(0),
107 fPIDProbabilityCutPositiveParticle(0),
108 fDodEdxSigmaCut(kTRUE),
109 fDoTOFsigmaCut(kFALSE),
110 fPIDTRDEfficiency(1),
111 fDoTRDPID(kFALSE),
112 fPIDnSigmaAboveElectronLine(100),
113 fPIDnSigmaBelowElectronLine(-100),
114 fTofPIDnSigmaAboveElectronLine(100),
115 fTofPIDnSigmaBelowElectronLine(-100),
116 fPIDnSigmaAbovePionLine(0),
117 fPIDnSigmaAbovePionLineHighPt(-100),
118 fPIDMinPnSigmaAbovePionLine(0),
119 fPIDMaxPnSigmaAbovePionLine(0),
120 fDoKaonRejectionLowP(kFALSE),
121 fDoProtonRejectionLowP(kFALSE),
122 fDoPionRejectionLowP(kFALSE),
123 fPIDnSigmaAtLowPAroundKaonLine(0),
124 fPIDnSigmaAtLowPAroundProtonLine(0),
125 fPIDnSigmaAtLowPAroundPionLine(0),
126 fPIDMinPKaonRejectionLowP(1.5),
127 fPIDMinPProtonRejectionLowP(2),
128 fPIDMinPPionRejectionLowP(0),
129 fDoQtGammaSelection(kTRUE),
130 fDo2DQt(kFALSE),
131 fQtMax(100),
132 fNSigmaMass(0.),
133 fUseEtaMinCut(kFALSE),
134 fUseOnFlyV0Finder(kTRUE),
135 fDoPhotonAsymmetryCut(kTRUE),
136 fMinPPhotonAsymmetryCut(100.),
137 fMinPhotonAsymmetry(0.),
138 fUseCorrectedTPCClsInfo(kFALSE),
139 fUseTOFpid(kFALSE),
140 fOpeningAngle(0.005),
141 fPsiPairCut(10000),
142 fDo2DPsiPairChi2(kFALSE),
143 fCosPAngleCut(10000),
144 fDoToCloseV0sCut(kFALSE),
145 fminV0Dist(200.),
146 fDoSharedElecCut(kFALSE),
147 fDoPhotonQualitySelectionCut(kFALSE),
148 fPhotonQualityCut(0),
149 fRandom(0),
150 fElectronArraySize(500),
151 fElectronLabelArray(NULL),
152 fDCAZPrimVtxCut(1000),
153 fDCARPrimVtxCut(1000),
154 fInPlaneOutOfPlane(0),
155 fConversionPointXArray(0.0),
156 fConversionPointYArray(0.0),
157 fConversionPointZArray(0.0),
158 fCutString(NULL),
159 fIsHeavyIon(0),
160 hEtaDistV0s(NULL),
161 hEtaDistV0sAfterdEdxCuts(NULL),
162 hdEdxCuts(NULL),
163 hTPCdEdxbefore(NULL),
164 hTPCdEdxafter(NULL),
165 hTPCdEdxSigbefore(NULL),
166 hTPCdEdxSigafter(NULL),
167 hTOFbefore(NULL),
168 hTOFSigbefore(NULL),
169 hTOFSigafter(NULL),
170 hPsiPairDeltaPhiafter(NULL),
171 hTrackCuts(NULL),
172 hPhotonCuts(NULL),
173 hInvMassbefore(NULL),
174 hArmenterosbefore(NULL),
175 hInvMassafter(NULL),
176 hArmenterosafter(NULL),
177 hAcceptanceCuts(NULL),
178 hCutIndex(NULL),
179 hEventPlanePhi(NULL),
180 fPreSelCut(kFALSE)
181{
182 InitPIDResponse();
183 for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=0;}
184 fCutString=new TObjString((GetCutNumber()).Data());
185
186 fElectronLabelArray = new Int_t[fElectronArraySize];
187}
188
189//________________________________________________________________________
190AliConversionPhotonCuts::AliConversionPhotonCuts(const AliConversionPhotonCuts &ref) :
191 AliAnalysisCuts(ref),
192 fHistograms(NULL),
193 fPIDResponse(NULL),
194 fMaxR(ref.fMaxR),
195 fMinR(ref.fMinR),
196 fEtaCut(ref.fEtaCut),
197 fEtaCutMin(ref.fEtaCutMin),
198 fPtCut(ref.fPtCut),
199 fSinglePtCut(ref.fSinglePtCut),
200 fMaxZ(ref.fMaxZ),
201 fMinClsTPC(ref.fMinClsTPC),
202 fMinClsTPCToF(ref.fMinClsTPCToF),
203 fLineCutZRSlope(ref.fLineCutZRSlope),
204 fLineCutZValue(ref.fLineCutZValue),
205 fLineCutZRSlopeMin(ref.fLineCutZRSlopeMin),
206 fLineCutZValueMin(ref.fLineCutZValueMin),
207 fChi2CutConversion(ref.fChi2CutConversion),
208 fPIDProbabilityCutNegativeParticle(ref.fPIDProbabilityCutNegativeParticle),
209 fPIDProbabilityCutPositiveParticle(ref.fPIDProbabilityCutPositiveParticle),
210 fDodEdxSigmaCut(ref. fDodEdxSigmaCut),
211 fDoTOFsigmaCut(ref.fDoTOFsigmaCut),
212 fPIDTRDEfficiency(ref.fPIDTRDEfficiency),
213 fDoTRDPID(ref.fDoTRDPID),
214 fPIDnSigmaAboveElectronLine(ref.fPIDnSigmaAboveElectronLine),
215 fPIDnSigmaBelowElectronLine(ref.fPIDnSigmaBelowElectronLine),
216 fTofPIDnSigmaAboveElectronLine(ref.fTofPIDnSigmaAboveElectronLine),
217 fTofPIDnSigmaBelowElectronLine(ref.fTofPIDnSigmaBelowElectronLine),
218 fPIDnSigmaAbovePionLine(ref.fPIDnSigmaAbovePionLine),
219 fPIDnSigmaAbovePionLineHighPt(ref.fPIDnSigmaAbovePionLineHighPt),
220 fPIDMinPnSigmaAbovePionLine(ref.fPIDMinPnSigmaAbovePionLine),
221 fPIDMaxPnSigmaAbovePionLine(ref.fPIDMaxPnSigmaAbovePionLine),
222 fDoKaonRejectionLowP(ref.fDoKaonRejectionLowP),
223 fDoProtonRejectionLowP(ref.fDoProtonRejectionLowP),
224 fDoPionRejectionLowP(ref.fDoPionRejectionLowP),
225 fPIDnSigmaAtLowPAroundKaonLine(ref.fPIDnSigmaAtLowPAroundKaonLine),
226 fPIDnSigmaAtLowPAroundProtonLine(ref.fPIDnSigmaAtLowPAroundProtonLine),
227 fPIDnSigmaAtLowPAroundPionLine(ref.fPIDnSigmaAtLowPAroundPionLine),
228 fPIDMinPKaonRejectionLowP(ref.fPIDMinPKaonRejectionLowP),
229 fPIDMinPProtonRejectionLowP(ref.fPIDMinPProtonRejectionLowP),
230 fPIDMinPPionRejectionLowP(ref.fPIDMinPPionRejectionLowP),
231 fDoQtGammaSelection(ref.fDoQtGammaSelection),
232 fDo2DQt(ref.fDo2DQt),
233 fQtMax(ref.fQtMax),
234 fNSigmaMass(ref.fNSigmaMass),
235 fUseEtaMinCut(ref.fUseEtaMinCut),
236 fUseOnFlyV0Finder(ref.fUseOnFlyV0Finder),
237 fDoPhotonAsymmetryCut(ref.fDoPhotonAsymmetryCut),
238 fMinPPhotonAsymmetryCut(ref.fMinPPhotonAsymmetryCut),
239 fMinPhotonAsymmetry(ref.fMinPhotonAsymmetry),
240 fUseCorrectedTPCClsInfo(ref.fUseCorrectedTPCClsInfo),
241 fUseTOFpid(ref.fUseTOFpid),
242 fOpeningAngle(ref.fOpeningAngle),
243 fPsiPairCut(ref.fPsiPairCut),
244 fDo2DPsiPairChi2(ref.fDo2DPsiPairChi2),
245 fCosPAngleCut(ref.fCosPAngleCut),
246 fDoToCloseV0sCut(ref.fDoToCloseV0sCut),
247 fminV0Dist(ref.fminV0Dist),
248 fDoSharedElecCut(ref.fDoSharedElecCut),
249 fDoPhotonQualitySelectionCut(ref.fDoPhotonQualitySelectionCut),
250 fPhotonQualityCut(ref.fPhotonQualityCut),
251 fRandom(ref.fRandom),
252 fElectronArraySize(ref.fElectronArraySize),
253 fElectronLabelArray(NULL),
254 fDCAZPrimVtxCut(ref.fDCAZPrimVtxCut),
255 fDCARPrimVtxCut(ref.fDCAZPrimVtxCut),
256 fInPlaneOutOfPlane(ref.fInPlaneOutOfPlane),
257 fConversionPointXArray(ref.fConversionPointXArray),
258 fConversionPointYArray(ref.fConversionPointYArray),
259 fConversionPointZArray(ref.fConversionPointZArray),
260 fCutString(NULL),
261 fIsHeavyIon(ref.fIsHeavyIon),
262 hEtaDistV0s(NULL),
263 hEtaDistV0sAfterdEdxCuts(NULL),
264 hdEdxCuts(NULL),
265 hTPCdEdxbefore(NULL),
266 hTPCdEdxafter(NULL),
267 hTPCdEdxSigbefore(NULL),
268 hTPCdEdxSigafter(NULL),
269 hTOFbefore(NULL),
270 hTOFSigbefore(NULL),
271 hTOFSigafter(NULL),
272 hPsiPairDeltaPhiafter(NULL),
273 hTrackCuts(NULL),
274 hPhotonCuts(NULL),
275 hInvMassbefore(NULL),
276 hArmenterosbefore(NULL),
277 hInvMassafter(NULL),
278 hArmenterosafter(NULL),
279 hAcceptanceCuts(NULL),
280 hCutIndex(NULL),
281 hEventPlanePhi(NULL),
282 fPreSelCut(ref.fPreSelCut)
283{
284 // Copy Constructor
285 for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=ref.fCuts[jj];}
286 fCutString=new TObjString((GetCutNumber()).Data());
287 fElectronLabelArray = new Int_t[fElectronArraySize];
288 // dont copy histograms (if you like histograms, call InitCutHistograms())
289
290}
291
292
293//________________________________________________________________________
294AliConversionPhotonCuts::~AliConversionPhotonCuts() {
295 // Destructor
296 //Deleting fHistograms leads to seg fault it it's added to output collection of a task
297 // if(fHistograms)
298 // delete fHistograms;
299 // fHistograms = NULL;
300 if(fCutString != NULL){
301 delete fCutString;
302 fCutString = NULL;
303 }
304 if(fElectronLabelArray){
305 delete fElectronLabelArray;
306 fElectronLabelArray = NULL;
307 }
308}
309
310//________________________________________________________________________
311void AliConversionPhotonCuts::InitCutHistograms(TString name, Bool_t preCut){
312
313 // Initialize Cut Histograms for QA (only initialized and filled if function is called)
314 TH1::AddDirectory(kFALSE);
315
316 if(fHistograms != NULL){
317 delete fHistograms;
318 fHistograms=NULL;
319 }
320 if(fHistograms==NULL){
321 fHistograms=new TList();
322 fHistograms->SetOwner(kTRUE);
323 if(name=="")fHistograms->SetName(Form("ConvCuts_%s",GetCutNumber().Data()));
324 else fHistograms->SetName(Form("%s_%s",name.Data(),GetCutNumber().Data()));
325 }
326
327 // IsPhotonSelected
328 hCutIndex=new TH1F(Form("IsPhotonSelected %s",GetCutNumber().Data()),"IsPhotonSelected",11,-0.5,10.5);
329 hCutIndex->GetXaxis()->SetBinLabel(kPhotonIn+1,"in");
330 hCutIndex->GetXaxis()->SetBinLabel(kOnFly+1,"onfly");
331 hCutIndex->GetXaxis()->SetBinLabel(kNoTracks+1,"no tracks");
332 hCutIndex->GetXaxis()->SetBinLabel(kdEdxCuts+1,"dEdx");
333 hCutIndex->GetXaxis()->SetBinLabel(kTrackCuts+1,"Track cuts");
334 hCutIndex->GetXaxis()->SetBinLabel(kConvPointFail+1,"ConvPoint fail");
335 hCutIndex->GetXaxis()->SetBinLabel(kPhotonCuts+1,"PhotonCuts");
336 hCutIndex->GetXaxis()->SetBinLabel(kEventPlane+1,"EventPlane");
337 hCutIndex->GetXaxis()->SetBinLabel(kPhotonOut+1,"out");
338 fHistograms->Add(hCutIndex);
339
340 // Track Cuts
341 hTrackCuts=new TH1F(Form("TrackCuts %s",GetCutNumber().Data()),"TrackCuts",9,-0.5,8.5);
342 hTrackCuts->GetXaxis()->SetBinLabel(1,"in");
343 hTrackCuts->GetXaxis()->SetBinLabel(2,"likesign");
344 hTrackCuts->GetXaxis()->SetBinLabel(3,"ntpccl");
345 hTrackCuts->GetXaxis()->SetBinLabel(4,"acceptance");
346 hTrackCuts->GetXaxis()->SetBinLabel(5,"singlept");
347 hTrackCuts->GetXaxis()->SetBinLabel(6,"TPCrefit");
348 hTrackCuts->GetXaxis()->SetBinLabel(7,"kink");
349 hTrackCuts->GetXaxis()->SetBinLabel(8,"out");
350 fHistograms->Add(hTrackCuts);
351
352 // Photon Cuts
353 hPhotonCuts=new TH1F(Form("PhotonCuts %s",GetCutNumber().Data()),"PhotonCuts",15,-0.5,14.5);
354 hPhotonCuts->GetXaxis()->SetBinLabel(1,"in");
355 hPhotonCuts->GetXaxis()->SetBinLabel(2,"qtcut");
356 hPhotonCuts->GetXaxis()->SetBinLabel(3,"chi2");
357 hPhotonCuts->GetXaxis()->SetBinLabel(4,"acceptance");
358 hPhotonCuts->GetXaxis()->SetBinLabel(5,"asymmetry");
359 hPhotonCuts->GetXaxis()->SetBinLabel(6,"pidprob");
360 hPhotonCuts->GetXaxis()->SetBinLabel(7,"cortpcclinfo");
361 hPhotonCuts->GetXaxis()->SetBinLabel(8,"PsiPair");
362 hPhotonCuts->GetXaxis()->SetBinLabel(9,"CosPAngle");
363 hPhotonCuts->GetXaxis()->SetBinLabel(10,"DCA R");
364 hPhotonCuts->GetXaxis()->SetBinLabel(11,"DCA Z");
365 hPhotonCuts->GetXaxis()->SetBinLabel(12,"Photon Quality");
366 hPhotonCuts->GetXaxis()->SetBinLabel(13,"out");
367 fHistograms->Add(hPhotonCuts);
368
369 if(preCut){
370 hInvMassbefore=new TH1F(Form("InvMass_before %s",GetCutNumber().Data()),"InvMass_before",1000,0,0.3);
371 fHistograms->Add(hInvMassbefore);
372 hArmenterosbefore=new TH2F(Form("Armenteros_before %s",GetCutNumber().Data()),"Armenteros_before",200,-1,1,1000,0,1.);
373 fHistograms->Add(hArmenterosbefore);
374 hEtaDistV0s = new TH1F(Form("Eta_before %s",GetCutNumber().Data()),"Eta_before",2000,-2,2);
375 fHistograms->Add(hEtaDistV0s);
376
377 }
378 hInvMassafter=new TH1F(Form("InvMass_after %s",GetCutNumber().Data()),"InvMass_after",1000,0,0.3);
379 fHistograms->Add(hInvMassafter);
380 hArmenterosafter=new TH2F(Form("Armenteros_after %s",GetCutNumber().Data()),"Armenteros_after",200,-1,1,250,0,0.25);
381 fHistograms->Add(hArmenterosafter);
382
383 hAcceptanceCuts=new TH1F(Form("PhotonAcceptanceCuts %s",GetCutNumber().Data()),"PhotonAcceptanceCuts",10,-0.5,9.5);
384 hAcceptanceCuts->GetXaxis()->SetBinLabel(1,"in");
385 hAcceptanceCuts->GetXaxis()->SetBinLabel(2,"maxR");
386 hAcceptanceCuts->GetXaxis()->SetBinLabel(3,"minR");
387 hAcceptanceCuts->GetXaxis()->SetBinLabel(4,"line");
388 hAcceptanceCuts->GetXaxis()->SetBinLabel(5,"maxZ");
389 hAcceptanceCuts->GetXaxis()->SetBinLabel(6,"eta");
390 hAcceptanceCuts->GetXaxis()->SetBinLabel(7,"minpt");
391 hAcceptanceCuts->GetXaxis()->SetBinLabel(8,"out");
392 fHistograms->Add(hAcceptanceCuts);
393
394 // dEdx Cuts
395 hdEdxCuts=new TH1F(Form("dEdxCuts %s",GetCutNumber().Data()),"dEdxCuts",10,-0.5,9.5);
396 hdEdxCuts->GetXaxis()->SetBinLabel(1,"in");
397 hdEdxCuts->GetXaxis()->SetBinLabel(2,"TPCelectron");
398 hdEdxCuts->GetXaxis()->SetBinLabel(3,"TPCpion");
399 hdEdxCuts->GetXaxis()->SetBinLabel(4,"TPCpionhighp");
400 hdEdxCuts->GetXaxis()->SetBinLabel(5,"TPCkaonlowprej");
401 hdEdxCuts->GetXaxis()->SetBinLabel(6,"TPCprotonlowprej");
402 hdEdxCuts->GetXaxis()->SetBinLabel(7,"TPCpionlowprej");
403 hdEdxCuts->GetXaxis()->SetBinLabel(8,"TOFelectron");
404 hdEdxCuts->GetXaxis()->SetBinLabel(9,"TRDelectron");
405 hdEdxCuts->GetXaxis()->SetBinLabel(10,"out");
406 fHistograms->Add(hdEdxCuts);
407
408 TAxis *AxisBeforedEdx = NULL;
409 TAxis *AxisBeforedEdxSig = NULL;
410 TAxis *AxisBeforeTOF = NULL;
411 TAxis *AxisBeforeTOFSig = NULL;
412 if(preCut){
413 hTPCdEdxbefore=new TH2F(Form("Gamma_dEdx_before %s",GetCutNumber().Data()),"dEdx Gamma before" ,150,0.03,20,800,0,200);
414 fHistograms->Add(hTPCdEdxbefore);
415 AxisBeforedEdx = hTPCdEdxbefore->GetXaxis();
416 hTPCdEdxSigbefore=new TH2F(Form("Gamma_dEdxSig_before %s",GetCutNumber().Data()),"dEdx Sigma Gamma before" ,150,0.03,20,400,-10,10);
417 fHistograms->Add(hTPCdEdxSigbefore);
418 AxisBeforedEdxSig = hTPCdEdxSigbefore->GetXaxis();
419
420 hTOFbefore=new TH2F(Form("Gamma_TOF_before %s",GetCutNumber().Data()),"TOF Gamma before" ,150,0.03,20,11000,-1000,10000);
421 fHistograms->Add(hTOFbefore);
422 AxisBeforeTOF = hTOFbefore->GetXaxis();
423 hTOFSigbefore=new TH2F(Form("Gamma_TOFSig_before %s",GetCutNumber().Data()),"TOF Sigma Gamma before" ,150,0.03,20,400,-6,10);
424 fHistograms->Add(hTOFSigbefore);
425 AxisBeforeTOFSig = hTOFSigbefore->GetXaxis();
426
427 }
428 hTPCdEdxSigafter=new TH2F(Form("Gamma_dEdxSig_after %s",GetCutNumber().Data()),"dEdx Sigma Gamma after" ,150,0.03,20,400, -10,10);
429 fHistograms->Add(hTPCdEdxSigafter);
430
431 hTPCdEdxafter=new TH2F(Form("Gamma_dEdx_after %s",GetCutNumber().Data()),"dEdx Gamma after" ,150,0.03,20,800,0,200);
432 fHistograms->Add(hTPCdEdxafter);
433
434 hTOFSigafter=new TH2F(Form("Gamma_TOFSig_after %s",GetCutNumber().Data()),"TOF Sigma Gamma after" ,150,0.03,20,400,-6,10);
435 fHistograms->Add(hTOFSigafter);
436
437 hEtaDistV0sAfterdEdxCuts = new TH1F(Form("Eta_afterdEdx %s",GetCutNumber().Data()),"Eta_afterdEdx",2000,-2,2);
438 fHistograms->Add(hEtaDistV0sAfterdEdxCuts);
439
440 hPsiPairDeltaPhiafter=new TH2F(Form("Gamma_PsiPairDeltaPhi_after %s",GetCutNumber().Data()),"Psi Pair vs Delta Phi Gamma after" ,200,-2,2,200,-2,2);
441 fHistograms->Add(hPsiPairDeltaPhiafter);
442
443 TAxis *AxisAfter = hTPCdEdxSigafter->GetXaxis();
444 Int_t bins = AxisAfter->GetNbins();
445 Double_t from = AxisAfter->GetXmin();
446 Double_t to = AxisAfter->GetXmax();
447 Double_t *newBins = new Double_t[bins+1];
448 newBins[0] = from;
449 Double_t factor = TMath::Power(to/from, 1./bins);
450 for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];
451 AxisAfter->Set(bins, newBins);
452 AxisAfter = hTOFSigafter->GetXaxis();
453 AxisAfter->Set(bins, newBins);
454 AxisAfter = hTPCdEdxafter->GetXaxis();
455 AxisAfter->Set(bins, newBins);
456 if(preCut){
457 AxisBeforedEdx->Set(bins, newBins);
458 AxisBeforeTOF->Set(bins, newBins);
459 AxisBeforedEdxSig->Set(bins, newBins);
460 AxisBeforeTOFSig->Set(bins, newBins);
461 }
462 delete [] newBins;
463
464 // Event Cuts and Info
465 if(!preCut){
466 hEventPlanePhi=new TH1F(Form("EventPlaneMinusPhotonAngle %s",GetCutNumber().Data()),"EventPlaneMinusPhotonAngle",360,-TMath::Pi(),TMath::Pi());
467 fHistograms->Add(hEventPlanePhi);
468
469
470 }
471 TH1::AddDirectory(kTRUE);
472}
473
474//________________________________________________________________________
475Bool_t AliConversionPhotonCuts::InitPIDResponse(){
476 // Set Pointer to AliPIDResponse
477
478 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
479 if(man) {
480 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
481 fPIDResponse = (AliPIDResponse*)inputHandler->GetPIDResponse();
482 if(fPIDResponse)return kTRUE;
483
484 }
485
486
487 return kFALSE;
488}
489
490///________________________________________________________________________
491Bool_t AliConversionPhotonCuts::PhotonIsSelectedMC(TParticle *particle,AliStack *fMCStack,Bool_t checkForConvertedGamma){
492 // MonteCarlo Photon Selection
493
494 if(!fMCStack)return kFALSE;
495
496 if (particle->GetPdgCode() == 22){
497
498
499 if( particle->Eta() > (fEtaCut) || particle->Eta() < (-fEtaCut) )
500 return kFALSE;
501 if(fEtaCutMin>-0.1){
502 if( particle->Eta() < (fEtaCutMin) && particle->Eta() > (-fEtaCutMin) )
503 return kFALSE;
504 }
505
506 if(particle->GetMother(0) >-1 && fMCStack->Particle(particle->GetMother(0))->GetPdgCode() == 22){
507 return kFALSE; // no photon as mothers!
508 }
509
510 if(particle->GetMother(0) >= fMCStack->GetNprimary()){
511 return kFALSE; // the gamma has a mother, and it is not a primary particle
512 }
513
514 if(!checkForConvertedGamma) return kTRUE; // return in case of accepted gamma
515
516 // looking for conversion gammas (electron + positron from pairbuilding (= 5) )
517 TParticle* ePos = NULL;
518 TParticle* eNeg = NULL;
519
520 if(particle->GetNDaughters() >= 2){
521 for(Int_t daughterIndex=particle->GetFirstDaughter();daughterIndex<=particle->GetLastDaughter();daughterIndex++){
522 TParticle *tmpDaughter = fMCStack->Particle(daughterIndex);
523 if(tmpDaughter->GetUniqueID() == 5){
524 if(tmpDaughter->GetPdgCode() == 11){
525 eNeg = tmpDaughter;
526 } else if(tmpDaughter->GetPdgCode() == -11){
527 ePos = tmpDaughter;
528 }
529 }
530 }
531 }
532
533 if(ePos == NULL || eNeg == NULL){ // means we do not have two daughters from pair production
534 return kFALSE;
535 }
536
537 if(ePos->Pt()<fSinglePtCut || eNeg->Pt()<fSinglePtCut){
538 return kFALSE; // no reconstruction below the Pt cut
539 }
540
541 if( ePos->Eta() > (fEtaCut) || ePos->Eta() < (-fEtaCut) ||
542 eNeg->Eta() > (fEtaCut) || eNeg->Eta() < (-fEtaCut) )
543 return kFALSE;
544
545 if(fEtaCutMin > -0.1){
546 if( (ePos->Eta() < (fEtaCutMin) && ePos->Eta() > (-fEtaCutMin)) ||
547 (eNeg->Eta() < (fEtaCutMin) && eNeg->Eta() > (-fEtaCutMin)) )
548 return kFALSE;
549 }
550
551 if(ePos->R()>fMaxR){
552 return kFALSE; // cuts on distance from collision point
553 }
554
555 if(abs(ePos->Vz()) > fMaxZ){
556 return kFALSE; // outside material
557 }
558 if(abs(eNeg->Vz()) > fMaxZ){
559 return kFALSE; // outside material
560 }
561
562 if( ePos->R() <= ((abs(ePos->Vz()) * fLineCutZRSlope) - fLineCutZValue)){
563 return kFALSE; // line cut to exclude regions where we do not reconstruct
564 } else if ( fEtaCutMin != -0.1 && ePos->R() >= ((abs(ePos->Vz()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
565 return kFALSE;
566 }
567
568 if( eNeg->R() <= ((abs(eNeg->Vz()) * fLineCutZRSlope) - fLineCutZValue)){
569 return kFALSE; // line cut to exclude regions where we do not reconstruct
570 } else if ( fEtaCutMin != -0.1 && eNeg->R() >= ((abs(eNeg->Vz()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
571 return kFALSE;
572 }
573
574 return kTRUE;
575 //if(AcceptanceCut(particle,ePos,eNeg))return kTRUE;
576 }
577 return kFALSE;
578}
579///________________________________________________________________________
580Bool_t AliConversionPhotonCuts::PhotonIsSelectedAODMC(AliAODMCParticle *particle,TClonesArray *aodmcArray,Bool_t checkForConvertedGamma){
581 // MonteCarlo Photon Selection
582
583 if(!aodmcArray)return kFALSE;
584
585 if (particle->GetPdgCode() == 22){
586 if( particle->Eta() > (fEtaCut) || particle->Eta() < (-fEtaCut) )
587 return kFALSE;
588 if(fEtaCutMin>-0.1){
589 if( particle->Eta() < (fEtaCutMin) && particle->Eta() > (-fEtaCutMin) )
590 return kFALSE;
591 }
592
593 if(particle->GetMother() > -1){
594 if((static_cast<AliAODMCParticle*>(aodmcArray->At(particle->GetMother())))->GetPdgCode() == 22){
595 return kFALSE; // no photon as mothers!
596 }
597 if(!(static_cast<AliAODMCParticle*>(aodmcArray->At(particle->GetMother()))->IsPrimary())){
598 return kFALSE; // the gamma has a mother, and it is not a primary particle
599 }
600 }
601
602 if(!checkForConvertedGamma) return kTRUE; // return in case of accepted gamma
603
604 // looking for conversion gammas (electron + positron from pairbuilding (= 5) )
605 AliAODMCParticle* ePos = NULL;
606 AliAODMCParticle* eNeg = NULL;
607
608 if(particle->GetNDaughters() >= 2){
609 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
610 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(aodmcArray->At(daughterIndex));
611 if(!tmpDaughter) continue;
612 if(((tmpDaughter->GetMCProcessCode())) == 5){ // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
613 if(tmpDaughter->GetPdgCode() == 11){
614 eNeg = tmpDaughter;
615 } else if(tmpDaughter->GetPdgCode() == -11){
616 ePos = tmpDaughter;
617 }
618 }
619 }
620 }
621
622 if(ePos == NULL || eNeg == NULL){ // means we do not have two daughters from pair production
623 return kFALSE;
624 }
625
626 if(ePos->Pt()<fSinglePtCut || eNeg->Pt()<fSinglePtCut){
627 return kFALSE; // no reconstruction below the Pt cut
628 }
629
630 if( ePos->Eta() > (fEtaCut) || ePos->Eta() < (-fEtaCut) ||
631 eNeg->Eta() > (fEtaCut) || eNeg->Eta() < (-fEtaCut) )
632 return kFALSE;
633
634 if(fEtaCutMin > -0.1){
635 if( (ePos->Eta() < (fEtaCutMin) && ePos->Eta() > (-fEtaCutMin)) ||
636 (eNeg->Eta() < (fEtaCutMin) && eNeg->Eta() > (-fEtaCutMin)) )
637 return kFALSE;
638 }
639
640 Double_t rPos = sqrt( (ePos->Xv()*ePos->Xv()) + (ePos->Yv()*ePos->Yv()) );
641 Double_t rNeg = sqrt( (eNeg->Xv()*eNeg->Xv()) + (eNeg->Yv()*eNeg->Yv()) );
642
643 if(rPos>fMaxR){
644 return kFALSE; // cuts on distance from collision point
645 }
646 if(abs(ePos->Zv()) > fMaxZ){
647 return kFALSE; // outside material
648 }
649 if(abs(eNeg->Zv()) > fMaxZ){
650 return kFALSE; // outside material
651 }
652
653 if( rPos <= ((abs(ePos->Zv()) * fLineCutZRSlope) - fLineCutZValue)){
654 return kFALSE; // line cut to exclude regions where we do not reconstruct
655 } else if ( fEtaCutMin != -0.1 && rPos >= ((abs(ePos->Zv()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
656 return kFALSE;
657 }
658
659 if( rNeg <= ((abs(eNeg->Zv()) * fLineCutZRSlope) - fLineCutZValue)){
660 return kFALSE; // line cut to exclude regions where we do not reconstruct
661 } else if ( fEtaCutMin != -0.1 && rNeg >= ((abs(eNeg->Zv()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
662 return kFALSE;
663 }
664
665 return kTRUE;
666 //if(AcceptanceCut(particle,ePos,eNeg))return kTRUE;
667 }
668 return kFALSE;
669}
670
671///________________________________________________________________________
672Bool_t AliConversionPhotonCuts::PhotonCuts(AliConversionPhotonBase *photon,AliVEvent *event)
673{ // Specific Photon Cuts
674
675 Int_t cutIndex = 0;
676 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex);
677 cutIndex++;
678
679 // Fill Histos before Cuts
680 if(hInvMassbefore)hInvMassbefore->Fill(photon->GetMass());
681 if(hArmenterosbefore)hArmenterosbefore->Fill(photon->GetArmenterosAlpha(),photon->GetArmenterosQt());
682
683 // Gamma selection based on QT from Armenteros
684 if(fDoQtGammaSelection == kTRUE){
685 if(!ArmenterosQtCut(photon)){
686 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //1
687 return kFALSE;
688 }
689 }
690 cutIndex++; //2
691
692 // Chi Cut
693 if(photon->GetChi2perNDF() > fChi2CutConversion || photon->GetChi2perNDF() <=0){
694 {
695 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //2
696 return kFALSE;
697 }
698 }
699 cutIndex++;//3
700
701 // Reconstruction Acceptance Cuts
702 if(!AcceptanceCuts(photon)){
703 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //3
704 return kFALSE;
705 }
706
707 cutIndex++; //4
708 // Asymmetry Cut
709 if(fDoPhotonAsymmetryCut == kTRUE){
710 if(!AsymmetryCut(photon,event)){
711 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //4
712 return kFALSE;
713 }
714 }
715
716 //Check the pid probability
717 cutIndex++; //5
718 if(!PIDProbabilityCut(photon, event)) {
719 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //5
720 return kFALSE;
721 }
722
723 cutIndex++; //6
724 if(!CorrectedTPCClusterCut(photon, event)) {
725 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //6
726 return kFALSE;
727 }
728
729 Double_t magField = event->GetMagneticField();
730 if( magField < 0.0 ){
731 magField = 1.0;
732 } else {
733 magField = -1.0;
734 }
735
736 AliVTrack * electronCandidate = GetTrack(event,photon->GetTrackLabelNegative() );
737 AliVTrack * positronCandidate = GetTrack(event,photon->GetTrackLabelPositive() );
738 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
739
740 cutIndex++; //7
741 if(!PsiPairCut(photon)) {
742 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //7
743 return kFALSE;
744 }
745
746 cutIndex++; //8
747 if(!CosinePAngleCut(photon, event)) {
748 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //8
749 return kFALSE;
750 }
751
752 AliAODConversionPhoton* photonAOD = dynamic_cast<AliAODConversionPhoton*>(photon);
753 if (photonAOD){
754 photonAOD->CalculateDistanceOfClossetApproachToPrimVtx(event->GetPrimaryVertex());
755
756 cutIndex++; //9
757 if(photonAOD->GetDCArToPrimVtx() > fDCARPrimVtxCut) { //DCA R cut of photon to primary vertex
758 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //9
759 return kFALSE;
760 }
761
762 cutIndex++; //10
763 if(abs(photonAOD->GetDCAzToPrimVtx()) > fDCAZPrimVtxCut) { //DCA Z cut of photon to primary vertex
764 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //10
765 return kFALSE;
766 }
767 } else {
768 cutIndex++; //9
769 cutIndex++; //10
770 }
771 cutIndex++; //11
772
773 if (photonAOD){
774 UChar_t photonQuality = 0;
775 AliAODEvent * aodEvent = dynamic_cast<AliAODEvent*>(event);
776 if(aodEvent) {
777 photonQuality = DeterminePhotonQualityAOD(photonAOD, event);
778 } else {
779 photonQuality = photonAOD->GetPhotonQuality();
780 }
781 if (fDoPhotonQualitySelectionCut && photonQuality != fPhotonQualityCut){
782 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //11
783 return kFALSE;
784 }
785 }
786 cutIndex++; //12
787 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //11
788
789 // Histos after Cuts
790 if(hInvMassafter)hInvMassafter->Fill(photon->GetMass());
791 if(hArmenterosafter)hArmenterosafter->Fill(photon->GetArmenterosAlpha(),photon->GetArmenterosQt());
792 if(hPsiPairDeltaPhiafter)hPsiPairDeltaPhiafter->Fill(deltaPhi,photon->GetPsiPair());
793 return kTRUE;
794
795}
796
797///________________________________________________________________________
798Bool_t AliConversionPhotonCuts::CorrectedTPCClusterCut(AliConversionPhotonBase *photon, AliVEvent * event)
799{ //Cut on corrected TPC Cluster Info
800
801 AliVTrack * negTrack = GetTrack(event, photon->GetTrackLabelNegative());
802 AliVTrack * posTrack = GetTrack(event, photon->GetTrackLabelPositive());
803
804 if(!negTrack||!posTrack)return kFALSE;
805
806 Double_t negclsToF=0;
807
808 if (!fUseCorrectedTPCClsInfo ){
809 if(negTrack->GetTPCNclsF()!=0){
810 negclsToF = (Double_t)negTrack->GetNcls(1)/(Double_t)negTrack->GetTPCNclsF();}// Ncluster/Nfindablecluster
811 }
812 else {
813 negclsToF = negTrack->GetTPCClusterInfo(2,0,GetFirstTPCRow(photon->GetConversionRadius()));
814 }
815
816 Double_t posclsToF = 0.;
817 if (!fUseCorrectedTPCClsInfo ){
818 if(posTrack->GetTPCNclsF()!=0){
819 posclsToF = (Double_t)posTrack->GetNcls(1)/(Double_t)posTrack->GetTPCNclsF();
820 }
821 }else{
822 posclsToF = posTrack->GetTPCClusterInfo(2,0,GetFirstTPCRow(photon->GetConversionRadius()));
823 }
824
825 if( negclsToF < fMinClsTPCToF || posclsToF < fMinClsTPCToF ){
826 return kFALSE;
827 }
828
829 return kTRUE;
830}
831
832///________________________________________________________________________
833Bool_t AliConversionPhotonCuts::PhotonIsSelected(AliConversionPhotonBase *photon, AliVEvent * event)
834{
835 //Selection of Reconstructed Photons
836
837 FillPhotonCutIndex(kPhotonIn);
838
839 if(event->IsA()==AliESDEvent::Class()) {
840 if(!SelectV0Finder( ( ((AliESDEvent*)event)->GetV0(photon->GetV0Index()))->GetOnFlyStatus() ) ){
841 FillPhotonCutIndex(kOnFly);
842 return kFALSE;
843 }
844 }
845 // else if(event->IsA()==AliAODEvent::Class()) {
846 // if(!SelectV0Finder( ( ((AliAODEvent*)event)->GetV0(photon->GetV0Index())) ) ){
847 // FillPhotonCutIndex(kOnFly);
848 // return kFALSE;
849 // }
850 // }
851
852 // Get Tracks
853 AliVTrack * negTrack = GetTrack(event, photon->GetTrackLabelNegative());
854 AliVTrack * posTrack = GetTrack(event, photon->GetTrackLabelPositive());
855
856 if(!negTrack || !posTrack) {
857 FillPhotonCutIndex(kNoTracks);
858 return kFALSE;
859 }
860 photon->DeterminePhotonQuality(negTrack,posTrack);
861 // Track Cuts
862 if(!TracksAreSelected(negTrack, posTrack)){
863 FillPhotonCutIndex(kTrackCuts);
864 return kFALSE;
865 }
866 if (hEtaDistV0s)hEtaDistV0s->Fill(photon->GetPhotonEta());
867 // dEdx Cuts
868 if(!dEdxCuts(negTrack) || !dEdxCuts(posTrack)) {
869 FillPhotonCutIndex(kdEdxCuts);
870 return kFALSE;
871 }
872 if (hEtaDistV0sAfterdEdxCuts)hEtaDistV0sAfterdEdxCuts->Fill(photon->GetPhotonEta());
873 // Photon Cuts
874 if(!PhotonCuts(photon,event)){
875 FillPhotonCutIndex(kPhotonCuts);
876 return kFALSE;
877 }
878
879 // Photon passed cuts
880 FillPhotonCutIndex(kPhotonOut);
881 return kTRUE;
882}
883
884///________________________________________________________________________
885Bool_t AliConversionPhotonCuts::ArmenterosQtCut(AliConversionPhotonBase *photon)
886{ // Armenteros Qt Cut
887 if(fDo2DQt){
888 if ( !(TMath::Power(photon->GetArmenterosAlpha()/0.95,2)+TMath::Power(photon->GetArmenterosQt()/fQtMax,2) < 1) ){
889 return kFALSE;
890 }
891 } else {
892 if(photon->GetArmenterosQt()>fQtMax){
893 return kFALSE;
894 }
895 }
896 return kTRUE;
897}
898
899
900///________________________________________________________________________
901Bool_t AliConversionPhotonCuts::AcceptanceCuts(AliConversionPhotonBase *photon) {
902 // Exclude certain areas for photon reconstruction
903
904 Int_t cutIndex=0;
905 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
906 cutIndex++;
907
908 if(photon->GetConversionRadius()>fMaxR){ // cuts on distance from collision point
909 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
910 return kFALSE;
911 }
912 cutIndex++;
913
914 if(photon->GetConversionRadius()<fMinR){ // cuts on distance from collision point
915 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
916 return kFALSE;
917 }
918 cutIndex++;
919
920 if(photon->GetConversionRadius() <= ((abs(photon->GetConversionZ())*fLineCutZRSlope)-fLineCutZValue)){
921 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
922 return kFALSE;
923 }
924 else if (fUseEtaMinCut && photon->GetConversionRadius() >= ((abs(photon->GetConversionZ())*fLineCutZRSlopeMin)-fLineCutZValueMin )){
925 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
926 return kFALSE;
927 }
928 cutIndex++;
929
930 if(abs(photon->GetConversionZ()) > fMaxZ ){ // cuts out regions where we do not reconstruct
931 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
932 return kFALSE;
933 }
934 cutIndex++;
935
936
937 if( photon->GetPhotonEta() > (fEtaCut) || photon->GetPhotonEta() < (-fEtaCut) ){
938 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
939 return kFALSE;
940 }
941 if(fEtaCutMin>-0.1){
942 if( photon->GetPhotonEta() < (fEtaCutMin) && photon->GetPhotonEta() > (-fEtaCutMin) ){
943 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
944 return kFALSE;
945 }
946 }
947 cutIndex++;
948
949 if(photon->GetPhotonPt()<fPtCut){
950 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
951 return kFALSE;
952 }
953 cutIndex++;
954
955 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
956
957 return kTRUE;
958}
959
960
961///________________________________________________________________________
962Bool_t AliConversionPhotonCuts::SpecificTrackCuts(AliAODTrack * negTrack, AliAODTrack * posTrack,Int_t &cutIndex) {
963 // Track Cuts which require AOD/ESD specific implementation
964
965 if( !negTrack->IsOn(AliESDtrack::kTPCrefit) || !posTrack->IsOn(AliESDtrack::kTPCrefit) ) {
966 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
967 return kFALSE;
968 }
969 cutIndex++;
970
971 AliAODVertex * NegVtxType=negTrack->GetProdVertex();
972 AliAODVertex * PosVtxType=posTrack->GetProdVertex();
973 if( (NegVtxType->GetType())==AliAODVertex::kKink || (PosVtxType->GetType())==AliAODVertex::kKink) {
974 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
975 return kFALSE;
976 }
977 return kTRUE;
978
979}
980
981
982///________________________________________________________________________
983Bool_t AliConversionPhotonCuts::SpecificTrackCuts(AliESDtrack * negTrack, AliESDtrack * posTrack,Int_t &cutIndex) {
984 // Track Cuts which require AOD/ESD specific implementation
985
986 if( !negTrack->IsOn(AliESDtrack::kTPCrefit) || !posTrack->IsOn(AliESDtrack::kTPCrefit) ) {
987 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
988 return kFALSE;
989 }
990 cutIndex++;
991
992 if(negTrack->GetKinkIndex(0) > 0 || posTrack->GetKinkIndex(0) > 0 ) {
993 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
994 return kFALSE;
995 }
996 return kTRUE;
997}
998
999
1000
1001///________________________________________________________________________
1002Bool_t AliConversionPhotonCuts::TracksAreSelected(AliVTrack * negTrack, AliVTrack * posTrack) {
1003 // Track Selection for Photon Reconstruction
1004
1005 Int_t cutIndex=0;
1006 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1007 cutIndex++;
1008
1009 // avoid like sign
1010 if(negTrack->Charge() == posTrack->Charge()) {
1011 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1012 return kFALSE;
1013 }
1014 cutIndex++;
1015
1016 // Number of TPC Clusters
1017
1018
1019 if( negTrack->GetNcls(1) < fMinClsTPC || posTrack->GetNcls(1) < fMinClsTPC ) {
1020 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1021 return kFALSE;
1022 }
1023 cutIndex++;
1024
1025 // Acceptance
1026 if( posTrack->Eta() > (fEtaCut) || posTrack->Eta() < (-fEtaCut) ||
1027 negTrack->Eta() > (fEtaCut) || negTrack->Eta() < (-fEtaCut) ){
1028 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1029 return kFALSE;
1030 }
1031 if(fEtaCutMin>-0.1){
1032 if( (posTrack->Eta() < (fEtaCutMin) && posTrack->Eta() > (-fEtaCutMin)) ||
1033 (negTrack->Eta() < (fEtaCutMin) && negTrack->Eta() > (-fEtaCutMin)) ){
1034 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1035 return kFALSE;
1036 }
1037 }
1038 cutIndex++;
1039
1040 // Single Pt Cut
1041 if( negTrack->Pt()< fSinglePtCut || posTrack->Pt()< fSinglePtCut){
1042 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1043 return kFALSE;
1044 }
1045 cutIndex++;
1046
1047 // AOD ESD specific cuts
1048 Bool_t passCuts = kTRUE;
1049
1050 if(negTrack->IsA()==AliAODTrack::Class()) {
1051 passCuts = passCuts * SpecificTrackCuts(static_cast<AliAODTrack*>(negTrack), static_cast<AliAODTrack*>(posTrack),cutIndex);
1052 } else {
1053 passCuts = passCuts * SpecificTrackCuts(static_cast<AliESDtrack*>(negTrack), static_cast<AliESDtrack*>(posTrack),cutIndex);
1054 }
1055
1056 if(!passCuts){
1057 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1058 return kFALSE;
1059 }
1060 cutIndex++;
1061
1062 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1063
1064 return kTRUE;
1065
1066}
1067
1068///________________________________________________________________________
1069Bool_t AliConversionPhotonCuts::dEdxCuts(AliVTrack *fCurrentTrack){
1070 // Electron Identification Cuts for Photon reconstruction
1071 if(!fPIDResponse){InitPIDResponse();}// Try to reinitialize PID Response
1072 if(!fPIDResponse){AliError("No PID Response"); return kTRUE;}// if still missing fatal error
1073
1074 Int_t cutIndex=0;
1075 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1076 if(hTPCdEdxSigbefore)hTPCdEdxSigbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));
1077 if(hTPCdEdxbefore)hTPCdEdxbefore->Fill(fCurrentTrack->P(),fCurrentTrack->GetTPCsignal());
1078 cutIndex++;
1079
1080 if(fDodEdxSigmaCut == kTRUE){
1081 // TPC Electron Line
1082 if( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLine ||
1083 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaAboveElectronLine){
1084
1085 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1086 return kFALSE;
1087 }
1088 cutIndex++;
1089
1090 // TPC Pion Line
1091 if( fCurrentTrack->P()>fPIDMinPnSigmaAbovePionLine && fCurrentTrack->P()<fPIDMaxPnSigmaAbovePionLine ){
1092 if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLine &&
1093 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLine&&
1094 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLine){
1095
1096 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1097 return kFALSE;
1098 }
1099 }
1100 cutIndex++;
1101
1102 // High Pt Pion rej
1103 if( fCurrentTrack->P()>fPIDMaxPnSigmaAbovePionLine ){
1104 if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLine &&
1105 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLine &&
1106 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineHighPt){
1107
1108 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1109 return kFALSE;
1110 }
1111 }
1112 cutIndex++;
1113 }
1114 else{cutIndex+=3;}
1115
1116 if(fDoKaonRejectionLowP == kTRUE){
1117 if(fCurrentTrack->P()<fPIDMinPKaonRejectionLowP ){
1118 if( abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kKaon))<fPIDnSigmaAtLowPAroundKaonLine){
1119
1120 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1121 return kFALSE;
1122 }
1123 }
1124 }
1125 cutIndex++;
1126 if(fDoProtonRejectionLowP == kTRUE){
1127 if( fCurrentTrack->P()<fPIDMinPProtonRejectionLowP ){
1128 if( abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kProton))<fPIDnSigmaAtLowPAroundProtonLine){
1129
1130 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1131 return kFALSE;
1132 }
1133 }
1134 }
1135 cutIndex++;
1136
1137 if(fDoPionRejectionLowP == kTRUE){
1138 if( fCurrentTrack->P()<fPIDMinPPionRejectionLowP ){
1139 if( abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion))<fPIDnSigmaAtLowPAroundPionLine){
1140
1141 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1142 return kFALSE;
1143 }
1144 }
1145 }
1146 cutIndex++;
1147
1148
1149 // cout<<"Start"<<endl;
1150 // AliPIDResponse::EDetPidStatus status=fPIDResponse->CheckPIDStatus(AliPIDResponse::kTOF,fCurrentTrack);
1151
1152 // if( ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) && ( (status & AliVTrack::kTIME) == AliVTrack::kTIME ))
1153 // {cout<<"TOF DA"<<endl;}
1154 // if(status == AliPIDResponse::kDetPidOk){
1155 // Float_t probMis = fPIDResponse->GetTOFMismatchProbability(fCurrentTrack);
1156 // cout<<"--> "<<probMis<<endl;
1157 // if(probMis > 0.01){
1158
1159 // }
1160 // }
1161
1162 if((fCurrentTrack->GetStatus() & AliESDtrack::kTOFpid) && !(fCurrentTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
1163 if(hTOFbefore){
1164 Double_t t0 = fPIDResponse->GetTOFResponse().GetStartTime(fCurrentTrack->P());
1165 Double_t times[AliPID::kSPECIESC];
1166 fCurrentTrack->GetIntegratedTimes(times);
1167 Double_t TOFsignal = fCurrentTrack->GetTOFsignal();
1168 Double_t dT = TOFsignal - t0 - times[0];
1169 hTOFbefore->Fill(fCurrentTrack->P(),dT);
1170 }
1171 if(hTOFSigbefore) hTOFSigbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));
1172 if(fUseTOFpid){
1173 if(fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)>fTofPIDnSigmaAboveElectronLine ||
1174 fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)<fTofPIDnSigmaBelowElectronLine ){
1175 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1176 return kFALSE;
1177 }
1178 }
1179 if(hTOFSigafter)hTOFSigafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));
1180 }
1181 cutIndex++;
1182 // Apply TRD PID
1183 if(fDoTRDPID){
1184 if(!fPIDResponse->IdentifiedAsElectronTRD(fCurrentTrack,fPIDTRDEfficiency)){
1185 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1186 return kFALSE;
1187 }
1188 }
1189 cutIndex++;
1190
1191 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1192 if(hTPCdEdxSigafter)hTPCdEdxSigafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));
1193 if(hTPCdEdxafter)hTPCdEdxafter->Fill(fCurrentTrack->P(),fCurrentTrack->GetTPCsignal());
1194
1195 return kTRUE;
1196}
1197
1198///________________________________________________________________________
1199Bool_t AliConversionPhotonCuts::AsymmetryCut(AliConversionPhotonBase * photon,AliVEvent *event) {
1200 // Cut on Energy Assymetry
1201
1202 for(Int_t ii=0;ii<2;ii++){
1203
1204 AliVTrack *track=GetTrack(event,photon->GetTrackLabel(ii));
1205
1206 if( track->P() > fMinPPhotonAsymmetryCut ){
1207 Double_t trackNegAsy=0;
1208 if (photon->GetPhotonP()!=0.){
1209 trackNegAsy= track->P()/photon->GetPhotonP();
1210 }
1211
1212 if( trackNegAsy<fMinPhotonAsymmetry ||trackNegAsy>(1.- fMinPhotonAsymmetry)){
1213 return kFALSE;
1214 }
1215 }
1216
1217 }
1218 return kTRUE;
1219}
1220
1221///________________________________________________________________________
1222AliVTrack *AliConversionPhotonCuts::GetTrack(AliVEvent * event, Int_t label){
1223 //Returns pointer to the track with given ESD label
1224 //(Important for AOD implementation, since Track array in AOD data is different
1225 //from ESD array, but ESD tracklabels are stored in AOD Tracks)
1226
1227 AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(event);
1228 if(esdEvent) {
1229 if(label > event->GetNumberOfTracks() ) return NULL;
1230 AliESDtrack * track = esdEvent->GetTrack(label);
1231 return track;
1232
1233 } else {
1234 AliVTrack * track = 0x0;
1235 if(((AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1"))->AreAODsRelabeled()){
1236 track = dynamic_cast<AliVTrack*>(event->GetTrack(label));
1237 return track;
1238 }
1239 else{
1240 for(Int_t ii=0; ii<event->GetNumberOfTracks(); ii++) {
1241 track = dynamic_cast<AliVTrack*>(event->GetTrack(ii));
1242 if(track){
1243 if(track->GetID() == label) {
1244 return track;
1245 }
1246 }
1247 }
1248 }
1249 }
1250 //AliDebug(5,(Form("track not found %d %d",label,event->GetNumberOfTracks()));
1251 return NULL;
1252}
1253
1254///________________________________________________________________________
1255AliESDtrack *AliConversionPhotonCuts::GetESDTrack(AliESDEvent * event, Int_t label){
1256 //Returns pointer to the track with given ESD label
1257 //(Important for AOD implementation, since Track array in AOD data is different
1258 //from ESD array, but ESD tracklabels are stored in AOD Tracks)
1259
1260 if(event) {
1261 if(label > event->GetNumberOfTracks() ) return NULL;
1262 AliESDtrack * track = event->GetTrack(label);
1263 return track;
1264 }
1265 //AliDebug(5,(Form("track not found %d %d",label,event->GetNumberOfTracks()));
1266 return NULL;
1267}
1268
1269
1270
1271///________________________________________________________________________
1272Bool_t AliConversionPhotonCuts::PIDProbabilityCut(AliConversionPhotonBase *photon, AliVEvent * event){
1273 // Cut on Electron Probability for Photon Reconstruction
1274
1275 AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(event);
1276
1277 if(esdEvent){
1278
1279 Bool_t iResult=kFALSE;
1280
1281 Double_t *posProbArray = new Double_t[AliPID::kSPECIES];
1282 Double_t *negProbArray = new Double_t[AliPID::kSPECIES];
1283
1284 AliESDtrack* negTrack = esdEvent->GetTrack(photon->GetTrackLabelNegative());
1285 AliESDtrack* posTrack = esdEvent->GetTrack(photon->GetTrackLabelPositive());
1286
1287 if(negProbArray && posProbArray){
1288
1289 negTrack->GetTPCpid(negProbArray);
1290 posTrack->GetTPCpid(posProbArray);
1291
1292 if(negProbArray[AliPID::kElectron]>=fPIDProbabilityCutNegativeParticle && posProbArray[AliPID::kElectron]>=fPIDProbabilityCutPositiveParticle){
1293 iResult=kTRUE;
1294 }
1295 }
1296
1297 delete [] posProbArray;
1298 delete [] negProbArray;
1299 return iResult;
1300
1301 } else {
1302 ///Not possible for AODs
1303 return kTRUE;
1304 }
1305}
1306
1307
1308///________________________________________________________________________
1309Bool_t AliConversionPhotonCuts::AcceptanceCut(TParticle *particle, TParticle * ePos,TParticle* eNeg){
1310 // MC Acceptance Cuts
1311 //(Certain areas were excluded for photon reconstruction)
1312
1313 if(particle->R()>fMaxR){
1314 return kFALSE;}
1315
1316 if(ePos->R()>fMaxR){
1317 return kFALSE;
1318 }
1319
1320 if(ePos->R()<fMinR){
1321 return kFALSE;
1322 }
1323
1324 if( ePos->R() <= ((abs(ePos->Vz())*fLineCutZRSlope)-fLineCutZValue)){
1325 return kFALSE;
1326 }
1327 else if (fUseEtaMinCut && ePos->R() >= ((abs(ePos->Vz())*fLineCutZRSlopeMin)-fLineCutZValueMin )){
1328 return kFALSE;
1329 }
1330
1331 if(abs(eNeg->Vz()) > fMaxZ ){ // cuts out regions where we do not reconstruct
1332 return kFALSE;
1333 }
1334
1335 if(eNeg->Vz()!=ePos->Vz()||eNeg->R()!=ePos->R()){
1336 return kFALSE;
1337 }
1338
1339 if(abs(ePos->Vz()) > fMaxZ ){ // cuts out regions where we do not reconstruct
1340 return kFALSE;
1341 }
1342
1343
1344 if( particle->Eta() > (fEtaCut) || particle->Eta() < (-fEtaCut) ){
1345 return kFALSE;
1346 }
1347 if( ePos->Eta() > (fEtaCut) || ePos->Eta() < (-fEtaCut) ){
1348 return kFALSE;
1349 }
1350 if( eNeg->Eta() > (fEtaCut) || eNeg->Eta() < (-fEtaCut) ){
1351 return kFALSE;
1352 }
1353 if(fEtaCutMin>-0.1){
1354 if( particle->Eta() < (fEtaCutMin) && particle->Eta() > (-fEtaCutMin) ){
1355 return kFALSE;
1356 }
1357 if( ePos->Eta() < (fEtaCutMin) && ePos->Eta() > (-fEtaCutMin) ){
1358 return kFALSE;
1359 }
1360 if( eNeg->Eta() < (fEtaCutMin) && eNeg->Eta() > (-fEtaCutMin) ){
1361 return kFALSE;
1362 }
1363 }
1364
1365 if( ePos->Pt()< fSinglePtCut || eNeg->Pt()< fSinglePtCut){
1366 return kFALSE;
1367 }
1368
1369 if(particle->Pt()<fPtCut){
1370 return kFALSE;
1371 }
1372
1373 return kTRUE;
1374}
1375///________________________________________________________________________
1376Bool_t AliConversionPhotonCuts::UpdateCutString() {
1377 ///Update the cut string (if it has been created yet)
1378
1379 if(fCutString && fCutString->GetString().Length() == kNCuts) {
1380 fCutString->SetString(GetCutNumber());
1381 } else {
1382 return kFALSE;
1383 }
1384 return kTRUE;
1385}
1386
1387
1388///________________________________________________________________________
1389Bool_t AliConversionPhotonCuts::InitializeCutsFromCutString(const TString analysisCutSelection ) {
1390 // Initialize Cuts from a given Cut string
1391 AliInfo(Form("Set Photoncut Number: %s",analysisCutSelection.Data()));
1392 if(analysisCutSelection.Length()!=kNCuts) {
1393 AliError(Form("Cut selection has the wrong length! size is %d, number of cuts is %d", analysisCutSelection.Length(), kNCuts));
1394 return kFALSE;
1395 }
1396 if(!analysisCutSelection.IsDigit()){
1397 AliError("Cut selection contains characters");
1398 return kFALSE;
1399 }
1400
1401 const char *cutSelection = analysisCutSelection.Data();
1402 #define ASSIGNARRAY(i) fCuts[i] = cutSelection[i] - '0'
1403 for(Int_t ii=0;ii<kNCuts;ii++){
1404 ASSIGNARRAY(ii);
1405 }
1406
1407 // Set Individual Cuts
1408 for(Int_t ii=0;ii<kNCuts;ii++){
1409 if(!SetCut(cutIds(ii),fCuts[ii]))return kFALSE;
1410 }
1411
1412 PrintCutsWithValues();
1413
1414 return kTRUE;
1415}
1416///________________________________________________________________________
1417Bool_t AliConversionPhotonCuts::SetCut(cutIds cutID, const Int_t value) {
1418 ///Set individual cut ID
1419
1420 switch (cutID) {
1421
1422 case kv0FinderType:
1423 if( SetV0Finder(value)) {
1424 fCuts[kv0FinderType] = value;
1425 UpdateCutString();
1426 return kTRUE;
1427 } else return kFALSE;
1428
1429 case kededxSigmaCut:
1430 if( SetTPCdEdxCutElectronLine(value)) {
1431 fCuts[kededxSigmaCut] = value;
1432 UpdateCutString();
1433 return kTRUE;
1434 } else return kFALSE;
1435
1436 case kpidedxSigmaCut:
1437 if( SetTPCdEdxCutPionLine(value)) {
1438 fCuts[kpidedxSigmaCut] = value;
1439 UpdateCutString();
1440 return kTRUE;
1441 } else return kFALSE;
1442
1443 case kpiMomdedxSigmaCut:
1444 if( SetMinMomPiondEdxCut(value)) {
1445 fCuts[kpiMomdedxSigmaCut] = value;
1446 UpdateCutString();
1447 return kTRUE;
1448 } else return kFALSE;
1449
1450 case kchi2GammaCut:
1451 if( SetChi2GammaCut(value)) {
1452 fCuts[kchi2GammaCut] = value;
1453 UpdateCutString();
1454 return kTRUE;
1455 } else return kFALSE;
1456
1457 case ksinglePtCut:
1458 if( SetSinglePtCut(value)) {
1459 fCuts[ksinglePtCut] = value;
1460 UpdateCutString();
1461 return kTRUE;
1462 } else return kFALSE;
1463
1464 case kclsTPCCut:
1465 if( SetTPCClusterCut(value)) {
1466 fCuts[kclsTPCCut] = value;
1467 UpdateCutString();
1468 return kTRUE;
1469 } else return kFALSE;
1470
1471 case ketaCut:
1472 if( SetEtaCut(value)) {
1473 fCuts[ketaCut] = value;
1474 UpdateCutString();
1475 return kTRUE;
1476 } else return kFALSE;
1477
1478 case kLowPRejectionSigmaCut:
1479 if( SetLowPRejectionCuts(value)) {
1480 fCuts[kLowPRejectionSigmaCut] = value;
1481 UpdateCutString();
1482 return kTRUE;
1483 } else return kFALSE;
1484
1485 case kQtMaxCut:
1486 if( SetQtMaxCut(value)) {
1487 fCuts[kQtMaxCut] = value;
1488 UpdateCutString();
1489 return kTRUE;
1490 } else return kFALSE;
1491
1492 case kpiMaxMomdedxSigmaCut:
1493 if( SetMaxMomPiondEdxCut(value)) {
1494 fCuts[kpiMaxMomdedxSigmaCut] = value;
1495 UpdateCutString();
1496 return kTRUE;
1497 } else return kFALSE;
1498
1499 case kRCut:
1500 if( SetRCut(value)) {
1501 fCuts[kRCut] = value;
1502 UpdateCutString();
1503 return kTRUE;
1504 } else return kFALSE;
1505
1506 case kTOFelectronPID:
1507 if( SetTOFElectronPIDCut(value)) {
1508 fCuts[kTOFelectronPID] = value;
1509 UpdateCutString();
1510 return kTRUE;
1511 } else return kFALSE;
1512
1513 case kdoPhotonAsymmetryCut:
1514 if( SetPhotonAsymmetryCut(value)) {
1515 fCuts[kdoPhotonAsymmetryCut] = value;
1516 UpdateCutString();
1517 return kTRUE;
1518 } else return kFALSE;
1519
1520 case kPsiPair:
1521 if( SetPsiPairCut(value)) {
1522 fCuts[kPsiPair] = value;
1523 UpdateCutString();
1524 return kTRUE;
1525 } else return kFALSE;
1526
1527 case kCosPAngle:
1528 if( SetCosPAngleCut(value)) {
1529 fCuts[kCosPAngle] = value;
1530 UpdateCutString();
1531 return kTRUE;
1532 } else return kFALSE;
1533
1534
1535 case kElecShare:
1536 if( SetSharedElectronCut(value)) {
1537 fCuts[kElecShare] = value;
1538 UpdateCutString();
1539 return kTRUE;
1540 } else return kFALSE;
1541
1542 case kToCloseV0s:
1543 if( SetToCloseV0sCut(value)) {
1544 fCuts[kToCloseV0s] = value;
1545 UpdateCutString();
1546 return kTRUE;
1547 } else return kFALSE;
1548
1549 case kDcaRPrimVtx:
1550 if( SetDCARPhotonPrimVtxCut(value)) {
1551 fCuts[kDcaRPrimVtx] = value;
1552 UpdateCutString();
1553 return kTRUE;
1554 } else return kFALSE;
1555
1556 case kDcaZPrimVtx:
1557 if( SetDCAZPhotonPrimVtxCut(value)) {
1558 fCuts[kDcaZPrimVtx] = value;
1559 UpdateCutString();
1560 return kTRUE;
1561 } else return kFALSE;
1562
1563 case kInPlaneOutOfPlane:
1564 if( SetInPlaneOutOfPlane(value)) {
1565 fCuts[kInPlaneOutOfPlane] = value;
1566 UpdateCutString();
1567 return kTRUE;
1568 } else return kFALSE;
1569
1570
1571
1572
1573 case kNCuts:
1574 AliError("Cut id out of range");
1575 return kFALSE;
1576 }
1577
1578 AliError("Cut id %d not recognized");
1579 return kFALSE;
1580
1581
1582}
1583///________________________________________________________________________
1584void AliConversionPhotonCuts::PrintCuts() {
1585 // Print out current Cut Selection
1586 for(Int_t ic = 0; ic < kNCuts; ic++) {
1587 printf("%-30s : %d \n", fgkCutNames[ic], fCuts[ic]);
1588 }
1589}
1590
1591void AliConversionPhotonCuts::PrintCutsWithValues() {
1592 // Print out current Cut Selection with value
1593 printf("\nConversion cutnumber \n");
1594 for(Int_t ic = 0; ic < kNCuts; ic++) {
1595 printf("%d",fCuts[ic]);
1596 }
1597 printf("\n\n");
1598 printf("Electron cuts & Secondary Track Cuts - only track from secondaries enter analysis: \n");
1599 printf("\t no like sign pairs from V0s \n");
1600 if (!fUseCorrectedTPCClsInfo) printf("\t # TPC clusters > %3.2f \n", fMinClsTPC);
1601 if (fEtaCutMin > -0.1) printf("\t %3.2f < eta_{e} < %3.2f\n", fEtaCutMin, fEtaCut );
1602 else printf("\t eta_{e} < %3.2f\n", fEtaCut );
1603 printf("\t p_{T,e} > %3.2f\n", fSinglePtCut );
1604 printf("\t TPC refit \n");
1605 printf("\t no kinks \n");
1606 printf("\t accept: %3.2f < n sigma_{e,TPC} < %3.2f\n", fPIDnSigmaBelowElectronLine, fPIDnSigmaAboveElectronLine );
1607 printf("\t reject: %3.2f < p_{e,T} < %3.2f, n sigma_{pi,TPC} < %3.2f\n", fPIDMinPnSigmaAbovePionLine, fPIDMaxPnSigmaAbovePionLine, fPIDnSigmaAbovePionLine );
1608 printf("\t reject: p_{e,T} > %3.2f, n sigma_{pi,TPC} < %3.2f\n", fPIDMaxPnSigmaAbovePionLine, fPIDnSigmaAbovePionLineHighPt );
1609 if (fDoPionRejectionLowP) printf("\t reject: p_{e,T} < %3.2f, -%3.2f < n sigma_{pi,TPC} < %3.2f\n", fPIDMinPPionRejectionLowP, fPIDnSigmaAtLowPAroundPionLine, fPIDnSigmaAtLowPAroundPionLine );
1610 if (fDoKaonRejectionLowP) printf("\t reject: -%3.2f < n sigma_{K,TPC} < %3.2f\n", fPIDnSigmaAtLowPAroundKaonLine, fPIDnSigmaAtLowPAroundKaonLine );
1611 if (fDoProtonRejectionLowP) printf("\t reject: -%3.2f < n sigma_{K,TPC} < %3.2f\n", fPIDnSigmaAtLowPAroundProtonLine, fPIDnSigmaAtLowPAroundProtonLine );
1612 if (fUseTOFpid) printf("\t accept: %3.2f < n sigma_{e,TOF} < %3.2f\n", fTofPIDnSigmaBelowElectronLine, fTofPIDnSigmaAboveElectronLine);
1613
1614 printf("Photon cuts: \n");
1615 if (fUseOnFlyV0Finder) printf("\t using Onfly V0 finder \n");
1616 else printf("\t using Offline V0 finder \n");
1617 if (fDo2DQt){
1618 printf("\t 2 dimensional q_{T} cut applied with maximum of %3.2f \n", fQtMax );
1619 } else {
1620 printf("\t 1 dimensional q_{T} cut applied with maximum of %3.2f \n", fQtMax );
1621 }
1622 if (fDo2DPsiPairChi2){
1623 printf("\t 2 dimensional triangle chi^{2} and psi_{pair} cut applied with maximum of chi^{2} = %3.2f and |psi_{pair}| = %3.2f \n", fChi2CutConversion, fPsiPairCut );
1624 } else {
1625 printf("\t chi^{2} max cut chi^{2} < %3.2f \n", fChi2CutConversion );
1626 printf("\t psi_{pair} max cut |psi_{pair}| < %3.2f \n", fPsiPairCut );
1627 }
1628 printf("\t %3.2f < R_{conv} < %3.2f\n", fMinR, fMaxR );
1629 printf("\t Z_{conv} < %3.2f\n", fMaxZ );
1630 if (fEtaCutMin > -0.1) printf("\t %3.2f < eta_{conv} < %3.2f\n", fEtaCutMin, fEtaCut );
1631 else printf("\t eta_{conv} < %3.2f\n", fEtaCut );
1632 if (fDoPhotonAsymmetryCut) printf("\t for p_{T,track} > %3.2f, A_{gamma} < %3.2f \n", fMinPPhotonAsymmetryCut, fMinPhotonAsymmetry );
1633 if (fUseCorrectedTPCClsInfo) printf("\t #cluster TPC/ #findable clusters TPC (corrected for radius) > %3.2f\n", fMinClsTPCToF );
1634 printf("\t p_{T,gamma} > %3.2f\n", fPtCut );
1635 printf("\t cos(Theta_{point}) > %3.2f \n", fCosPAngleCut );
1636 printf("\t dca_{R} < %3.2f \n", fDCARPrimVtxCut );
1637 printf("\t dca_{Z} < %3.2f \n", fDCAZPrimVtxCut );
1638 if (fDoPhotonQualitySelectionCut) printf("\t selection based on photon quality with quality %d \n", fPhotonQualityCut );
1639}
1640
1641///________________________________________________________________________
1642Bool_t AliConversionPhotonCuts::SetV0Finder(Int_t v0FinderType)
1643{ // Set Cut
1644 switch (v0FinderType){
1645 case 0: // on fly V0 finder
1646 cout << "have chosen onfly V0" << endl;
1647 fUseOnFlyV0Finder=kTRUE;
1648 break;
1649 case 1: // offline V0 finder
1650 cout << "have chosen offline V0" << endl;
1651 fUseOnFlyV0Finder=kFALSE;
1652 break;
1653 default:
1654 AliError(Form(" v0FinderType not defined %d",v0FinderType));
1655 return kFALSE;
1656 }
1657 return kTRUE;
1658}
1659
1660///________________________________________________________________________
1661Bool_t AliConversionPhotonCuts::SetEtaCut(Int_t etaCut)
1662{ // Set Cut
1663
1664 //Set Standard LineCutZValues
1665 fLineCutZValueMin = -2;
1666 fLineCutZValue = 7.;
1667
1668 switch(etaCut){
1669 case 0: // 0.9
1670 fEtaCut = 0.9;
1671 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1672 fEtaCutMin = -0.1;
1673 fLineCutZRSlopeMin = 0.;
1674 break;
1675 case 1: // 0.6 // changed from 1.2 to 0.6 on 2013.06.10
1676 fEtaCut = 0.6;
1677 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1678 fEtaCutMin = -0.1;
1679 fLineCutZRSlopeMin = 0.;
1680 break;
1681 case 2: // 1.4
1682 fEtaCut = 1.4;
1683 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1684 fEtaCutMin = -0.1;
1685 fLineCutZRSlopeMin = 0.;
1686 break;
1687 case 3: // 0.65
1688 fEtaCut = 0.65;
1689 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1690 fEtaCutMin = -0.1;
1691 fLineCutZRSlopeMin = 0.;
1692 break;
1693 case 4: // 0.75
1694 fEtaCut = 0.75;
1695 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1696 fEtaCutMin = -0.1;
1697 fLineCutZRSlopeMin = 0.;
1698 break;
1699 case 5: // 0.5
1700 fEtaCut = 0.5;
1701 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1702 fEtaCutMin = -0.1;
1703 fLineCutZRSlopeMin = 0.;
1704 break;
1705 case 6: // 5.
1706 fEtaCut = 5.;
1707 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1708 fEtaCutMin = -0.1;
1709 fLineCutZRSlopeMin = 0.;
1710 break;
1711 case 7:
1712 if (fIsHeavyIon==1){
1713 fEtaCut = 0.7;
1714 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1715 fEtaCutMin = -0.1;
1716 fLineCutZRSlopeMin = 0.;
1717 break;
1718 } else {
1719 fEtaCut = 0.3;
1720 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1721 fEtaCutMin = -0.1;
1722 fLineCutZRSlopeMin = 0.;
1723 break;
1724 }
1725 // case 8: // 0.1 - 0.8
1726 // fEtaCut = 0.9;
1727 // fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1728 // fEtaCutMin = 0.1;
1729 // fLineCutZRSlopeMin = tan(2*atan(exp(-fEtaCutMin)));
1730 // break;
1731 case 8: // 0.4
1732 fEtaCut = 0.4;
1733 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1734 fEtaCutMin = -0.1;
1735 fLineCutZRSlopeMin = 0.;
1736 break;
1737 case 9: // 10
1738 fEtaCut = 10;
1739 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1740 fEtaCutMin = -0.1;
1741 fLineCutZRSlopeMin = 0.;
1742 break;
1743 default:
1744 AliError(Form(" EtaCut not defined %d",etaCut));
1745 return kFALSE;
1746 }
1747 return kTRUE;
1748}
1749
1750///________________________________________________________________________
1751Bool_t AliConversionPhotonCuts::SetRCut(Int_t RCut){
1752 // Set Cut
1753 switch(RCut){
1754 case 0:
1755 fMinR=0;
1756 fMaxR = 180.;
1757 break;
1758 case 1:
1759 fMinR=2.8;
1760 fMaxR = 180.;
1761 break;
1762 case 2:
1763 fMinR=5.;
1764 fMaxR = 180.;
1765 break;
1766 case 3:
1767 fMaxR = 70.;
1768 fMinR = 10.;
1769 break;
1770 case 4:
1771 fMaxR = 70.;
1772 fMinR = 5.;
1773 break;
1774 case 5:
1775 fMaxR = 180.;
1776 fMinR = 10.;
1777 break;
1778 case 6:
1779 fMaxR = 180.;
1780 fMinR = 20.;
1781 break;
1782 case 7:
1783 fMaxR = 180.;
1784 fMinR = 35.; //old 26.
1785 break;
1786 case 8:
1787 fMaxR = 180.;
1788 fMinR = 12.5;
1789 break;
1790 case 9:
1791 fMaxR = 180.;
1792 fMinR = 7.5;
1793 break;
1794
1795 default:
1796 AliError("RCut not defined");
1797 return kFALSE;
1798 }
1799 return kTRUE;
1800}
1801
1802///________________________________________________________________________
1803Bool_t AliConversionPhotonCuts::SetSinglePtCut(Int_t singlePtCut)
1804{ // Set Cut
1805 switch(singlePtCut){
1806 case 0: // 0.050 GeV
1807 fSinglePtCut = 0.050;
1808 break;
1809 case 1: // 0.100 GeV
1810 fSinglePtCut = 0.100;
1811 break;
1812 case 2: // 0.150 GeV
1813 fSinglePtCut = 0.150;
1814 break;
1815 case 3: // 0.200 GeV
1816 fSinglePtCut = 0.200;
1817 break;
1818 case 4: // 0.075 GeV
1819 fSinglePtCut = 0.075;
1820 break;
1821 case 5: // 0.125 GeV
1822 fSinglePtCut = 0.125;
1823 break;
1824 case 6: // 0.04 GeV
1825 fSinglePtCut = 0.040;
1826 break;
1827 case 7: // 0.0 GeV
1828 fSinglePtCut = 0.0;
1829 break;
1830 default:
1831 AliError(Form("singlePtCut not defined %d",singlePtCut));
1832 return kFALSE;
1833 }
1834 return kTRUE;
1835}
1836
1837///________________________________________________________________________
1838Bool_t AliConversionPhotonCuts::SetTPCClusterCut(Int_t clsTPCCut)
1839{ // Set Cut
1840 switch(clsTPCCut){
1841 case 0: // 0
1842 fMinClsTPC= 0.;
1843 break;
1844 case 1: // 60
1845 fMinClsTPC= 60.;
1846 break;
1847 case 2: // 80
1848 fMinClsTPC= 80.;
1849 break;
1850 case 3: // 100
1851 fMinClsTPC= 100.;
1852 break;
1853 case 4: // 95% of findable clusters
1854 fMinClsTPCToF= 0.95;
1855 fUseCorrectedTPCClsInfo=1;
1856 break;
1857 case 5: // 0% of findable clusters
1858 fMinClsTPCToF= 0.0;
1859 fUseCorrectedTPCClsInfo=1;
1860 break;
1861 case 6: // 70% of findable clusters
1862 fMinClsTPCToF= 0.7;
1863 fUseCorrectedTPCClsInfo=1;
1864 break;
1865 case 7: // 0% of findable clusters
1866 fMinClsTPCToF= 0.35;
1867 fUseCorrectedTPCClsInfo=0;
1868 break;
1869 case 8:
1870 fMinClsTPCToF= 0.35;
1871 fUseCorrectedTPCClsInfo=1;
1872 break;
1873 case 9:
1874 fMinClsTPCToF= 0.6;
1875 fUseCorrectedTPCClsInfo=1;
1876 break;
1877 default:
1878 AliError(Form("Warning: clsTPCCut not defined %d",clsTPCCut));
1879 return kFALSE;
1880 }
1881 return kTRUE;
1882}
1883
1884///________________________________________________________________________
1885Bool_t AliConversionPhotonCuts::SetTPCdEdxCutElectronLine(Int_t ededxSigmaCut)
1886{ // Set Cut
1887 switch(ededxSigmaCut){
1888 case 0: // -10,10
1889 fPIDnSigmaBelowElectronLine=-10;
1890 fPIDnSigmaAboveElectronLine=10;
1891 break;
1892 case 1: // -5,5
1893 fPIDnSigmaBelowElectronLine=-5;
1894 fPIDnSigmaAboveElectronLine=5;
1895 break;
1896 case 2: // -3,5
1897 fPIDnSigmaBelowElectronLine=-3;
1898 fPIDnSigmaAboveElectronLine=5;
1899 break;
1900 case 3: // -4,5
1901 fPIDnSigmaBelowElectronLine=-4;
1902 fPIDnSigmaAboveElectronLine=5;
1903 break;
1904 case 4: // -6,7
1905 fPIDnSigmaBelowElectronLine=-6;
1906 fPIDnSigmaAboveElectronLine=7;
1907 break;
1908 case 5: // -4,4
1909 fPIDnSigmaBelowElectronLine=-4;
1910 fPIDnSigmaAboveElectronLine=4;
1911 break;
1912 case 6: // -2.5,4
1913 fPIDnSigmaBelowElectronLine=-2.5;
1914 fPIDnSigmaAboveElectronLine=4;
1915 break;
1916 case 7: // -2,3.5
1917 fPIDnSigmaBelowElectronLine=-2;
1918 fPIDnSigmaAboveElectronLine=3.5;
1919 break;
1920 default:
1921 AliError("TPCdEdxCutElectronLine not defined");
1922 return kFALSE;
1923
1924 }
1925 return kTRUE;
1926}
1927
1928///________________________________________________________________________
1929Bool_t AliConversionPhotonCuts::SetTPCdEdxCutPionLine(Int_t pidedxSigmaCut)
1930{ // Set Cut
1931
1932 switch(pidedxSigmaCut){
1933 case 0: // -10
1934 fPIDnSigmaAbovePionLine=-10;
1935 fPIDnSigmaAbovePionLineHighPt=-10;
1936 break;
1937 case 1: // 0
1938 fPIDnSigmaAbovePionLine=0;
1939 fPIDnSigmaAbovePionLineHighPt=-10;
1940 break;
1941 case 2: // 1
1942 fPIDnSigmaAbovePionLine=1;
1943 fPIDnSigmaAbovePionLineHighPt=-10;
1944 break;
1945 case 3: // 1
1946 fPIDnSigmaAbovePionLine=2.5;
1947 fPIDnSigmaAbovePionLineHighPt=-10;
1948 break;
1949 case 4: // 1
1950 fPIDnSigmaAbovePionLine=0.5;
1951 fPIDnSigmaAbovePionLineHighPt=-10;
1952 break;
1953 case 5: // 1
1954 fPIDnSigmaAbovePionLine=2.;
1955 fPIDnSigmaAbovePionLineHighPt=-10;
1956 break;
1957 case 6: // 1
1958 fPIDnSigmaAbovePionLine=2.;
1959 fPIDnSigmaAbovePionLineHighPt=0.5;
1960 break;
1961 case 7: // 1
1962 fPIDnSigmaAbovePionLine=3.5;
1963 fPIDnSigmaAbovePionLineHighPt=-10;
1964 break;
1965 case 8: // 1
1966 fPIDnSigmaAbovePionLine=2.;
1967 fPIDnSigmaAbovePionLineHighPt=1.;
1968 break;
1969 case 9:
1970 fPIDnSigmaAbovePionLine=3.0; // We need a bit less tight cut on dE/dx
1971 fPIDnSigmaAbovePionLineHighPt=-10;
1972 break;
1973 default:
1974 AliError(Form("Warning: pidedxSigmaCut not defined %d",pidedxSigmaCut));
1975 return kFALSE;
1976 }
1977 return kTRUE;
1978}
1979
1980///________________________________________________________________________
1981Bool_t AliConversionPhotonCuts::SetMinMomPiondEdxCut(Int_t piMomdedxSigmaCut)
1982{ // Set Cut
1983 switch(piMomdedxSigmaCut){
1984 case 0: // 0.5 GeV
1985 fPIDMinPnSigmaAbovePionLine=0.5;
1986 break;
1987 case 1: // 1. GeV
1988 fPIDMinPnSigmaAbovePionLine=1.;
1989 break;
1990 case 2: // 1.5 GeV
1991 fPIDMinPnSigmaAbovePionLine=1.5;
1992 break;
1993 case 3: // 20.0 GeV
1994 fPIDMinPnSigmaAbovePionLine=20.;
1995 break;
1996 case 4: // 50.0 GeV
1997 fPIDMinPnSigmaAbovePionLine=50.;
1998 break;
1999 case 5: // 0.3 GeV
2000 fPIDMinPnSigmaAbovePionLine=0.3;
2001 break;
2002 case 6: // 0.25 GeV
2003 fPIDMinPnSigmaAbovePionLine=0.25;
2004 break;
2005 case 7: // 0.4 GeV
2006 fPIDMinPnSigmaAbovePionLine=0.4;
2007 break;
2008 case 8: // 0.2 GeV
2009 fPIDMinPnSigmaAbovePionLine=0.2;
2010 break;
2011 default:
2012 AliError(Form("piMomdedxSigmaCut not defined %d",piMomdedxSigmaCut));
2013 return kFALSE;
2014 }
2015 return kTRUE;
2016}
2017
2018///________________________________________________________________________
2019Bool_t AliConversionPhotonCuts::SetMaxMomPiondEdxCut(Int_t piMaxMomdedxSigmaCut)
2020{ // Set Cut
2021 switch(piMaxMomdedxSigmaCut){
2022 case 0: // 100. GeV
2023 fPIDMaxPnSigmaAbovePionLine=100.;
2024 break;
2025 case 1: // 5. GeV
2026 fPIDMaxPnSigmaAbovePionLine=5.;
2027 break;
2028 case 2: // 4. GeV
2029 fPIDMaxPnSigmaAbovePionLine=4.;
2030 break;
2031 case 3: // 3.5 GeV
2032 fPIDMaxPnSigmaAbovePionLine=3.5;
2033 break;
2034 case 4: // 3. GeV
2035 fPIDMaxPnSigmaAbovePionLine=3.;
2036 break;
2037 case 5: // 7. GeV
2038 fPIDMaxPnSigmaAbovePionLine=7.;
2039 break;
2040 default:
2041 AliError(Form("piMaxMomdedxSigmaCut not defined %d",piMaxMomdedxSigmaCut));
2042 return kFALSE;
2043 }
2044 return kTRUE;
2045}
2046
2047///________________________________________________________________________
2048Bool_t AliConversionPhotonCuts::SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut)
2049{ // Set Cut
2050 switch(LowPRejectionSigmaCut){
2051 case 0: //
2052 fPIDnSigmaAtLowPAroundKaonLine=0;
2053 fPIDnSigmaAtLowPAroundProtonLine=0;
2054 fPIDnSigmaAtLowPAroundPionLine=0;
2055 fDoKaonRejectionLowP = kFALSE;
2056 fDoProtonRejectionLowP = kFALSE;
2057 fDoPionRejectionLowP = kFALSE;
2058 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2059 break;
2060 case 1: //
2061 fPIDnSigmaAtLowPAroundKaonLine=0.5;
2062 fPIDnSigmaAtLowPAroundProtonLine=0.5;
2063 fPIDnSigmaAtLowPAroundPionLine=0.5;
2064 fDoKaonRejectionLowP = kTRUE;
2065 fDoProtonRejectionLowP = kTRUE;
2066 fDoPionRejectionLowP = kTRUE;
2067 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2068 break;
2069 case 2: //
2070 fPIDnSigmaAtLowPAroundKaonLine=1;
2071 fPIDnSigmaAtLowPAroundProtonLine=1;
2072 fPIDnSigmaAtLowPAroundPionLine=1;
2073 fDoKaonRejectionLowP = kTRUE;
2074 fDoProtonRejectionLowP = kTRUE;
2075 fDoPionRejectionLowP = kTRUE;
2076 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2077 break;
2078 case 3: //
2079 fPIDnSigmaAtLowPAroundKaonLine=2.;
2080 fPIDnSigmaAtLowPAroundProtonLine=2.;
2081 fPIDnSigmaAtLowPAroundPionLine=2.;
2082 fDoKaonRejectionLowP = kTRUE;
2083 fDoProtonRejectionLowP = kTRUE;
2084 fDoPionRejectionLowP = kTRUE;
2085 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2086 break;
2087 case 4: //
2088 fPIDnSigmaAtLowPAroundKaonLine=0.;
2089 fPIDnSigmaAtLowPAroundProtonLine=0.;
2090 fPIDnSigmaAtLowPAroundPionLine=1;
2091 fDoKaonRejectionLowP = kFALSE;
2092 fDoProtonRejectionLowP = kFALSE;
2093 fDoPionRejectionLowP = kTRUE;
2094 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2095 break;
2096 case 5: //
2097 fPIDnSigmaAtLowPAroundKaonLine=0.;
2098 fPIDnSigmaAtLowPAroundProtonLine=0.;
2099 fPIDnSigmaAtLowPAroundPionLine=1.5;
2100 fDoKaonRejectionLowP = kFALSE;
2101 fDoProtonRejectionLowP = kFALSE;
2102 fDoPionRejectionLowP = kTRUE;
2103 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2104 break;
2105 case 6: //
2106 fPIDnSigmaAtLowPAroundKaonLine=0.;
2107 fPIDnSigmaAtLowPAroundProtonLine=0.;
2108 fPIDnSigmaAtLowPAroundPionLine=2.;
2109 fDoKaonRejectionLowP = kFALSE;
2110 fDoProtonRejectionLowP = kFALSE;
2111 fDoPionRejectionLowP = kTRUE;
2112 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2113 break;
2114 case 7: //
2115 fPIDnSigmaAtLowPAroundKaonLine=0.;
2116 fPIDnSigmaAtLowPAroundProtonLine=0.;
2117 fPIDnSigmaAtLowPAroundPionLine=0.5;
2118 fDoKaonRejectionLowP = kFALSE;
2119 fDoProtonRejectionLowP = kFALSE;
2120 fDoPionRejectionLowP = kTRUE;
2121 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2122 break;
2123 default:
2124 AliError(Form("LowPRejectionSigmaCut not defined %d",LowPRejectionSigmaCut));
2125 return kFALSE;
2126 }
2127 return kTRUE;
2128}
2129
2130///________________________________________________________________________
2131Bool_t AliConversionPhotonCuts::SetTOFElectronPIDCut(Int_t TOFelectronPID){
2132 // Set Cut
2133 switch(TOFelectronPID){
2134 case 0: // no cut
2135 fUseTOFpid = kFALSE;
2136 fTofPIDnSigmaBelowElectronLine=-100;
2137 fTofPIDnSigmaAboveElectronLine=100;
2138 break;
2139 case 1: // -7,7
2140 fUseTOFpid = kTRUE;
2141 fTofPIDnSigmaBelowElectronLine=-7;
2142 fTofPIDnSigmaAboveElectronLine=7;
2143 break;
2144 case 2: // -5,5
2145 fUseTOFpid = kTRUE;
2146 fTofPIDnSigmaBelowElectronLine=-5;
2147 fTofPIDnSigmaAboveElectronLine=5;
2148 break;
2149 case 3: // -3,5
2150 fUseTOFpid = kTRUE;
2151 fTofPIDnSigmaBelowElectronLine=-3;
2152 fTofPIDnSigmaAboveElectronLine=5;
2153 break;
2154 case 4: // -2,3
2155 fUseTOFpid = kTRUE;
2156 fTofPIDnSigmaBelowElectronLine=-2;
2157 fTofPIDnSigmaAboveElectronLine=3;
2158 break;
2159 case 5: // -3,3
2160 fUseTOFpid = kTRUE;
2161 fTofPIDnSigmaBelowElectronLine=-3;
2162 fTofPIDnSigmaAboveElectronLine=3;
2163 break;
2164 default:
2165 AliError(Form("TOFElectronCut not defined %d",TOFelectronPID));
2166 return kFALSE;
2167 }
2168 return kTRUE;
2169}
2170
2171///________________________________________________________________________
2172Bool_t AliConversionPhotonCuts::SetQtMaxCut(Int_t QtMaxCut)
2173{ // Set Cut
2174 switch(QtMaxCut){
2175 case 0: //
2176 fQtMax=1.;
2177 fDoQtGammaSelection=kFALSE;
2178 fDo2DQt=kFALSE;
2179 break;
2180 case 1:
2181 fQtMax=0.1;
2182 fDo2DQt=kFALSE;
2183 break;
2184 case 2:
2185 fQtMax=0.07;
2186 fDo2DQt=kFALSE;
2187 break;
2188 case 3:
2189 fQtMax=0.05;
2190 fDo2DQt=kFALSE;
2191 break;
2192 case 4:
2193 fQtMax=0.03;
2194 fDo2DQt=kFALSE;
2195 break;
2196 case 5:
2197 fQtMax=0.02;
2198 fDo2DQt=kFALSE;
2199 break;
2200 case 6:
2201 fQtMax=0.02;
2202 fDo2DQt=kTRUE;
2203 break;
2204 case 7:
2205 fQtMax=0.15;
2206 fDo2DQt=kFALSE;
2207 break;
2208 case 8:
2209 fQtMax=0.05;
2210 fDo2DQt=kTRUE;
2211 break;
2212 case 9:
2213 fQtMax=0.03;
2214 fDo2DQt=kTRUE;
2215 break;
2216 default:
2217 AliError(Form("Warning: QtMaxCut not defined %d",QtMaxCut));
2218 return kFALSE;
2219 }
2220 return kTRUE;
2221}
2222
2223///________________________________________________________________________
2224Bool_t AliConversionPhotonCuts::SetChi2GammaCut(Int_t chi2GammaCut)
2225{ // Set Cut
2226
2227 switch(chi2GammaCut){
2228 case 0: // 100
2229 fChi2CutConversion = 100.;
2230 break;
2231 case 1: // 50
2232 fChi2CutConversion = 50.;
2233 break;
2234 case 2: // 30
2235 fChi2CutConversion = 30.;
2236 break;
2237 case 3:
2238 fChi2CutConversion = 200.;
2239 break;
2240 case 4:
2241 fChi2CutConversion = 500.;
2242 break;
2243 case 5:
2244 fChi2CutConversion = 100000.;
2245 break;
2246 case 6:
2247 fChi2CutConversion = 5.;
2248 break;
2249 case 7:
2250 fChi2CutConversion = 10.;
2251 break;
2252 case 8:
2253 fChi2CutConversion = 20.;
2254 break;
2255 case 9:
2256 fChi2CutConversion = 15.;
2257 break;
2258 default:
2259 AliError(Form("Warning: Chi2GammaCut not defined %d",chi2GammaCut));
2260 return kFALSE;
2261 }
2262 return kTRUE;
2263}
2264
2265///________________________________________________________________________
2266Bool_t AliConversionPhotonCuts::SetPsiPairCut(Int_t psiCut) {
2267
2268 switch(psiCut) {
2269 case 0:
2270 fPsiPairCut = 10000; //
2271 break;
2272 case 1:
2273 fPsiPairCut = 0.1; //
2274 break;
2275 case 2:
2276 fPsiPairCut = 0.05; // Standard
2277 break;
2278 case 3:
2279 fPsiPairCut = 0.035; //
2280 break;
2281 case 4:
2282 fPsiPairCut = 0.2; //
2283 break;
2284 case 5:
2285 fPsiPairCut = 0.1; //
2286 fDo2DPsiPairChi2 = kTRUE;
2287 break;
2288 case 6:
2289 fPsiPairCut = 0.05; //
2290 fDo2DPsiPairChi2 = kTRUE;
2291 break;
2292 case 7:
2293 fPsiPairCut = 0.035; //
2294 fDo2DPsiPairChi2 = kTRUE;
2295 break;
2296 case 8:
2297 fPsiPairCut = 0.2; //
2298 fDo2DPsiPairChi2 = kTRUE; //
2299 break;
2300 case 9:
2301 fPsiPairCut = 0.5; //
2302 break;
2303 default:
2304 AliError(Form("PsiPairCut not defined %d",psiCut));
2305 return kFALSE;
2306 }
2307
2308 return kTRUE;
2309}
2310
2311///________________________________________________________________________
2312Bool_t AliConversionPhotonCuts::SetPhotonAsymmetryCut(Int_t doPhotonAsymmetryCut){
2313 // Set Cut
2314 switch(doPhotonAsymmetryCut){
2315 case 0:
2316 fDoPhotonAsymmetryCut=0;
2317 fMinPPhotonAsymmetryCut=100.;
2318 fMinPhotonAsymmetry=0.;
2319 break;
2320 case 1:
2321 fDoPhotonAsymmetryCut=1;
2322 fMinPPhotonAsymmetryCut=3.5;
2323 fMinPhotonAsymmetry=0.04;
2324 break;
2325 case 2:
2326 fDoPhotonAsymmetryCut=1;
2327 fMinPPhotonAsymmetryCut=3.5;
2328 fMinPhotonAsymmetry=0.06;
2329 break;
2330 case 3:
2331 fDoPhotonAsymmetryCut=1;
2332 fMinPPhotonAsymmetryCut=0.0;
2333 fMinPhotonAsymmetry=0.05;
2334 break;
2335 default:
2336 AliError(Form("PhotonAsymmetryCut not defined %d",doPhotonAsymmetryCut));
2337 return kFALSE;
2338 }
2339 fCuts[kdoPhotonAsymmetryCut]=doPhotonAsymmetryCut;
2340 return kTRUE;
2341}
2342
2343///________________________________________________________________________
2344Bool_t AliConversionPhotonCuts::SetCosPAngleCut(Int_t cosCut) {
2345
2346 switch(cosCut){
2347 case 0:
2348 fCosPAngleCut = -1;
2349 break;
2350 case 1:
2351 fCosPAngleCut = 0;
2352 break;
2353 case 2:
2354 fCosPAngleCut = 0.5;
2355 break;
2356 case 3:
2357 fCosPAngleCut = 0.75;
2358 break;
2359 case 4:
2360 fCosPAngleCut = 0.85;
2361 break;
2362 case 5:
2363 fCosPAngleCut = 0.88;
2364 break;
2365 case 6:
2366 fCosPAngleCut = 0.9;
2367 break;
2368 case 7:
2369 fCosPAngleCut = 0.95;
2370 break;
2371 default:
2372 AliError(Form("Cosine Pointing Angle cut not defined %d",cosCut));
2373 return kFALSE;
2374 }
2375
2376 return kTRUE;
2377}
2378
2379///________________________________________________________________________
2380Bool_t AliConversionPhotonCuts::SetSharedElectronCut(Int_t sharedElec) {
2381
2382 switch(sharedElec){
2383 case 0:
2384 fDoSharedElecCut = kFALSE;
2385 fDoPhotonQualitySelectionCut = kFALSE;
2386 fPhotonQualityCut = 0;
2387 break;
2388 case 1:
2389 fDoSharedElecCut = kTRUE;
2390 fDoPhotonQualitySelectionCut = kFALSE;
2391 fPhotonQualityCut = 0;
2392 break;
2393 case 2:
2394 fDoSharedElecCut = kFALSE;
2395 fDoPhotonQualitySelectionCut = kTRUE;
2396 fPhotonQualityCut = 1;
2397 break;
2398 case 3:
2399 fDoSharedElecCut = kFALSE;
2400 fDoPhotonQualitySelectionCut = kTRUE;
2401 fPhotonQualityCut = 2;
2402 break;
2403 case 4:
2404 fDoSharedElecCut = kFALSE;
2405 fDoPhotonQualitySelectionCut = kTRUE;
2406 fPhotonQualityCut = 3;
2407 break;
2408 default:
2409 AliError(Form("Shared Electron Cut not defined %d",sharedElec));
2410 return kFALSE;
2411 }
2412
2413 return kTRUE;
2414}
2415
2416///________________________________________________________________________
2417Bool_t AliConversionPhotonCuts::SetToCloseV0sCut(Int_t toClose) {
2418
2419 switch(toClose){
2420 case 0:
2421 fDoToCloseV0sCut = kFALSE;
2422 fminV0Dist = 250;
2423 break;
2424 case 1:
2425 fDoToCloseV0sCut = kTRUE;
2426 fminV0Dist = 1;
2427 break;
2428 case 2:
2429 fDoToCloseV0sCut = kTRUE;
2430 fminV0Dist = 2;
2431 break;
2432 case 3:
2433 fDoToCloseV0sCut = kTRUE;
2434 fminV0Dist = 3;
2435 break;
2436 default:
2437 AliError(Form("Shared Electron Cut not defined %d",toClose));
2438 return kFALSE;
2439 }
2440 return kTRUE;
2441}
2442
2443///________________________________________________________________________
2444Bool_t AliConversionPhotonCuts::SetTRDElectronCut(Int_t TRDElectronCut)
2445{ // Set Cut
2446 switch(TRDElectronCut){
2447 case 0:
2448 fDoTRDPID=kFALSE;
2449 break;
2450 case 1:
2451 fDoTRDPID=kTRUE;
2452 fPIDTRDEfficiency=0.1;
2453 break;
2454 case 8:
2455 fDoTRDPID=kTRUE;
2456 fPIDTRDEfficiency=0.8;
2457 break;
2458 case 9:
2459 fDoTRDPID=kTRUE;
2460 fPIDTRDEfficiency=0.9;
2461 break;
2462 default:
2463 AliError(Form("TRDElectronCut not defined %d",TRDElectronCut));
2464 return kFALSE;
2465 }
2466
2467 return kTRUE;
2468}
2469
2470///________________________________________________________________________
2471Bool_t AliConversionPhotonCuts::SetDCAZPhotonPrimVtxCut(Int_t DCAZPhotonPrimVtx){
2472 // Set Cut
2473 switch(DCAZPhotonPrimVtx){
2474 case 0: //
2475 fDCAZPrimVtxCut = 1000;
2476 break;
2477 case 1: //
2478 fDCAZPrimVtxCut = 10;
2479 break;
2480 case 2: //
2481 fDCAZPrimVtxCut = 5;
2482 break;
2483 case 3: //
2484 fDCAZPrimVtxCut = 4;
2485 break;
2486 case 4: //
2487 fDCAZPrimVtxCut = 3;
2488 break;
2489 case 5: //
2490 fDCAZPrimVtxCut = 2.5;
2491 break;
2492 case 6: //
2493 fDCAZPrimVtxCut = 2;
2494 break;
2495 case 7: //
2496 fDCAZPrimVtxCut = 1.5;
2497 break;
2498 case 8: //
2499 fDCAZPrimVtxCut = 1;
2500 break;
2501 case 9: //
2502 fDCAZPrimVtxCut = 0.5;
2503 break;
2504 default:
2505 cout<<"Warning: DCAZPhotonPrimVtx not defined "<<DCAZPhotonPrimVtx<<endl;
2506 return kFALSE;
2507 }
2508 return kTRUE;
2509}
2510
2511///________________________________________________________________________
2512Bool_t AliConversionPhotonCuts::SetDCARPhotonPrimVtxCut(Int_t DCARPhotonPrimVtx){
2513 // Set Cut
2514 switch(DCARPhotonPrimVtx){
2515 case 0: //
2516 fDCARPrimVtxCut = 1000;
2517 break;
2518 case 1: //
2519 fDCARPrimVtxCut = 10;
2520 break;
2521 case 2: //
2522 fDCARPrimVtxCut = 5;
2523 break;
2524 case 3: //
2525 fDCARPrimVtxCut = 4;
2526 break;
2527 case 4: //
2528 fDCARPrimVtxCut = 3;
2529 break;
2530 case 5: //
2531 fDCARPrimVtxCut = 2.5;
2532 break;
2533 case 6: //
2534 fDCARPrimVtxCut = 2;
2535 break;
2536 case 7: //
2537 fDCARPrimVtxCut = 1.5;
2538 break;
2539 case 8: //
2540 fDCARPrimVtxCut = 1;
2541 break;
2542 case 9: //
2543 fDCARPrimVtxCut = 0.5;
2544 break;
2545 default:
2546 cout<<"Warning: DCARPhotonPrimVtx not defined "<<DCARPhotonPrimVtx<<endl;
2547 return kFALSE;
2548 }
2549 return kTRUE;
2550}
2551
2552///________________________________________________________________________
2553Bool_t AliConversionPhotonCuts::SetInPlaneOutOfPlane(Int_t inOutPlane){
2554 // Set Cut
2555 switch(inOutPlane){
2556 case 0: //
2557 fInPlaneOutOfPlane = 0; // No Event Plane
2558 break;
2559 case 1: //
2560 fInPlaneOutOfPlane = 1; // In-Plane
2561 break;
2562 case 2: //
2563 fInPlaneOutOfPlane = 2; // Out-Of-Plane
2564 break;
2565 default:
2566 cout<<"Warning: In-Plane or Out-Of-Plane not defined "<<inOutPlane<<endl;
2567 return kFALSE;
2568 }
2569 return kTRUE;
2570}
2571
2572
2573///________________________________________________________________________
2574Int_t AliConversionPhotonCuts::GetFirstTPCRow(Double_t radius){
2575 // Get first TPC row
2576 Int_t firstTPCRow = 0;
2577 Double_t radiusI = 84.8;
2578 Double_t radiusO = 134.6;
2579 Double_t radiusOB = 198.;
2580 Double_t rSizeI = 0.75;
2581 Double_t rSizeO = 1.;
2582 Double_t rSizeOB = 1.5;
2583 Int_t nClsI = 63;
2584 Int_t nClsIO = 127;
2585
2586 if(radius <= radiusI){
2587 return firstTPCRow;
2588 }
2589 if(radius>radiusI && radius<=radiusO){
2590 firstTPCRow = (Int_t)((radius-radiusI)/rSizeI);
2591 }
2592 if(radius>radiusO && radius<=radiusOB){
2593 firstTPCRow = (Int_t)(nClsI+(radius-radiusO)/rSizeO);
2594 }
2595
2596 if(radius>radiusOB){
2597 firstTPCRow =(Int_t)(nClsIO+(radius-radiusOB)/rSizeOB);
2598 }
2599
2600 return firstTPCRow;
2601}
2602
2603///________________________________________________________________________
2604Bool_t AliConversionPhotonCuts::CosinePAngleCut(const AliConversionPhotonBase * photon, AliVEvent * event) const {
2605 ///Check if passes cosine of pointing angle cut
2606 if(GetCosineOfPointingAngle(photon, event) < fCosPAngleCut){
2607 return kFALSE;
2608 }
2609 return kTRUE;
2610}
2611
2612///________________________________________________________________________
2613Double_t AliConversionPhotonCuts::GetCosineOfPointingAngle( const AliConversionPhotonBase * photon, AliVEvent * event) const{
2614 // calculates the pointing angle of the recalculated V0
2615
2616 Double_t momV0[3] = {0,0,0};
2617 if(event->IsA()==AliESDEvent::Class()){
2618 AliESDEvent *esdEvent = dynamic_cast<AliESDEvent*>(event);
2619 if(!esdEvent) return -999;
2620 AliESDv0 *v0 = esdEvent->GetV0(photon->GetV0Index());
2621 if(!v0) return -999;
2622 v0->GetPxPyPz(momV0[0],momV0[1],momV0[2]);
2623 }
2624 if(event->IsA()==AliAODEvent::Class()){
2625 momV0[0] = photon->GetPx();
2626 momV0[1] = photon->GetPy();
2627 momV0[2] = photon->GetPz();
2628 }
2629
2630 //Double_t momV0[3] = { photon->GetPx(), photon->GetPy(), photon->GetPz() }; //momentum of the V0
2631 Double_t PosV0[3] = { photon->GetConversionX() - event->GetPrimaryVertex()->GetX(),
2632 photon->GetConversionY() - event->GetPrimaryVertex()->GetY(),
2633 photon->GetConversionZ() - event->GetPrimaryVertex()->GetZ() }; //Recalculated V0 Position vector
2634
2635 Double_t momV02 = momV0[0]*momV0[0] + momV0[1]*momV0[1] + momV0[2]*momV0[2];
2636 Double_t PosV02 = PosV0[0]*PosV0[0] + PosV0[1]*PosV0[1] + PosV0[2]*PosV0[2];
2637
2638
2639 Double_t cosinePointingAngle = -999;
2640 if(momV02*PosV02 > 0.0)
2641 cosinePointingAngle = (PosV0[0]*momV0[0] + PosV0[1]*momV0[1] + PosV0[2]*momV0[2] ) / TMath::Sqrt(momV02 * PosV02);
2642
2643 return cosinePointingAngle;
2644}
2645
2646///________________________________________________________________________
2647Bool_t AliConversionPhotonCuts::PsiPairCut(const AliConversionPhotonBase * photon) const {
2648
2649 if (fDo2DPsiPairChi2){
2650 if (abs(photon->GetPsiPair()) < -fPsiPairCut/fChi2CutConversion*photon->GetChi2perNDF() + fPsiPairCut ){
2651 return kTRUE;
2652 } else {
2653 return kFALSE;
2654 }
2655 } else {
2656 if(abs(photon->GetPsiPair()) > fPsiPairCut){
2657 return kFALSE;}
2658 else{return kTRUE;}
2659 }
2660}
2661
2662///________________________________________________________________________
2663TString AliConversionPhotonCuts::GetCutNumber(){
2664 // returns TString with current cut number
2665 TString a(kNCuts);
2666 for(Int_t ii=0;ii<kNCuts;ii++){
2667 a.Append(Form("%d",fCuts[ii]));
2668 }
2669 return a;
2670}
2671
2672///________________________________________________________________________
2673void AliConversionPhotonCuts::FillElectonLabelArray(AliAODConversionPhoton* photon, Int_t nV0){
2674
2675 Int_t posLabel = photon->GetTrackLabelPositive();
2676 Int_t negLabel = photon->GetTrackLabelNegative();
2677
2678 fElectronLabelArray[nV0*2] = posLabel;
2679 fElectronLabelArray[(nV0*2)+1] = negLabel;
2680}
2681///________________________________________________________________________
2682Bool_t AliConversionPhotonCuts::RejectSharedElectronV0s(AliAODConversionPhoton* photon, Int_t nV0, Int_t nV0s){
2683
2684 Int_t posLabel = photon->GetTrackLabelPositive();
2685 Int_t negLabel = photon->GetTrackLabelNegative();
2686
2687 for(Int_t i = 0; i<nV0s*2;i++){
2688 if(i==nV0*2) continue;
2689 if(i==(nV0*2)+1) continue;
2690 if(fElectronLabelArray[i] == posLabel){
2691 return kFALSE;}
2692 if(fElectronLabelArray[i] == negLabel){
2693 return kFALSE;}
2694 }
2695
2696 return kTRUE;
2697}
2698
2699///________________________________________________________________________
2700Bool_t AliConversionPhotonCuts::RejectToCloseV0s(AliAODConversionPhoton* photon, TList *photons, Int_t nV0){
2701
2702
2703 Double_t posX = photon->GetConversionX();
2704 Double_t posY = photon->GetConversionY();
2705 Double_t posZ = photon->GetConversionZ();
2706
2707 for(Int_t i = 0;i<photons->GetEntries();i++){
2708 if(nV0 == i) continue;
2709 AliAODConversionPhoton *photonComp = (AliAODConversionPhoton*) photons->At(i);
2710 Double_t posCompX = photonComp->GetConversionX();
2711 Double_t posCompY = photonComp->GetConversionY();
2712 Double_t posCompZ = photonComp->GetConversionZ();
2713
2714 Double_t dist = pow((posX - posCompX),2)+pow((posY - posCompY),2)+pow((posZ - posCompZ),2);
2715
2716 if(dist < fminV0Dist*fminV0Dist){
2717 if(photon->GetChi2perNDF() < photonComp->GetChi2perNDF()) return kTRUE;
2718 else {
2719 return kFALSE;}
2720 }
2721
2722 }
2723 return kTRUE;
2724}
2725
2726
2727///________________________________________________________________________
2728AliConversionPhotonCuts* AliConversionPhotonCuts::GetStandardCuts2010PbPb(){
2729 //Create and return standard 2010 PbPb cuts
2730 AliConversionPhotonCuts *cuts=new AliConversionPhotonCuts("StandardCuts2010PbPb","StandardCuts2010PbPb");
2731 if(!cuts->InitializeCutsFromCutString("04209297002322000000")){
2732 cout<<"Warning: Initialization of Standardcuts2010PbPb failed"<<endl;}
2733 return cuts;
2734}
2735
2736///________________________________________________________________________
2737AliConversionPhotonCuts* AliConversionPhotonCuts::GetStandardCuts2010pp(){
2738 //Create and return standard 2010 PbPb cuts
2739 AliConversionPhotonCuts *cuts=new AliConversionPhotonCuts("StandardCuts2010pp","StandardCuts2010pp");
2740 if(!cuts->InitializeCutsFromCutString("00209366300380000000")){
2741 cout<<"Warning: Initialization of Standardcuts2010pp failed"<<endl;}
2742 return cuts;
2743}
2744
2745///________________________________________________________________________
2746Bool_t AliConversionPhotonCuts::InPlaneOutOfPlaneCut(Double_t photonPhi, Double_t eventPlaneAngle, Bool_t fill){
2747
2748 //GetPhotonPhi() 0-2 Pi //eventPlaneAngle -1pi-1pi
2749 eventPlaneAngle=eventPlaneAngle+TMath::Pi();
2750 Double_t gammaToEPAngle = eventPlaneAngle-photonPhi;
2751 if(gammaToEPAngle < 0) gammaToEPAngle=gammaToEPAngle+2*TMath::Pi();
2752 gammaToEPAngle = gammaToEPAngle-TMath::Pi(); // angle from -pi +pi
2753
2754 if(!fInPlaneOutOfPlane){
2755 if(fill&&hEventPlanePhi)hEventPlanePhi->Fill(gammaToEPAngle);
2756 return kTRUE;
2757 }
2758 else if(fInPlaneOutOfPlane == 1){
2759 if(abs(gammaToEPAngle)<=0.25*TMath::Pi() || abs(gammaToEPAngle)>=0.75*TMath::Pi()){
2760 if(fill&&hEventPlanePhi)hEventPlanePhi->Fill(gammaToEPAngle);
2761 return kTRUE;
2762 }
2763 else return kFALSE;
2764 }
2765 else if(fInPlaneOutOfPlane == 2){
2766 if(abs(gammaToEPAngle)>0.25*TMath::Pi() && abs(gammaToEPAngle)<0.75*TMath::Pi()){
2767 if(fill&&hEventPlanePhi)hEventPlanePhi->Fill(gammaToEPAngle);
2768 return kTRUE;
2769 }
2770 else return kFALSE;
2771 }
2772 return kFALSE;
2773}
2774
2775///________________________________________________________________________
2776UChar_t AliConversionPhotonCuts::DeterminePhotonQualityAOD(AliAODConversionPhoton* photon, AliVEvent* eventDummy){
2777
2778 AliAODTrack * negTrack = static_cast<AliAODTrack*>(GetTrack(eventDummy, photon->GetTrackLabelNegative()));
2779 AliAODTrack * posTrack = static_cast<AliAODTrack*>(GetTrack(eventDummy, photon->GetTrackLabelPositive()));
2780
2781 if(!negTrack || !posTrack) {
2782 return 0;
2783 }
2784 if(negTrack->Charge() == posTrack->Charge()){
2785 return 0;
2786 }
2787 Int_t nClusterITSneg = negTrack->GetITSNcls();
2788 Int_t nClusterITSpos = posTrack->GetITSNcls();
2789 // cout << nClusterITSneg << "\t" << nClusterITSpos <<endl;
2790
2791 if (nClusterITSneg > 1 && nClusterITSpos > 1){
2792 return 3;
2793 } else if (nClusterITSneg > 1 || nClusterITSpos > 1){
2794 return 2;
2795 } else {
2796 return 1;
2797 }
2798 return 0;
2799}