AliPhysics  d497547 (d497547)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliV0ReaderV1.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Developers: Friederike Bock *
5  * Original Authors: Svein Lindal, Daniel Lohner *
6  * *
7  * Version 1.0 *
8  * *
9  * *
10  * based on: on older version (see aliroot up to v5-04-42-AN) *
11  * AliV0Reader.cxx *
12  * Authors: Kathrin Koch, Kenneth Aamodt, Ana Marin *
13  * *
14  * Permission to use, copy, modify and distribute this software and its *
15  * documentation strictly for non-commercial purposes is hereby granted *
16  * without fee, provided that the above copyright notice appears in all *
17  * copies and that both the copyright notice and this permission notic *
18  * appear in the supporting documentation. The authors make no claims *
19  * about the suitability of this software for any purpose. It is *
20  * provided "as is" without express or implied warranty. *
21  **************************************************************************/
22 
24 //---------------------------------------------
25 // Class reconstructing conversion photons from V0s
26 //---------------------------------------------
28 
29 // The AliAODConversionPhotons will return the Position (== ESDTrack->GetID())of the positive (negative) ESDTrack
30 // in the Array of ESDTracks stored in the ESDEvent via GetTrackLabelPositive() (GetTrackLabelNagative()).
31 // Since it is the Position in the Array it is always positive.
32 // After the conversion ESD --> AOD each AOD track will give you the former Position in the ESDArray via the
33 // Function AODTrack->GetID(). AODTracks are stored for different TrackParameter (e.g. HybridTracks, TPC only ...). No Standard
34 // AODTracks (not copies of AliExternalTrackParam) will be stored with negative values of AODTrack->GetID() (Formula: (ESDTrack->GetID()+1)*-1)
35 // This leads to the possibility of more than one AOD track with the same negative ID. For that reason all AOD tracks are additionally flaged.
36 // In this analysis we should therefore only use AODTracks with positive values of AODTrack->GetID().
37 
38 // If you want to find the AODTrack corresponding to the daugher track of a AliAODConversionPhoton you have to find the AODTrack with
39 // AODTrack->GetID() == GetTrackLabelPositive() (GetTrackLabelNagative()).
40 
41 #include <vector>
42 #include <TGeoGlobalMagField.h>
43 
44 #include "AliV0ReaderV1.h"
45 #include "AliKFParticle.h"
46 #include "AliAODv0.h"
47 #include "AliESDv0.h"
48 #include "AliAODEvent.h"
49 #include "AliESDEvent.h"
50 #include "AliPID.h"
51 #include "AliMCEvent.h"
52 #include "AliMCEventHandler.h"
53 #include "AliESDpid.h"
54 #include "AliESDtrackCuts.h"
55 #include "TRandom3.h"
56 #include "AliGenCocktailEventHeader.h"
57 #include "TList.h"
58 #include "AliKFConversionPhoton.h"
59 #include "AliAODConversionPhoton.h"
61 #include "TVector.h"
62 #include "AliKFVertex.h"
63 #include "AliAODTrack.h"
64 #include "AliESDtrack.h"
65 #include "AliAnalysisManager.h"
66 #include "AliInputEventHandler.h"
67 #include "AliAODHandler.h"
68 #include "AliPIDResponse.h"
69 #include "TChain.h"
70 #include "TFile.h"
71 #include "TString.h"
72 #include "TObjArray.h"
73 
74 class iostream;
75 
76 using namespace std;
77 
78 ClassImp(AliV0ReaderV1)
79 
80 //________________________________________________________________________
81 AliV0ReaderV1::AliV0ReaderV1(const char *name) : AliAnalysisTaskSE(name),
82  fConversionCuts(NULL),
83  fEventCuts(NULL),
84  fConversionGammas(NULL),
85  fUseImprovedVertex(kTRUE),
86  fUseOwnXYZCalculation(kTRUE),
87  fUseConstructGamma(kFALSE),
88  kUseAODConversionPhoton(kTRUE),
89  kAddv0sInESDFilter(kFALSE),
90  fCreateAOD(kFALSE),
91  fDeltaAODBranchName("GammaConv"),
92  fDeltaAODFilename("AliAODGammaConversion.root"),
93  fRelabelAODs(kFALSE),
94  fPreviousV0ReaderPerformsAODRelabeling(0),
95  fEventIsSelected(kFALSE),
96  fNumberOfPrimaryTracks(0),
97  fNumberOfTPCoutTracks(0),
98  fPeriodName(""),
99  fPtHardBin(0),
100  fUseMassToZero(kTRUE),
101  fProduceV0findingEffi(kFALSE),
102  fProduceImpactParamHistograms(kFALSE),
103  fCurrentInvMassPair(0),
104  fImprovedPsiPair(3),
105  fHistograms(NULL),
106  fImpactParamHistograms(NULL),
107  fHistoMCGammaPtvsR(NULL),
108  fHistoMCGammaPtvsPhi(NULL),
109  fHistoMCGammaPtvsEta(NULL),
110  fHistoMCGammaRvsPhi(NULL),
111  fHistoMCGammaRvsEta(NULL),
112  fHistoMCGammaPhivsEta(NULL),
113  fHistoRecMCGammaPtvsR(NULL),
114  fHistoRecMCGammaPtvsPhi(NULL),
115  fHistoRecMCGammaPtvsEta(NULL),
116  fHistoRecMCGammaRvsPhi(NULL),
117  fHistoRecMCGammaRvsEta(NULL),
118  fHistoRecMCGammaPhivsEta(NULL),
119  fHistoRecMCGammaMultiPt(NULL),
120  fHistoRecMCGammaMultiPtvsEta(NULL),
121  fHistoRecMCGammaMultiR(NULL),
122  fHistoRecMCGammaMultiPhi(NULL),
123  fHistoPosTrackImpactParamZ(NULL),
124  fHistoPosTrackImpactParamY(NULL),
125  fHistoPosTrackImpactParamX(NULL),
126  fHistoPosTrackImpactParamZvsPt(NULL),
127  fHistoPosTrackImpactParamYvsPt(NULL),
128  fHistoPosTrackImpactParamXvsPt(NULL),
129  fHistoNegTrackImpactParamZ(NULL),
130  fHistoNegTrackImpactParamY(NULL),
131  fHistoNegTrackImpactParamX(NULL),
132  fHistoNegTrackImpactParamZvsPt(NULL),
133  fHistoNegTrackImpactParamYvsPt(NULL),
134  fHistoNegTrackImpactParamXvsPt(NULL),
135  fHistoImpactParamZvsR(NULL),
136  fHistoImpactParamZvsR2(NULL),
137  fHistoPt(NULL),
138  fHistoPt2(NULL),
139  fHistoDCAzPhoton(NULL),
140  fHistoDCAzPhoton2(NULL),
141  fHistoR(NULL),
142  fHistoRrecalc(NULL),
143  fHistoRviaAlpha(NULL),
144  fHistoRviaAlphaRecalc(NULL),
145  fHistoRdiff(NULL),
146  fHistoImpactParameterStudy(NULL),
147  fImpactParamTree(NULL),
148  fVectorFoundGammas(0),
149  fCurrentFileName(""),
150  fMCFileChecked(kFALSE),
151  fPCMv0BitField(NULL)
152 {
153  // Default constructor
154 
155  DefineInput(0, TChain::Class());
156  DefineOutput(1,TBits::Class());
157 }
158 
159 //________________________________________________________________________
161 {
162  // default deconstructor
163 
164  if(fConversionGammas){
165  fConversionGammas->Delete();// Clear Objects
166  delete fConversionGammas;
167  fConversionGammas=0x0;
168  }
169 }
170 
180  if(fConversionGammas && (index < fConversionGammas->GetEntriesFast())) {
181  TObject *tmp = fConversionGammas->At(index);
182  if(tmp->IsA() == AliAODConversionPhoton::Class()){
183  AliAODConversionPhoton *photon = static_cast<AliAODConversionPhoton *>(tmp);
184  return photon;
185  } else {
186  AliKFConversionPhoton *photon = static_cast<AliKFConversionPhoton *>(tmp);
187  return photon;
188  }
189  } else {
190  return nullptr;
191  }
192 }
193 
194 /*
195 //________________________________________________________________________
196 AliV0ReaderV1::AliV0ReaderV1(AliV0ReaderV1 &original) : AliAnalysisTaskSE(original),
197 fConversionCuts(NULL),
198 fConversionGammas(NULL),
199 fUseImprovedVertex(original.fUseImprovedVertex),
200 fUseOwnXYZCalculation(original.fUseOwnXYZCalculation),
201 fUseConstructGamma(original.fUseConstructGamma),
202 kUseAODConversionPhoton(original.kUseAODConversionPhoton),
203 fCreateAOD(original.fCreateAOD),
204 fDeltaAODBranchName(original.fDeltaAODBranchName),
205 fDeltaAODFilename(original.fDeltaAODFilename),
206 fEventIsSelected(original.fEventIsSelected)
207 {
208 // Default constructor
209 
210 DefineInput(0, TChain::Class());
211 }
212 
213 //____________________________________________________________
214 AliV0ReaderV1 &AliV0ReaderV1::operator=(const AliV0ReaderV1 &ref){
215 //
216 // Assignment operator
217 // Only copies pointers, object is not the owner of the references
218 //
219 if(this != &ref){
220 AliAnalysisTaskSE::operator=(ref);
221 fUseImprovedVertex=ref.fUseImprovedVertex;
222 fUseOwnXYZCalculation=ref.fUseOwnXYZCalculation;
223 fUseConstructGamma=ref.fUseConstructGamma;
224 kUseAODConversionPhoton=ref.kUseAODConversionPhoton;
225 fCreateAOD=ref.fCreateAOD;
226 fDeltaAODBranchName=ref.fDeltaAODBranchName;
227 fDeltaAODFilename=ref.fDeltaAODFilename;
228 fEventIsSelected=ref.fEventIsSelected;
229 }
230 return *this;
231 }
232 */
233 
234 //________________________________________________________________________
236 {
237  // Initialize function to be called once before analysis
238  if(fConversionCuts==NULL){
239  if(fConversionCuts==NULL)AliError("No Conversion Cut Selection initialized");
240  }
241  if(fEventCuts==NULL){
242  if(fEventCuts==NULL)AliError("No Event Cut Selection initialized");
243  }
244 
245  if(fCreateAOD){kUseAODConversionPhoton=kTRUE;}
246 
247  if(fConversionGammas != NULL){
248  delete fConversionGammas;
249  fConversionGammas=NULL;
250  }
251 
252  if(fConversionGammas == NULL){
253  if(kUseAODConversionPhoton){
254  fConversionGammas = new TClonesArray("AliAODConversionPhoton",100);}
255  else{
256  fConversionGammas = new TClonesArray("AliKFConversionPhoton",100);}
257  }
258  fConversionGammas->Delete();//Reset the TClonesArray
259 }
260 
261 //________________________________________________________________________
263 {
264  // Create AODs
265 
266  if(fCreateAOD){
267  fPCMv0BitField = new TBits();
268 
269  if (fEventCuts){
270  fDeltaAODBranchName.Append("_");
271  fDeltaAODBranchName.Append(fEventCuts->GetCutNumber());
272  }
273  if(fConversionCuts){
274  fDeltaAODBranchName.Append("_");
275  fDeltaAODBranchName.Append(fConversionCuts->GetCutNumber());
276  fDeltaAODBranchName.Append("_gamma");
277  }
278  fConversionGammas->SetName(fDeltaAODBranchName.Data());
279 
280  AddAODBranch("TClonesArray", &fConversionGammas, fDeltaAODFilename.Data());
281  AliAnalysisManager::GetAnalysisManager()->RegisterExtraFile(fDeltaAODFilename.Data());
282  }
283 
284  if(fProduceImpactParamHistograms){
285  if(fImpactParamHistograms != NULL){
286  delete fImpactParamHistograms;
287  fImpactParamHistograms = NULL;
288  }
289  if(fImpactParamHistograms==NULL){
290  fImpactParamHistograms = new TList();
291  fImpactParamHistograms->SetOwner(kTRUE);
292  fImpactParamHistograms->SetName(Form("ImpactParamHistograms_%s_%s",fEventCuts->GetCutNumber().Data(),fConversionCuts->GetCutNumber().Data()));
293  }
294  fHistoPosTrackImpactParamZ = new TH1F("fHistoPosTrackImpactParamZ","",480,-80,80);
295  fHistoPosTrackImpactParamZ->SetXTitle("Z (cm)");
296  fImpactParamHistograms->Add(fHistoPosTrackImpactParamZ);
297 
298  fHistoPosTrackImpactParamY = new TH1F("fHistoPosTrackImpactParamY","",720,-120,120);
299  fHistoPosTrackImpactParamY->SetXTitle("Y (cm)");
300  fImpactParamHistograms->Add(fHistoPosTrackImpactParamY);
301 
302  fHistoPosTrackImpactParamX = new TH1F("fHistoPosTrackImpactParamX","",30,-3,3);
303  fHistoPosTrackImpactParamX->SetXTitle("X (cm)");
304  fImpactParamHistograms->Add(fHistoPosTrackImpactParamX);
305 
306  fHistoNegTrackImpactParamZ = new TH1F("fHistoNegTrackImpactParamZ","",480,-80,80);
307  fHistoNegTrackImpactParamZ->SetXTitle("Z (cm)");
308  fImpactParamHistograms->Add(fHistoNegTrackImpactParamZ);
309 
310  fHistoNegTrackImpactParamY = new TH1F("fHistoNegTrackImpactParamY","",720,-120,120);
311  fHistoNegTrackImpactParamY->SetXTitle("Y (cm)");
312  fImpactParamHistograms->Add(fHistoNegTrackImpactParamY);
313 
314  fHistoNegTrackImpactParamX = new TH1F("fHistoNegTrackImpactParamX","",30,-3,3);
315  fHistoNegTrackImpactParamX->SetXTitle("X (cm)");
316  fImpactParamHistograms->Add(fHistoNegTrackImpactParamX);
317 
318  fHistoPosTrackImpactParamZvsPt = new TH2F("fHistoPosTrackImpactParamZvsPt","",100,0,10,480,-80,80);
319  fHistoPosTrackImpactParamZvsPt->SetYTitle("Z (cm)");
320  fHistoPosTrackImpactParamZvsPt->SetXTitle("Pt (GeV)");
321  fImpactParamHistograms->Add(fHistoPosTrackImpactParamZvsPt);
322 
323  fHistoPosTrackImpactParamYvsPt = new TH2F("fHistoPosTrackImpactParamYvsPt","",100,0,10,720,-120,120);
324  fHistoPosTrackImpactParamYvsPt->SetYTitle("Y (cm)");
325  fHistoPosTrackImpactParamYvsPt->SetXTitle("Pt (GeV)");
326  fImpactParamHistograms->Add(fHistoPosTrackImpactParamYvsPt);
327 
328  fHistoPosTrackImpactParamXvsPt = new TH2F("fHistoPosTrackImpactParamXvsPt","",100,0,10,30,-3,5);
329  fHistoPosTrackImpactParamXvsPt->SetYTitle("X (cm)");
330  fHistoPosTrackImpactParamXvsPt->SetXTitle("Pt (GeV)");
331  fImpactParamHistograms->Add(fHistoPosTrackImpactParamXvsPt);
332 
333  fHistoNegTrackImpactParamZvsPt = new TH2F("fHistoNegTrackImpactParamZvsPt","",100,0,10,480,-80,80);
334  fHistoNegTrackImpactParamZvsPt->SetYTitle("Z (cm)");
335  fHistoNegTrackImpactParamZvsPt->SetXTitle("Pt (GeV)");
336  fImpactParamHistograms->Add(fHistoNegTrackImpactParamZvsPt);
337 
338  fHistoNegTrackImpactParamYvsPt = new TH2F("fHistoNegTrackImpactParamYvsPt","",100,0,10,720,-120,120);
339  fHistoNegTrackImpactParamYvsPt->SetYTitle("Y (cm)");
340  fHistoNegTrackImpactParamYvsPt->SetXTitle("Pt (GeV)");
341  fImpactParamHistograms->Add(fHistoNegTrackImpactParamYvsPt);
342 
343  fHistoNegTrackImpactParamXvsPt = new TH2F("fHistoNegTrackImpactParamXvsPt","",100,0,10,30,-3,3);
344  fHistoNegTrackImpactParamXvsPt->SetYTitle("X (cm)");
345  fHistoNegTrackImpactParamXvsPt->SetXTitle("Pt (GeV)");
346  fImpactParamHistograms->Add(fHistoNegTrackImpactParamXvsPt);
347 
348  fHistoImpactParamZvsR = new TH2F("fHistoImpactParamZvsR","Before cuts",300,-150,150,200,0,200);
349  fHistoImpactParamZvsR->SetXTitle("Z (cm)");
350  fHistoImpactParamZvsR->SetYTitle("R (cm)");
351  fImpactParamHistograms->Add(fHistoImpactParamZvsR);
352 
353  fHistoImpactParamZvsR2 = new TH2F("fHistoImpactParamZvsR2","After cuts",300,-150,150,200,0,200);
354  fHistoImpactParamZvsR2->SetXTitle("Z (cm)");
355  fHistoImpactParamZvsR2->SetYTitle("R (cm)");
356  fImpactParamHistograms->Add(fHistoImpactParamZvsR2);
357 
358  fHistoPt = new TH1F("fHistoPt","Before all cuts",100,0,10);
359  fHistoPt->SetXTitle("Pt (GeV)");
360  fImpactParamHistograms->Add(fHistoPt);
361 
362  fHistoPt2 = new TH1F("fHistoPt2","After all cuts",100,0,10);
363  fHistoPt2->SetXTitle("Pt (GeV)");
364  fImpactParamHistograms->Add(fHistoPt2);
365 
366  fHistoDCAzPhoton = new TH1F("fHistoDCAzPhoton","Before cuts",20,-2,2);
367  fHistoDCAzPhoton->SetXTitle("DCAz photon (cm)");
368  fImpactParamHistograms->Add(fHistoDCAzPhoton);
369 
370  fHistoDCAzPhoton2 = new TH1F("fHistoDCAzPhoton2","After cuts",20,-2,2);
371  fHistoDCAzPhoton2->SetXTitle("DCAz photon (cm)");
372  fImpactParamHistograms->Add(fHistoDCAzPhoton2);
373 
374  fHistoR = new TH1F("fHistoR","",200,0,200);
375  fHistoR->SetXTitle("Conversion radius (cm)");
376  fImpactParamHistograms->Add(fHistoR);
377 
378  fHistoRrecalc = new TH1F("fHistoRrecalc","",200,0,200);
379  fHistoRrecalc->SetXTitle("conversion radius (cm)");
380  fImpactParamHistograms->Add(fHistoRrecalc);
381 
382  fHistoRviaAlpha = new TH1F("fHistoRviaAlpha","",200,0,200);
383  fHistoRviaAlpha->SetXTitle("Conversion radius (cm)");
384  fImpactParamHistograms->Add(fHistoRviaAlpha);
385 
386  fHistoRviaAlphaRecalc = new TH1F("fHistoRviaAlphaRecalc","",200,0,200);
387  fHistoRviaAlphaRecalc->SetXTitle("conversion radius (cm)");
388  fImpactParamHistograms->Add(fHistoRviaAlphaRecalc);
389 
390  fHistoRdiff = new TH1F("fHistoRdiff","",200,0,200);
391  fHistoRdiff->SetXTitle("R_conv - R_cluster conflict (cm)");
392  fImpactParamHistograms->Add(fHistoRdiff);
393 
394  fHistoImpactParameterStudy = new TH1F("fHistoImpactParameterStudy","",7,-0.5,6.5);
395  fHistoImpactParameterStudy->GetXaxis()->SetBinLabel(1,"# V0s");
396  fHistoImpactParameterStudy->GetXaxis()->SetBinLabel(2,"two TPC-only tracks");
397  fHistoImpactParameterStudy->GetXaxis()->SetBinLabel(3,"Z cut not passed");
398  fHistoImpactParameterStudy->GetXaxis()->SetBinLabel(4,"Y cut not passed");
399  fHistoImpactParameterStudy->GetXaxis()->SetBinLabel(5,"R>80cm");
400  fHistoImpactParameterStudy->GetXaxis()->SetBinLabel(6,"causality cut not p.");
401  fHistoImpactParameterStudy->GetXaxis()->SetBinLabel(7,"# removed V0s"); // of all V0s
402  fImpactParamHistograms->Add(fHistoImpactParameterStudy);
403 
404  fImpactParamTree = new TTree("fImpactParamTree","");
405  fImpactParamHistograms->Add(fImpactParamTree);
406  }
407 
408  if (fProduceV0findingEffi){
409  TH1::AddDirectory(kFALSE);
410  if(fHistograms != NULL){
411  delete fHistograms;
412  fHistograms = NULL;
413  }
414  if(fHistograms==NULL){
415  fHistograms = new TList();
416  fHistograms->SetOwner(kTRUE);
417  fHistograms->SetName(Form("V0FindingEfficiencyInput_%s_%s",fEventCuts->GetCutNumber().Data(),fConversionCuts->GetCutNumber().Data()));
418  }
419 
420  fHistoMCGammaPtvsR = new TH2F("MCconvGamma_Pt_R","MC converted gamma Pt vs R (|eta| < 0.9)",250,0.0,25,400,0,200);
421  fHistoMCGammaPtvsR->SetXTitle("p_{MC,T} (GeV/c)");
422  fHistoMCGammaPtvsR->SetYTitle("R_{MC,conv} (cm)");
423  fHistograms->Add(fHistoMCGammaPtvsR);
424 
425  fHistoMCGammaPtvsEta = new TH2F("MCconvGamma_Pt_Eta","MC converted gamma Pt vs Eta ",250,0.0,25,280,-1.4,1.4);
426  fHistoMCGammaPtvsEta->SetXTitle("p_{MC,T} (GeV/c)");
427  fHistoMCGammaPtvsEta->SetYTitle("#eta_{MC}");
428  fHistograms->Add(fHistoMCGammaPtvsEta);
429 
430  fHistoMCGammaPtvsPhi = new TH2F("MCconvGamma_Pt_Phi","MC converted gamma Pt vs Phi (|eta| < 0.9) ",250,0.0,25,400,0,2*TMath::Pi());
431  fHistoMCGammaPtvsPhi->SetXTitle("p_{MC,T} (GeV/c)");
432  fHistoMCGammaPtvsPhi->SetYTitle("#varphi_{MC} (rad)");
433  fHistograms->Add(fHistoMCGammaPtvsPhi);
434 
435  fHistoMCGammaRvsPhi = new TH2F("MCconvGamma_R_Phi","MC converted gamma R vs Phi (|eta| < 0.9) ",400,0,200,400,0,2*TMath::Pi());
436  fHistoMCGammaRvsPhi->SetXTitle("R_{MC,conv} (cm)");
437  fHistoMCGammaRvsPhi->SetYTitle("#varphi_{MC} (rad)");
438  fHistograms->Add(fHistoMCGammaRvsPhi);
439 
440  fHistoMCGammaRvsEta = new TH2F("MCconvGamma_R_Eta","MC converted gamma R vs Eta ",400,0,200,280,-1.4,1.4);
441  fHistoMCGammaRvsEta->SetXTitle("R_{MC,conv} (cm)");
442  fHistoMCGammaRvsEta->SetYTitle("#eta_{MC}");
443  fHistograms->Add(fHistoMCGammaRvsEta);
444 
445  fHistoMCGammaPhivsEta = new TH2F("MCconvGamma_Phi_Eta","MC converted gamma Phi vs Eta ",400,0,2*TMath::Pi(),280,-1.4,1.4);
446  fHistoMCGammaPhivsEta->SetXTitle("#phi_{MC} (rad)");
447  fHistoMCGammaPhivsEta->SetYTitle("#eta_{MC}");
448  fHistograms->Add(fHistoMCGammaPhivsEta);
449 
450  fHistoRecMCGammaPtvsR = new TH2F("RecMCconvGamma_Pt_R","rec MC converted gamma Pt vs R (|eta| < 0.9)",250,0.0,25,400,0,200);
451  fHistoRecMCGammaPtvsR->SetXTitle("p_{MC,T} (GeV/c)");
452  fHistoRecMCGammaPtvsR->SetYTitle("R_{MC,conv} (cm)");
453  fHistograms->Add(fHistoRecMCGammaPtvsR);
454 
455  fHistoRecMCGammaPtvsEta = new TH2F("RecMCconvGamma_Pt_Eta","rec MC converted gamma Pt vs Eta ",250,0.0,25,280,-1.4,1.4);
456  fHistoRecMCGammaPtvsEta->SetXTitle("p_{MC,T} (GeV/c)");
457  fHistoRecMCGammaPtvsEta->SetYTitle("#eta_{MC}");
458  fHistograms->Add(fHistoRecMCGammaPtvsEta);
459 
460  fHistoRecMCGammaPtvsPhi = new TH2F("RecMCconvGamma_Pt_Phi","rec MC converted gamma Pt vs Phi (|eta| < 0.9) ",250,0.0,25,400,0,2*TMath::Pi());
461  fHistoRecMCGammaPtvsPhi->SetXTitle("p_{MC,T} (GeV/c)");
462  fHistoRecMCGammaPtvsPhi->SetYTitle("#varphi_{MC} (rad)");
463  fHistograms->Add(fHistoRecMCGammaPtvsPhi);
464 
465  fHistoRecMCGammaRvsPhi = new TH2F("RecMCconvGamma_R_Phi","rec MC converted gamma R vs Phi (|eta| < 0.9) ",400,0,200,400,0,2*TMath::Pi());
466  fHistoRecMCGammaRvsPhi->SetXTitle("R_{MC,conv} (cm)");
467  fHistoRecMCGammaRvsPhi->SetYTitle("#varphi_{MC} (rad)");
468  fHistograms->Add(fHistoRecMCGammaRvsPhi);
469 
470  fHistoRecMCGammaRvsEta = new TH2F("RecMCconvGamma_R_Eta","rec MC converted gamma R vs Eta ",400,0,200,280,-1.4,1.4);
471  fHistoRecMCGammaRvsEta->SetXTitle("R_{MC,conv} (cm)");
472  fHistoRecMCGammaRvsEta->SetYTitle("#eta_{MC}");
473  fHistograms->Add(fHistoRecMCGammaRvsEta);
474 
475  fHistoRecMCGammaPhivsEta = new TH2F("RecMCconvGamma_Phi_Eta","rec MC converted gamma Phi vs Eta ",400,0,2*TMath::Pi(),280,-1.4,1.4);
476  fHistoRecMCGammaPhivsEta->SetXTitle("#phi_{MC} (rad)");
477  fHistoRecMCGammaPhivsEta->SetYTitle("#eta_{MC}");
478  fHistograms->Add(fHistoRecMCGammaPhivsEta);
479 
480  fHistoRecMCGammaMultiPtvsEta = new TH2F("RecMCconvGammaMulti_Pt_Eta","rec MC converted gamma (at least double counted) Pt vs Eta ",250,0.0,25,280,-1.4,1.4);
481  fHistoRecMCGammaMultiPtvsEta->SetXTitle("p_{MC,T} (GeV/c)");
482  fHistoRecMCGammaMultiPtvsEta->SetYTitle("#eta_{MC}");
483  fHistograms->Add(fHistoRecMCGammaMultiPtvsEta);
484 
485  fHistoRecMCGammaMultiPt = new TH1F("RecMCconvGammaMulti_Pt","rec MC converted gamma (at least double counted) Pt (|eta| < 0.9)",250,0.0,25);
486  fHistoRecMCGammaMultiPt->SetXTitle("p_{MC,T} (GeV/c)");
487  fHistograms->Add(fHistoRecMCGammaMultiPt);
488 
489  fHistoRecMCGammaMultiR = new TH1F("RecMCconvGammaMulti_R","rec MC converted gamma (at least double counted) R (|eta| < 0.9)",400,0,200);
490  fHistoRecMCGammaMultiR->SetXTitle("R_{MC,conv} (cm)");
491  fHistograms->Add(fHistoRecMCGammaMultiR);
492 
493  fHistoRecMCGammaMultiPhi = new TH1F("RecMCconvGammaMulti_Phi","rec MC converted gamma (at least double counted) Phi (|eta| < 0.9)",400,0,2*TMath::Pi());
494  fHistoRecMCGammaMultiPhi->SetXTitle("#phi_{MC} (rad)");
495  fHistograms->Add(fHistoRecMCGammaMultiPhi);
496 
497  fVectorFoundGammas.clear();
498  }
499 
500 }
501 //________________________________________________________________________
503 
504  // set file name to empty & reset check flag
505  fCurrentFileName = "";
506  fMCFileChecked = kFALSE;
507 
508  // obtain file name from analysis manager
509  AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
510  if(man) {
511  AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
512  if (inputHandler){
513  TTree* tree = (TTree*) inputHandler->GetTree();
514  TFile* file = (TFile*) tree->GetCurrentFile();
515  fCurrentFileName = file->GetName();
516  }
517  }
518 
519  // try to extract period name from file name if not given
520  if (fPeriodName.CompareTo("") == 0){
521  TObjArray *arr = fCurrentFileName.Tokenize("/");
522  fPtHardBin = -1;
523  for (Int_t i = 0; i < arr->GetEntriesFast();i++ ){
524  TObjString* testObjString = (TObjString*)arr->At(i);
525  if (testObjString->GetString().BeginsWith("LHC")){
526  fPeriodName = testObjString->GetString();
527  i = arr->GetEntriesFast();
528  }
529  }
530  if (fPeriodName.CompareTo("")==0){
531  TObjArray *arr2 = fCurrentFileName.Tokenize("__");
532  for (Int_t i = 0; i < arr->GetEntriesFast();i++ ){
533  TObjString* testObjString = (TObjString*)arr2->At(i);
534  if (testObjString->GetString().BeginsWith("LHC")){
535  fPeriodName = testObjString->GetString();
536  i = arr2->GetEntriesFast();
537  }
538  }
539  }
540  if (fPeriodName.CompareTo("") != 0 && fEventCuts->GetPeriodEnum() == AliConvEventCuts::kNoPeriod ){
541  fEventCuts->SetPeriodEnum (fPeriodName);
542  }
543  } else {
544  if(fEventCuts->GetPeriodEnum() == AliConvEventCuts::kNoPeriod ){
545  fEventCuts->SetPeriodEnum (fPeriodName);
546  }
547  }
548  // set pt hard bin from file name
549  if ( fEventCuts->GetPeriodEnum() == AliConvEventCuts::kLHC15a3a || fEventCuts->GetPeriodEnum() == AliConvEventCuts::kLHC15a3a_plus ||
550  fEventCuts->GetPeriodEnum() == AliConvEventCuts::kLHC15a3b ||
551  fEventCuts->GetPeriodEnum() == AliConvEventCuts::kLHC15g1a || fEventCuts->GetPeriodEnum() == AliConvEventCuts::kLHC15g1b ||
552  fEventCuts->GetPeriodEnum() == AliConvEventCuts::kLHC16c2 || fEventCuts->GetPeriodEnum() == AliConvEventCuts::kLHC16c2_plus ||
553  fEventCuts->GetPeriodEnum() == AliConvEventCuts::kLHC16c3a || fEventCuts->GetPeriodEnum() == AliConvEventCuts::kLHC16c3b ||
554  fEventCuts->GetPeriodEnum() == AliConvEventCuts::kLHC16c3c){
555  TObjArray *arr = fCurrentFileName.Tokenize("/");
556  fPtHardBin = -1;
557  for (Int_t i = 0; i < arr->GetEntriesFast();i++ ){
558  TObjString* testObjString = (TObjString*)arr->At(i);
559  if (testObjString->GetString().BeginsWith("LHC")){
560  TObjString* testObjString2 = (TObjString*)arr->At(i+1);
561  fPtHardBin = testObjString2->GetString().Atoi();
562  i = arr->GetEntriesFast();
563  }
564  }
565  }
566 
567  if(!fEventCuts->GetDoEtaShift()) return kTRUE; // No Eta Shift requested, continue
568  if(fEventCuts->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
569  fEventCuts->GetCorrectEtaShiftFromPeriod();
570  fEventCuts->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
571  return kTRUE;
572  } else {
573  printf(" Gamma Conversion Reader %s_%s :: Eta Shift Manually Set to %f \n\n",
574  (fEventCuts->GetCutNumber()).Data(),(fConversionCuts->GetCutNumber()).Data(),fEventCuts->GetEtaShift());
575  fEventCuts->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
576  }
577 
578  return kTRUE;
579 }
580 //________________________________________________________________________
582 
583  AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(fInputEvent);
584  if(esdEvent) {
585  if (!TGeoGlobalMagField::Instance()->GetField()) esdEvent->InitMagneticField();
586  }
587 
588  // Check if correctly initialized
589  if(!fConversionGammas)Init();
590 
591  // User Exec
592  fEventIsSelected=ProcessEvent(fInputEvent,fMCEvent);
593 
594  // AOD Output
595  FillAODOutput();
596 
597 }
598 
599 //________________________________________________________________________
600 Bool_t AliV0ReaderV1::ProcessEvent(AliVEvent *inputEvent,AliMCEvent *mcEvent)
601 {
602 
603  //Reset the TClonesArray
604  fConversionGammas->Delete();
605 
606  //Clear TBits object with accepted v0s from previous event
607  if (kAddv0sInESDFilter){fPCMv0BitField->Clear();}
608 
609  fInputEvent = inputEvent;
610  fMCEvent = mcEvent;
611 
612  if(!fInputEvent){
613  AliError("No Input event");
614  return kFALSE;
615  }
616  if(!fEventCuts){AliError("No EventCuts");return kFALSE;}
617  if(!fConversionCuts){AliError("No ConversionCuts");return kFALSE;}
618 
619 
620  // Count Primary Tracks Event
621  CountTracks();
622 
623  //Count Tracks with TPCout flag
624  CountTPCoutTracks();
625 
626 
627  // Event Cuts
628  if(!fEventCuts->EventIsSelected(fInputEvent,fMCEvent)){
629  if (fEventCuts->GetEventQuality() == 2 && !fMCFileChecked ){
630  cout << "ERROR with MC reading for: "<< fCurrentFileName.Data() << endl;
631  fMCFileChecked = kTRUE;
632  }
633  return kFALSE;
634  }
635  // Set Magnetic Field
636  AliKFParticle::SetField(fInputEvent->GetMagneticField());
637 
638  if(fInputEvent->IsA()==AliAODEvent::Class() && fProduceV0findingEffi){
639  fProduceV0findingEffi = kFALSE;
640  AliWarning("V0finding effi cannot be run on AODs ");
641  }
642 
643  if(fProduceV0findingEffi){
644  CreatePureMCHistosForV0FinderEffiESD();
645  fVectorFoundGammas.clear();
646  }
647 
648  if(fInputEvent->IsA()==AliESDEvent::Class()){
649  ProcessESDV0s();
650  }
651  if(fInputEvent->IsA()==AliAODEvent::Class()){
652  GetAODConversionGammas();
653  }
654 
655  return kTRUE;
656 }
659 {
660  // Fill AOD Output with reconstructed Photons
661 
662  if(fInputEvent->IsA()==AliESDEvent::Class()){
664  if(fCreateAOD) {
665  PostData(1, fPCMv0BitField);
666  AliAODHandler * aodhandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
667  if (aodhandler && aodhandler->GetFillAOD()) {
668  AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillExtension(kTRUE);
669  //PostData(0, fConversionGammas);
670 
671  }
672  }
673  }
674 }
675 
677 const AliExternalTrackParam *AliV0ReaderV1::GetExternalTrackParam(AliESDv0 *fCurrentV0,Int_t &tracklabel,Int_t charge){
678 
679  // Get External Track Parameter with given charge
680 
681  if(!(charge==1||charge==-1)){AliError("Charge not defined");return 0x0;}
682 
683  if(fConversionCuts->GetV0FinderSameSign()==1){
684  if(fCurrentV0){
685  if((fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetPindex()))->Charge()!=(fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetNindex()))->Charge())return 0x0;
686  if((fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetPindex()))->Charge()==(fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetNindex()))->Charge()){
687  if(charge==1){
688  tracklabel=fCurrentV0->GetPindex();
689  return fCurrentV0->GetParamP();
690  }else{
691  tracklabel=fCurrentV0->GetNindex();
692  return fCurrentV0->GetParamN();
693  }
694  }
695  }
696  }else if(fConversionCuts->GetV0FinderSameSign()==2){
697  if(fCurrentV0){
698  if(charge==1){
699  tracklabel=fCurrentV0->GetPindex();
700  return fCurrentV0->GetParamP();
701  }else{
702  tracklabel=fCurrentV0->GetNindex();
703  return fCurrentV0->GetParamN();
704  }
705  }
706  }else{
707  // Check for sign flip
708  if(fCurrentV0){
709  if(!fCurrentV0->GetParamN()||!fCurrentV0->GetParamP())return 0x0;
710  if(!fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetNindex())||!fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetPindex()))return 0x0;
711  if((fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetPindex()))->Charge()==charge){
712  tracklabel=fCurrentV0->GetPindex();
713  return fCurrentV0->GetParamP();}
714  if((fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetNindex()))->Charge()==charge){
715  tracklabel=fCurrentV0->GetNindex();
716  return fCurrentV0->GetParamN();}
717  }
718  }
719  return 0x0;
720 }
721 
724 {
725 
726  // Process ESD V0s for conversion photon reconstruction
727  AliESDEvent *fESDEvent=dynamic_cast<AliESDEvent*>(fInputEvent);
728 
729  AliKFConversionPhoton *fCurrentMotherKFCandidate=NULL;
730 
731  if(fESDEvent){
732  for(Int_t currentV0Index=0;currentV0Index<fESDEvent->GetNumberOfV0s();currentV0Index++){
733  AliESDv0 *fCurrentV0=(AliESDv0*)(fESDEvent->GetV0(currentV0Index));
734  if(!fCurrentV0){
735  printf("Requested V0 does not exist");
736  continue;
737  }
738 
739  fCurrentMotherKFCandidate=ReconstructV0(fCurrentV0,currentV0Index);
740 
741  if(fCurrentMotherKFCandidate){
742  // Add Gamma to the TClonesArray
743 
744  if(kUseAODConversionPhoton){
745  new((*fConversionGammas)[fConversionGammas->GetEntriesFast()]) AliAODConversionPhoton(fCurrentMotherKFCandidate);
746  AliAODConversionPhoton * currentConversionPhoton = (AliAODConversionPhoton*)(fConversionGammas->At(fConversionGammas->GetEntriesFast()-1));
747  currentConversionPhoton->SetMass(fCurrentMotherKFCandidate->M());
748  if (fUseMassToZero) currentConversionPhoton->SetMassToZero();
749  currentConversionPhoton->SetInvMassPair(fCurrentInvMassPair);
750  if(kAddv0sInESDFilter){fPCMv0BitField->SetBitNumber(currentV0Index, kTRUE);}
751  } else {
752  new((*fConversionGammas)[fConversionGammas->GetEntriesFast()]) AliKFConversionPhoton(*fCurrentMotherKFCandidate);
753  }
754 
755  delete fCurrentMotherKFCandidate;
756  fCurrentMotherKFCandidate=NULL;
757  }
758  }
759  if(kAddv0sInESDFilter){fPCMv0BitField->Compact();}
760  }
761  return kTRUE;
762 }
763 
765 AliKFConversionPhoton *AliV0ReaderV1::ReconstructV0(AliESDv0 *fCurrentV0,Int_t currentV0Index)
766 {
767  // cout << currentV0Index << endl;
768  // Reconstruct conversion photon from ESD v0
769  fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kPhotonIn);
770 
771  //checks if on the fly mode is set
772  if(!fConversionCuts->SelectV0Finder(fCurrentV0->GetOnFlyStatus())){
773  fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kOnFly);
774  return 0x0;
775  }
776 
777  if (fMCEvent && fProduceV0findingEffi ) FillRecMCHistosForV0FinderEffiESD(fCurrentV0);
778 
779  // TrackLabels
780  Int_t currentTrackLabels[2]={-1,-1};
781 
782  // Get Daughter KF Particles
783 
784  const AliExternalTrackParam *fCurrentExternalTrackParamPositive=GetExternalTrackParamP(fCurrentV0,currentTrackLabels[0]);
785  // cout << fCurrentExternalTrackParamPositive << "\t" << currentTrackLabels[0] << endl;
786  const AliExternalTrackParam *fCurrentExternalTrackParamNegative=GetExternalTrackParamN(fCurrentV0,currentTrackLabels[1]);
787  // cout << fCurrentExternalTrackParamNegative << "\t" << currentTrackLabels[1] << endl;
788  if(!fCurrentExternalTrackParamPositive||!fCurrentExternalTrackParamNegative)return 0x0;
789 
790  // Apply some Cuts before Reconstruction
791 
792  AliVTrack * posTrack = fConversionCuts->GetTrack(fInputEvent,currentTrackLabels[0]);
793  AliVTrack * negTrack = fConversionCuts->GetTrack(fInputEvent,currentTrackLabels[1]);
794  if(!negTrack || !posTrack) {
795  fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kNoTracks);
796  return 0x0;
797  }
798  // Track Cuts
799  if(!fConversionCuts->TracksAreSelected(negTrack, posTrack)){
800  fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kTrackCuts);
801  return 0x0;
802  }
803 
804  fConversionCuts->FillV0EtaBeforedEdxCuts(fCurrentV0->Eta());
805  if (!fConversionCuts->dEdxCuts(posTrack)) {
806  fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kdEdxCuts);
807  return 0x0;
808  }
809  // PID Cuts
810  if(!fConversionCuts->dEdxCuts(negTrack)) {
811  fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kdEdxCuts);
812  return 0x0;
813  }
814  fConversionCuts->FillV0EtaAfterdEdxCuts(fCurrentV0->Eta());
815  // Reconstruct Photon
816  AliKFConversionPhoton *fCurrentMotherKF=NULL;
817  // fUseConstructGamma = kFALSE;
818  // cout << "construct gamma " << endl;
819  AliKFParticle fCurrentNegativeKFParticle(*(fCurrentExternalTrackParamNegative),11);
820  // cout << fCurrentExternalTrackParamNegative << "\t" << endl;
821  AliKFParticle fCurrentPositiveKFParticle(*(fCurrentExternalTrackParamPositive),-11);
822  // cout << fCurrentExternalTrackParamPositive << "\t" << endl;
823  // cout << currentTrackLabels[0] << "\t" << currentTrackLabels[1] << endl;
824  // cout << "construct gamma " <<fUseConstructGamma << endl;
825 
826  // Reconstruct Gamma
827  if(fUseConstructGamma){
828  fCurrentMotherKF = new AliKFConversionPhoton();
829  fCurrentMotherKF->ConstructGamma(fCurrentNegativeKFParticle,fCurrentPositiveKFParticle);
830  }else{
831  fCurrentMotherKF = new AliKFConversionPhoton(fCurrentNegativeKFParticle,fCurrentPositiveKFParticle);
832  fCurrentMotherKF->SetMassConstraint(0,0.0001);
833  }
834 
835  // Set Track Labels
836 
837  fCurrentMotherKF->SetTrackLabels(currentTrackLabels[0],currentTrackLabels[1]);
838 
839  // Set V0 index
840 
841  fCurrentMotherKF->SetV0Index(currentV0Index);
842 
843  //Set MC Label
844  if(fMCEvent){
845 
846  Int_t labelp=TMath::Abs(fConversionCuts->GetTrack(fInputEvent,fCurrentMotherKF->GetTrackLabelPositive())->GetLabel());
847  Int_t labeln=TMath::Abs(fConversionCuts->GetTrack(fInputEvent,fCurrentMotherKF->GetTrackLabelNegative())->GetLabel());
848 
849 // cout << "rec: " << currentTrackLabels[0] << "\t" << currentTrackLabels[1] << endl;
850 // cout << "recProp: " << fCurrentMotherKF->GetTrackLabelPositive() << "\t" << fCurrentMotherKF->GetTrackLabelNegative() << endl;
851 // cout << "MC: " << labeln << "\t" << labelp << endl;
852 
853  TParticle *fNegativeMCParticle = 0x0;
854  if(labeln>-1) fNegativeMCParticle = fMCEvent->Particle(labeln);
855  TParticle *fPositiveMCParticle = 0x0;
856  if(labelp>-1) fPositiveMCParticle = fMCEvent->Particle(labelp);
857 
858  if(fPositiveMCParticle&&fNegativeMCParticle){
859  fCurrentMotherKF->SetMCLabelPositive(labelp);
860  fCurrentMotherKF->SetMCLabelNegative(labeln);
861  }
862  }
863 
864  // Update Vertex (moved for same eta compared to old)
865  // cout << currentV0Index <<" \t before: \t" << fCurrentMotherKF->GetPx() << "\t" << fCurrentMotherKF->GetPy() << "\t" << fCurrentMotherKF->GetPz() << endl;
866  if(fUseImprovedVertex == kTRUE){
867  AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
868  // cout << "Prim Vtx: " << primaryVertexImproved.GetX() << "\t" << primaryVertexImproved.GetY() << "\t" << primaryVertexImproved.GetZ() << endl;
869  primaryVertexImproved+=*fCurrentMotherKF;
870  fCurrentMotherKF->SetProductionVertex(primaryVertexImproved);
871  }
872  // SetPsiPair
873  Double_t convpos[3]={0,0,0};
874  if (fImprovedPsiPair == 0){
875  Double_t PsiPair=GetPsiPair(fCurrentV0,fCurrentExternalTrackParamPositive,fCurrentExternalTrackParamNegative, convpos);
876  fCurrentMotherKF->SetPsiPair(PsiPair);
877  }
878 
879  // Recalculate ConversionPoint
880  Double_t dca[2]={0,0};
881  if(fUseOwnXYZCalculation){
882  // Double_t convpos[3]={0,0,0};
883  if(!GetConversionPoint(fCurrentExternalTrackParamPositive,fCurrentExternalTrackParamNegative,convpos,dca)){
884  fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kConvPointFail);
885  delete fCurrentMotherKF;
886  fCurrentMotherKF=NULL;
887  return 0x0;
888  }
889 
890  fCurrentMotherKF->SetConversionPoint(convpos);
891  }
892 
893 
894  // SetPsiPair
895  if (fImprovedPsiPair >= 1){
896  // the propagation can be more precise after the precise conversion point calculation
897  Double_t PsiPair=GetPsiPair(fCurrentV0,fCurrentExternalTrackParamPositive,fCurrentExternalTrackParamNegative,convpos);
898  fCurrentMotherKF->SetPsiPair(PsiPair);
899  //cout<<" GetPsiPair::"<<fCurrentMotherKF->GetPsiPair() <<endl;
900  }
901 
902  if(fCurrentMotherKF->GetNDF() > 0.)
903  fCurrentMotherKF->SetChi2perNDF(fCurrentMotherKF->GetChi2()/fCurrentMotherKF->GetNDF()); //->Photon is created before all chi2 relevant changes are performed, set it "by hand"
904 
905 
906  // Set Dilepton Mass (moved down for same eta compared to old)
907  fCurrentMotherKF->SetMass(fCurrentMotherKF->M());
908 
909  // Calculating invariant mass
910  Double_t mass=-99.0, mass_width=-99.0, Pt=-99.0, Pt_width=-99.0;
911  AliKFParticle fCurrentMotherKFForMass(fCurrentNegativeKFParticle,fCurrentPositiveKFParticle);
912  fCurrentMotherKFForMass.GetMass(mass,mass_width);
913  fCurrentMotherKFForMass.GetPt(Pt,Pt_width);
914  fCurrentInvMassPair=mass;
915 
916  // apply possible Kappa cut
917  if (!fConversionCuts->KappaCuts(fCurrentMotherKF,fInputEvent)){
918  fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kdEdxCuts);
919  delete fCurrentMotherKF;
920  fCurrentMotherKF=NULL;
921  return 0x0;
922  }
923 
924  // Apply Photon Cuts
925  if(!fConversionCuts->PhotonCuts(fCurrentMotherKF,fInputEvent)){
926  fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kPhotonCuts);
927  delete fCurrentMotherKF;
928  fCurrentMotherKF=NULL;
929  return 0x0;
930  }
931 
932  // cout << currentV0Index <<" \t after: \t" <<fCurrentMotherKF->GetPx() << "\t" << fCurrentMotherKF->GetPy() << "\t" << fCurrentMotherKF->GetPz() << endl;
933 
934  if(fProduceImpactParamHistograms) FillImpactParamHistograms(posTrack, negTrack, fCurrentV0, fCurrentMotherKF);
935 
936  fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kPhotonOut);
937  return fCurrentMotherKF;
938 }
939 
941 Double_t AliV0ReaderV1::GetPsiPair(const AliESDv0* v0, const AliExternalTrackParam *positiveparam,const AliExternalTrackParam *negativeparam,const Double_t convpos[3]) const {
942  //
943  // Angle between daughter momentum plane and plane
944  //
945 
946  AliExternalTrackParam nt(*negativeparam);
947  AliExternalTrackParam pt(*positiveparam);
948 
949  Float_t magField = fInputEvent->GetMagneticField();
950 
951  Double_t xyz[3] = {0.,0.,0.};
952  if (fImprovedPsiPair==0 ) {
953  v0->GetXYZ(xyz[0],xyz[1],xyz[2]);
954  } else if (fImprovedPsiPair>=1 ) {
955  xyz[0]= convpos[0];
956  xyz[1]= convpos[1];
957  xyz[2]= convpos[2];
958  }
959 
960 
961  // Double_t pPlus[3] = {pt.Px(),pt.Py(),pt.Pz()};
962  // Double_t pMinus[3] = {nt.Px(),nt.Py(),nt.Pz()};
963 
964  // Double_t u[3] = {pPlus[0]+pMinus[0],pPlus[1]+pMinus[1],pPlus[2]+pMinus[2]};
965  // Double_t normu = sqrt( (u[0]*u[0]) + (u[1]*u[1]) + (u[2]*u[2]) );
966 
967  // u[0] = u[0] / normu;
968  // u[1] = u[1] / normu;
969  // u[2] = u[2] / normu;
970 
971  // Double_t normpPlus = sqrt( (pPlus[0]*pPlus[0]) + (pPlus[1]*pPlus[1]) + (pPlus[2]*pPlus[2]) );
972  // Double_t normpMinus = sqrt( (pMinus[0]*pMinus[0]) + (pMinus[1]*pMinus[1]) + (pMinus[2]*pMinus[2]) );
973 
974  // pPlus[0] = pPlus[0] / normpPlus;
975  // pPlus[1] = pPlus[1] / normpPlus;
976  // pPlus[2] = pPlus[2] / normpPlus;
977 
978  // pMinus[0] = pMinus[0] / normpMinus;
979  // pMinus[1] = pMinus[1] / normpMinus;
980  // pMinus[2] = pMinus[2] / normpMinus;
981 
982  // Double_t v[3] = {0,0,0}; // pPlus X pMinus
983  // v[0] = (pPlus[1]*pMinus[2]) - (pPlus[2]*pMinus[1]);
984  // v[1] = (pPlus[2]*pMinus[0]) - (pPlus[0]*pMinus[2]);
985  // v[2] = (pPlus[0]*pMinus[1]) - (pPlus[1]*pMinus[0]);
986 
987  // Double_t w[3] = {0,0,0}; // u X v
988  // w[0] = (u[1]*v[2]) - (u[2]*v[1]);
989  // w[1] = (u[2]*v[0]) - (u[0]*v[2]);
990  // w[2] = (u[0]*v[1]) - (u[1]*v[0]);
991 
992  // Double_t z[3] = {0,0,1};
993  // Double_t wc[3] = {0,0,0}; // u X v
994  // wc[0] = (u[1]*z[2]) - (u[2]*z[1]);
995  // wc[1] = (u[2]*z[0]) - (u[0]*z[2]);
996  // wc[2] = (u[0]*z[1]) - (u[1]*z[0]);
997 
998  // Double_t PhiV = TMath::ACos((w[0]*wc[0]) + (w[1]*wc[1]) + (w[2]*wc[2]));
999  //return TMath::Abs(PhiV);
1000 
1001 
1002  // TVector3 pPlus(pt.Px(),pt.Py(),pt.Pz());
1003  // TVector3 pMinus(nt.Px(),nt.Py(),nt.Pz());
1004 
1005  // TVector3 u = pMinus + pPlus;
1006  // u = u*(1/u.Mag());
1007 
1008  // TVector3 pHPlus = pPlus*(1/pPlus.Mag());
1009  // TVector3 pHMinus = pMinus*(1/pMinus.Mag());
1010 
1011  // TVector3 v = pHPlus.Cross(pHMinus);
1012  // TVector3 w = u.Cross(v);
1013  // TVector3 z(0,0,1);
1014  // TVector3 wc = u.Cross(z);
1015 
1016  // Double_t PhiV = w * wc;
1017 
1018  Double_t mn[3] = {0,0,0};
1019  Double_t mp[3] = {0,0,0};
1020 
1021  v0->GetNPxPyPz(mn[0],mn[1],mn[2]);//reconstructed cartesian momentum components of negative daughter;
1022  v0->GetPPxPyPz(mp[0],mp[1],mp[2]);//reconstructed cartesian momentum components of positive daughter;
1023 
1024  Double_t deltat = 1.;
1025  deltat = TMath::ATan(mp[2]/(TMath::Sqrt(mp[0]*mp[0] + mp[1]*mp[1])+1.e-13)) - TMath::ATan(mn[2]/(TMath::Sqrt(mn[0]*mn[0] + mn[1]*mn[1])+1.e-13));//difference of angles of the two daughter tracks with z-axis
1026  Double_t radiussum = TMath::Sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]) + 50;//radius to which tracks shall be propagated
1027 
1028  Double_t momPosProp[3] = {0,0,0};
1029  Double_t momNegProp[3] = {0,0,0};
1030 
1031  Double_t psiPair = 4.;
1032  // cout<< "Momentum before propagation at radius ::"<< TMath::Sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1])<< endl;
1033  // cout<< mn[0]<< " " <<mn[1]<<" "<< mn[2]<<" "<<TMath::Sqrt(mn[0]*mn[0] + mn[1]*mn[1] +mn[2]*mn[2])<< endl;
1034  // cout<< mp[0]<< " " <<mp[1]<<" "<< mp[2]<<" "<<TMath::Sqrt(mp[0]*mp[0] + mp[1]*mp[1] +mp[2]*mp[2])<< endl;
1035  Double_t pEle,pPos;
1036 
1037  if (fImprovedPsiPair==1 || fImprovedPsiPair==0 ){
1038  if(nt.PropagateTo(radiussum,magField) == 0) return psiPair; //propagate tracks to the outside -> Better Purity and Efficiency
1039  if(pt.PropagateTo(radiussum,magField) == 0) return psiPair; //propagate tracks to the outside -> Better Purity and Efficiency
1040 
1041  pt.GetPxPyPz(momPosProp);//Get momentum vectors of tracks after propagation
1042  nt.GetPxPyPz(momNegProp);
1043  } else if (fImprovedPsiPair>=2) {
1044  momPosProp[0] = pt.GetParameterAtRadius(radiussum,magField,3);
1045  momPosProp[1] = pt.GetParameterAtRadius(radiussum,magField,4);
1046  momPosProp[2] = pt.GetParameterAtRadius(radiussum,magField,5);
1047 
1048  momNegProp[0] = nt.GetParameterAtRadius(radiussum,magField,3);
1049  momNegProp[1] = nt.GetParameterAtRadius(radiussum,magField,4);
1050  momNegProp[2] = nt.GetParameterAtRadius(radiussum,magField,5);
1051  pEle = TMath::Sqrt(momNegProp[0]*momNegProp[0]+momNegProp[1]*momNegProp[1]+momNegProp[2]*momNegProp[2]);//absolute momentum value of negative daughter
1052 
1053  pPos = TMath::Sqrt(momPosProp[0]*momPosProp[0]+momPosProp[1]*momPosProp[1]+momPosProp[2]*momPosProp[2]);//absolute momentum value of positive daughter
1054 
1055  if ( (pEle==0 || pPos==0) && fImprovedPsiPair==3) {
1056  radiussum = TMath::Sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]) + 30;
1057  momPosProp[0] = pt.GetParameterAtRadius(radiussum,magField,3);
1058  momPosProp[1] = pt.GetParameterAtRadius(radiussum,magField,4);
1059  momPosProp[2] = pt.GetParameterAtRadius(radiussum,magField,5);
1060 
1061  momNegProp[0] = nt.GetParameterAtRadius(radiussum,magField,3);
1062  momNegProp[1] = nt.GetParameterAtRadius(radiussum,magField,4);
1063  momNegProp[2] = nt.GetParameterAtRadius(radiussum,magField,5);
1064 
1065  }
1066  }
1067 
1068  pEle = TMath::Sqrt(momNegProp[0]*momNegProp[0]+momNegProp[1]*momNegProp[1]+momNegProp[2]*momNegProp[2]);//absolute momentum value of negative daughter
1069  pPos = TMath::Sqrt(momPosProp[0]*momPosProp[0]+momPosProp[1]*momPosProp[1]+momPosProp[2]*momPosProp[2]);//absolute momentum value of positive daughter
1070 
1071  Double_t scalarproduct =
1072  momPosProp[0]*momNegProp[0]+momPosProp[1]*momNegProp[1]+momPosProp[2]*momNegProp[2];//scalar product of propagated positive and negative daughters' momenta
1073 
1074  if (pEle==0 || pPos==0) return psiPair;
1075 
1076 
1077  Double_t chipair = TMath::ACos(scalarproduct/(pEle*pPos));//Angle between propagated daughter tracks
1078 
1079  // psiPair = TMath::Abs(TMath::ASin(deltat/chipair));
1080  psiPair = TMath::ASin(deltat/chipair);
1081  return psiPair;
1082 }
1083 
1085 Bool_t AliV0ReaderV1::GetHelixCenter(const AliExternalTrackParam *track,Double_t center[2]){
1086 
1087  // Get Center of the helix track parametrization
1088 
1089  Int_t charge=track->Charge();
1090  Double_t b=fInputEvent->GetMagneticField();
1091 
1092  Double_t helix[6];
1093  track->GetHelixParameters(helix,b);
1094 
1095  Double_t xpos = helix[5];
1096  Double_t ypos = helix[0];
1097  Double_t radius = TMath::Abs(1./helix[4]);
1098  Double_t phi = helix[2];
1099 
1100  if(phi < 0){
1101  phi = phi + 2*TMath::Pi();
1102  }
1103 
1104  phi -= TMath::Pi()/2.;
1105  Double_t xpoint = radius * TMath::Cos(phi);
1106  Double_t ypoint = radius * TMath::Sin(phi);
1107 
1108  if(b<0){
1109  if(charge > 0){
1110  xpoint = - xpoint;
1111  ypoint = - ypoint;
1112  }
1113  }
1114  if(b>0){
1115  if(charge < 0){
1116  xpoint = - xpoint;
1117  ypoint = - ypoint;
1118  }
1119  }
1120  center[0] = xpos + xpoint;
1121  center[1] = ypos + ypoint;
1122 
1123  return 1;
1124 }
1126 Bool_t AliV0ReaderV1::GetConversionPoint(const AliExternalTrackParam *pparam,const AliExternalTrackParam *nparam,Double_t convpos[3],Double_t dca[2]){
1127 
1128  // Recalculate Conversion Point
1129 
1130  if(!pparam||!nparam)return kFALSE;
1131 
1132  Double_t helixcenterpos[2];
1133  GetHelixCenter(pparam,helixcenterpos);
1134 
1135  Double_t helixcenterneg[2];
1136  GetHelixCenter(nparam,helixcenterneg);
1137 
1138  Double_t helixpos[6];
1139  pparam->GetHelixParameters(helixpos,fInputEvent->GetMagneticField());
1140  Double_t posradius = TMath::Abs(1./helixpos[4]);
1141 
1142  Double_t helixneg[6];
1143  nparam->GetHelixParameters(helixneg,fInputEvent->GetMagneticField());
1144  Double_t negradius = TMath::Abs(1./helixneg[4]);
1145 
1146  // Calculate xy-position
1147 
1148  Double_t xpos = helixcenterpos[0];
1149  Double_t ypos = helixcenterpos[1];
1150  Double_t xneg = helixcenterneg[0];
1151  Double_t yneg = helixcenterneg[1];
1152 
1153  convpos[0] = (xpos*negradius + xneg*posradius)/(negradius+posradius);
1154  convpos[1] = (ypos*negradius+ yneg*posradius)/(negradius+posradius);
1155 
1156 
1157  // Calculate Track XY vertex position
1158 
1159  Double_t deltaXPos = convpos[0] - xpos;
1160  Double_t deltaYPos = convpos[1] - ypos;
1161 
1162  Double_t deltaXNeg = convpos[0] - xneg;
1163  Double_t deltaYNeg = convpos[1] - yneg;
1164 
1165  Double_t alphaPos = TMath::Pi() + TMath::ATan2(-deltaYPos,-deltaXPos);
1166  Double_t alphaNeg = TMath::Pi() + TMath::ATan2(-deltaYNeg,-deltaXNeg);
1167 
1168  Double_t vertexXNeg = xneg + TMath::Abs(negradius)*TMath::Cos(alphaNeg);
1169  Double_t vertexYNeg = yneg + TMath::Abs(negradius)*TMath::Sin(alphaNeg);
1170 
1171  Double_t vertexXPos = xpos + TMath::Abs(posradius)*TMath::Cos(alphaPos);
1172  Double_t vertexYPos = ypos + TMath::Abs(posradius)*TMath::Sin(alphaPos);
1173 
1174  AliExternalTrackParam p(*pparam);
1175  AliExternalTrackParam n(*nparam);
1176 
1177  TVector2 vertexPos(vertexXPos,vertexYPos);
1178  TVector2 vertexNeg(vertexXNeg,vertexYNeg);
1179 
1180  // Convert to local coordinate system
1181  TVector2 vertexPosRot=vertexPos.Rotate(-p.GetAlpha());
1182  TVector2 vertexNegRot=vertexNeg.Rotate(-n.GetAlpha());
1183 
1184  // Propagate Track Params to Vertex
1185 
1186  if(!p.PropagateTo(vertexPosRot.X(),fInputEvent->GetMagneticField()))return kFALSE;
1187  if(!n.PropagateTo(vertexNegRot.X(),fInputEvent->GetMagneticField()))return kFALSE;
1188 
1189  // Check whether propagation was sucessful
1190 
1191  if(TMath::Abs(vertexPos.Mod()-TMath::Sqrt(p.GetX()*p.GetX()+p.GetY()*p.GetY()))>0.01)return kFALSE;
1192  if(TMath::Abs(vertexNeg.Mod()-TMath::Sqrt(n.GetX()*n.GetX()+n.GetY()*n.GetY()))>0.01)return kFALSE;
1193 
1194  // Calculate z position
1195 
1196  convpos[2] = (p.GetZ()*negradius+n.GetZ()*posradius)/(negradius+posradius);
1197 
1198  // Calculate DCA
1199  TVector2 vdca=vertexPos-vertexNeg;
1200  dca[0]=vdca.Mod();
1201  dca[1]=TMath::Abs(n.GetZ()-p.GetZ());
1202 
1203  return kTRUE;
1204 }
1205 
1206 //________________________________________________________________________
1208 
1209  // Get reconstructed conversion photons from satellite AOD file
1210 
1211  AliAODEvent *fAODEvent=dynamic_cast<AliAODEvent*>(fInputEvent);
1212 
1213  if(fAODEvent){
1214 
1215  if(fConversionGammas == NULL){
1216  fConversionGammas = new TClonesArray("AliAODConversionPhoton",100);
1217  }
1218  fConversionGammas->Delete();//Reset the TClonesArray
1219 
1220  //Get Gammas from satellite AOD gamma branch
1221 
1222  AliAODConversionPhoton *gamma=0x0;
1223 
1224  TClonesArray *fInputGammas=dynamic_cast<TClonesArray*>(fAODEvent->FindListObject(fDeltaAODBranchName.Data()));
1225 
1226  if(!fInputGammas){
1227  FindDeltaAODBranchName();
1228  fInputGammas=dynamic_cast<TClonesArray*>(fAODEvent->FindListObject(fDeltaAODBranchName.Data()));}
1229  if(!fInputGammas){AliError("No Gamma Satellites found");return kFALSE;}
1230  // Apply Selection Cuts to Gammas and create local working copy
1231  if(fInputGammas){
1232  for(Int_t i=0;i<fInputGammas->GetEntriesFast();i++){
1233  gamma=dynamic_cast<AliAODConversionPhoton*>(fInputGammas->At(i));
1234  if(gamma){
1235  if(fRelabelAODs)RelabelAODPhotonCandidates(gamma);
1236  if(fConversionCuts->PhotonIsSelected(gamma,fInputEvent)){
1237  new((*fConversionGammas)[fConversionGammas->GetEntriesFast()]) AliAODConversionPhoton(*gamma);}
1238  }
1239  }
1240  }
1241  }
1242 
1243  if(fConversionGammas->GetEntries()){return kTRUE;}
1244 
1245  return kFALSE;
1246 }
1247 
1248 //________________________________________________________________________
1250 
1251  // Find delta AOD branchname containing reconstructed photons
1252 
1253  TList *list=fInputEvent->GetList();
1254  for(Int_t ii=0;ii<list->GetEntries();ii++){
1255  TString name((list->At(ii))->GetName());
1256  if(name.BeginsWith(fDeltaAODBranchName)&&name.EndsWith("gamma")){
1257  fDeltaAODBranchName=name;
1258  AliInfo(Form("Set DeltaAOD BranchName to: %s",fDeltaAODBranchName.Data()));
1259  return;
1260  }
1261  }
1262 }
1263 
1264 //________________________________________________________________________
1266 
1267  if(fPreviousV0ReaderPerformsAODRelabeling == 2) return;
1268  else if(fPreviousV0ReaderPerformsAODRelabeling == 0){
1269  printf("Running AODs! Determine if V0Reader '%s' should perform relabeling\n",this->GetName());
1270  TObjArray* obj = (TObjArray*)AliAnalysisManager::GetAnalysisManager()->GetTasks();
1271  Int_t iPosition = obj->IndexOf(this);
1272  Bool_t prevV0ReaderRunningButNotRelabeling = kFALSE;
1273  for(Int_t i=iPosition-1; i>=0; i--){
1274  if( (obj->At(i))->IsA() == AliV0ReaderV1::Class()){
1275  AliV0ReaderV1* tempReader = (AliV0ReaderV1*) obj->At(i);
1276  if( tempReader->AreAODsRelabeled() && tempReader->IsReaderPerformingRelabeling() == 1){
1277  fPreviousV0ReaderPerformsAODRelabeling = 2;
1278  prevV0ReaderRunningButNotRelabeling = kFALSE;
1279  printf("V0Reader '%s' is running before this V0Reader '%s': do _NOT_ relabel AODs by current reader!\n",tempReader->GetName(),this->GetName());
1280  break;
1281  }else prevV0ReaderRunningButNotRelabeling = kTRUE;
1282  }
1283  }
1284  if(prevV0ReaderRunningButNotRelabeling) AliFatal(Form("There are V0Readers before '%s', but none of them is relabeling!",this->GetName()));
1285 
1286  if(fPreviousV0ReaderPerformsAODRelabeling == 2) return;
1287  else{
1288  printf("This V0Reader '%s' is first to be processed: do relabel AODs by current reader!\n",this->GetName());
1289  fPreviousV0ReaderPerformsAODRelabeling = 1;
1290  }
1291  }
1292 
1293  if(fPreviousV0ReaderPerformsAODRelabeling != 1) AliFatal(Form("In %s: fPreviousV0ReaderPerformsAODRelabeling = '%i' - while it should be impossible it is something different than '1'!",this->GetName(),fPreviousV0ReaderPerformsAODRelabeling));
1294 
1295  // Relabeling For AOD Event
1296  // ESDiD -> AODiD
1297  // MCLabel -> AODMCLabel
1298  Bool_t AODLabelPos = kFALSE;
1299  Bool_t AODLabelNeg = kFALSE;
1300 
1301  for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
1302  AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
1303  if(!AODLabelPos){
1304  if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
1305  PhotonCandidate->SetMCLabelPositive(TMath::Abs(tempDaughter->GetLabel()));
1306  PhotonCandidate->SetLabelPositive(i);
1307  AODLabelPos = kTRUE;
1308  }
1309  }
1310  if(!AODLabelNeg){
1311  if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
1312  PhotonCandidate->SetMCLabelNegative(TMath::Abs(tempDaughter->GetLabel()));
1313  PhotonCandidate->SetLabelNegative(i);
1314  AODLabelNeg = kTRUE;
1315  }
1316  }
1317  if(AODLabelNeg && AODLabelPos){
1318  return;
1319  }
1320  }
1321  if(!AODLabelPos || !AODLabelNeg){
1322  AliError(Form("NO AOD Daughters Found Pos: %i %i Neg: %i %i, setting all labels to -999999",AODLabelPos,PhotonCandidate->GetTrackLabelPositive(),AODLabelNeg,PhotonCandidate->GetTrackLabelNegative()));
1323  if(!AODLabelNeg){
1324  PhotonCandidate->SetMCLabelNegative(-999999);
1325  PhotonCandidate->SetLabelNegative(-999999);
1326  }
1327  if(!AODLabelPos){
1328  PhotonCandidate->SetMCLabelPositive(-999999);
1329  PhotonCandidate->SetLabelPositive(-999999);
1330  }
1331  }
1332 
1333 }
1334 
1335 //************************************************************************
1336 // This function counts the number of primary tracks in the event, the
1337 // implementation for ESD and AOD had to be different due to the different
1338 // filters which are already applied on AOD level the so-called filter
1339 // bits, we tried to replicate the conditions in both but an exact match
1340 // could not be reached. The cuts are similar to the ones used by the
1341 // jet-group
1342 //************************************************************************
1343 //________________________________________________________________________
1345 
1346  // In Case of MC count only MB tracks
1347  // if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){
1348  // fEventCuts->GetNotRejectedParticles(1,NULL,fMCEvent);
1349  // }
1350  // if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class()){
1351  // fEventCuts->GetNotRejectedParticles(1,NULL,fInputEvent);
1352  // }
1353 
1354  if(fInputEvent->IsA()==AliESDEvent::Class()){
1355  static AliESDtrackCuts *EsdTrackCuts = 0x0;
1356  static int prevRun = -1;
1357  // Using standard function for setting Cuts
1358  Int_t runNumber = fInputEvent->GetRunNumber();
1359 
1360  if (prevRun!=runNumber) {
1361  delete EsdTrackCuts;
1362  EsdTrackCuts = 0;
1363  prevRun = runNumber;
1364  }
1365  if (!EsdTrackCuts) {
1366  // if LHC11a or earlier or if LHC13g or if LHC12a-i -> use 2010 cuts
1367  if( (runNumber<=146860) || (runNumber>=197470 && runNumber<=197692) || (runNumber>=172440 && runNumber<=193766) ){
1368  EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010();
1369  // else if run2 data use 2015 PbPb cuts
1370  }else if (runNumber>=209122){
1371  EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2015PbPb();
1372  // else use 2011 version of track cuts
1373  }else{
1374  EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011();
1375  }
1376  EsdTrackCuts->SetMaxDCAToVertexZ(2);
1377  EsdTrackCuts->SetEtaRange(-0.8, 0.8);
1378  EsdTrackCuts->SetPtRange(0.15);
1379  }
1380  fNumberOfPrimaryTracks = 0;
1381  for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
1382  AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
1383  if(!curTrack) continue;
1384  if(!EsdTrackCuts->AcceptTrack(curTrack)) continue;
1385  //if(fMCEvent && !(fEventCuts->IsParticleFromBGEvent(TMath::Abs(curTrack->GetLabel()),fMCEvent->Stack(),fInputEvent))) continue;
1386  fNumberOfPrimaryTracks++;
1387  }
1388  }
1389  else if(fInputEvent->IsA()==AliAODEvent::Class()){
1390  fNumberOfPrimaryTracks = 0;
1391  for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
1392  AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
1393  if(curTrack->GetID()<0) continue; // Avoid double counting of tracks
1394  if(!curTrack->IsHybridGlobalConstrainedGlobal()) continue;
1395  if(TMath::Abs(curTrack->Eta())>0.8) continue;
1396  if(curTrack->Pt()<0.15) continue;
1397  //if(fMCEvent && !(fEventCuts->IsParticleFromBGEvent(TMath::Abs(curTrack->GetLabel()),NULL,fInputEvent))) continue;
1398  //if(TMath::Abs(curTrack->ZAtDCA())>2) continue; // Only Set For TPCOnly tracks
1399  fNumberOfPrimaryTracks++;
1400  }
1401  }
1402 
1403  return;
1404 }
1405 
1408  fNumberOfTPCoutTracks = 0;
1409 
1410  for (Int_t itrk = 0; itrk < fInputEvent->GetNumberOfTracks(); itrk++) {
1411  AliVTrack *trk = dynamic_cast<AliVTrack*>(fInputEvent->GetTrack(itrk));
1412 
1413  if (trk != NULL) {
1414  /* the initial method of counting TPC out tracks */
1415  if (!(trk->Pt() < 0.15) && (TMath::Abs(trk->Eta()) < 0.8)) {
1416  if ((trk->GetStatus() & AliVTrack::kTPCout) == AliVTrack::kTPCout) {
1417  fNumberOfTPCoutTracks++;
1418  }
1419  }
1420  }
1421  }
1422 
1423 
1424  return;
1425 }
1426 
1428 Bool_t AliV0ReaderV1::ParticleIsConvertedPhoton(AliMCEvent *mcEvent, TParticle *particle, Double_t etaMax, Double_t rMax, Double_t zMax){
1429  // MonteCarlo Photon Selection
1430  if(!mcEvent)return kFALSE;
1431 
1432  if (particle->GetPdgCode() == 22){
1433  // check whether particle is within eta range
1434  if( TMath::Abs(particle->Eta()) > etaMax ) return kFALSE;
1435  // check if particle doesn't have a photon as mother
1436  if(particle->GetMother(0) >-1 && mcEvent->Particle(particle->GetMother(0))->GetPdgCode() == 22){
1437  return kFALSE; // no photon as mothers!
1438  }
1439  // looking for conversion gammas (electron + positron from pairbuilding (= 5) )
1440  TParticle* ePos = NULL;
1441  TParticle* eNeg = NULL;
1442  if(particle->GetNDaughters() >= 2){
1443  for(Int_t daughterIndex=particle->GetFirstDaughter();daughterIndex<=particle->GetLastDaughter();daughterIndex++){
1444  if(daughterIndex<0) continue;
1445  TParticle *tmpDaughter = mcEvent->Particle(daughterIndex);
1446  if(tmpDaughter->GetUniqueID() == 5){
1447  if(tmpDaughter->GetPdgCode() == 11){
1448  eNeg = tmpDaughter;
1449  } else if(tmpDaughter->GetPdgCode() == -11){
1450  ePos = tmpDaughter;
1451  }
1452  }
1453  }
1454  }
1455  if(ePos == NULL || eNeg == NULL){ // means we do not have two daughters from pair production
1456  return kFALSE;
1457  }
1458  // check if electrons are in correct eta window
1459  if( TMath::Abs(ePos->Eta()) > etaMax ||
1460  TMath::Abs(eNeg->Eta()) > etaMax )
1461  return kFALSE;
1462 
1463  // check if photons have converted in reconstructable range
1464  if(ePos->R() > rMax){
1465  return kFALSE; // cuts on distance from collision point
1466  }
1467  if(TMath::Abs(ePos->Vz()) > zMax){
1468  return kFALSE; // outside material
1469  }
1470  if(TMath::Abs(eNeg->Vz()) > zMax){
1471  return kFALSE; // outside material
1472  }
1473 
1474 
1475  Double_t lineCutZRSlope = tan(2*atan(exp(-etaMax)));
1476  Double_t lineCutZValue = 7.;
1477  if( ePos->R() <= ((TMath::Abs(ePos->Vz()) * lineCutZRSlope) - lineCutZValue)){
1478  return kFALSE; // line cut to exclude regions where we do not reconstruct
1479  }
1480  if( eNeg->R() <= ((TMath::Abs(eNeg->Vz()) * lineCutZRSlope) - lineCutZValue)){
1481  return kFALSE; // line cut to exclude regions where we do not reconstruct
1482  }
1483  if (ePos->Pt() < 0.05 || eNeg->Pt() < 0.05){
1484  return kFALSE;
1485  }
1486 
1487  return kTRUE;
1488  }
1489  return kFALSE;
1490 }
1491 
1494  const AliVVertex* primVtxMC = fMCEvent->GetPrimaryVertex();
1495  Double_t mcProdVtxX = primVtxMC->GetX();
1496  Double_t mcProdVtxY = primVtxMC->GetY();
1497  Double_t mcProdVtxZ = primVtxMC->GetZ();
1498  //cout << mcProdVtxX <<"\t" << mcProdVtxY << "\t" << mcProdVtxZ << endl;
1499 
1500  // Loop over all primary MC particle
1501  for(Long_t i = 0; i < fMCEvent->GetNumberOfTracks(); i++) {
1502  if (fEventCuts->IsConversionPrimaryESD( fMCEvent, i, mcProdVtxX, mcProdVtxY, mcProdVtxZ)){
1503  // fill primary histogram
1504  TParticle* particle = (TParticle *)fMCEvent->Particle(i);
1505  if (!particle) continue;
1506  if (ParticleIsConvertedPhoton(fMCEvent, particle, 0.9, 180.,250. )){
1507  if(particle->GetFirstDaughter()<0) continue;
1508  TParticle *tmpDaughter = fMCEvent->Particle(particle->GetFirstDaughter());
1509  if (!tmpDaughter) continue;
1510  fHistoMCGammaPtvsR->Fill(particle->Pt(),tmpDaughter->R());
1511  fHistoMCGammaPtvsPhi->Fill(particle->Pt(),particle->Phi());
1512  fHistoMCGammaRvsPhi->Fill(tmpDaughter->R(),particle->Phi());
1513  }
1514  if (ParticleIsConvertedPhoton(fMCEvent, particle, 1.4, 180.,250. )){
1515  if(particle->GetFirstDaughter()<0) continue;
1516  TParticle *tmpDaughter = fMCEvent->Particle(particle->GetFirstDaughter());
1517  if (!tmpDaughter) continue;
1518  fHistoMCGammaPtvsEta->Fill(particle->Pt(),particle->Eta());
1519  fHistoMCGammaRvsEta->Fill(tmpDaughter->R(),particle->Eta());
1520  fHistoMCGammaPhivsEta->Fill(particle->Phi(),particle->Eta());
1521  }
1522  }
1523  }
1524 }
1525 
1528 
1529  const AliVVertex* primVtxMC = fMCEvent->GetPrimaryVertex();
1530  Double_t mcProdVtxX = primVtxMC->GetX();
1531  Double_t mcProdVtxY = primVtxMC->GetY();
1532  Double_t mcProdVtxZ = primVtxMC->GetZ();
1533 // cout << mcProdVtxX <<"\t" << mcProdVtxY << "\t" << mcProdVtxZ << endl;
1534 
1535  Int_t tracklabelPos=currentV0->GetPindex();
1536  Int_t tracklabelNeg=currentV0->GetNindex();
1537 
1538  Int_t labelp=TMath::Abs(fConversionCuts->GetTrack(fInputEvent,tracklabelPos)->GetLabel());
1539  Int_t labeln=TMath::Abs(fConversionCuts->GetTrack(fInputEvent,tracklabelNeg)->GetLabel());
1540 
1541  TParticle* negPart = 0x0;
1542  if(labeln>-1) negPart = (TParticle *)fMCEvent->Particle(labeln);
1543  TParticle* posPart = 0x0;
1544  if(labelp>-1) posPart = (TParticle *)fMCEvent->Particle(labelp);
1545 
1546  if ( negPart == NULL || posPart == NULL ) return;
1547 // if (!(negPart->GetPdgCode() == 11)) return;
1548 // if (!(posPart->GetPdgCode() == -11)) return;
1549  Long_t motherlabelNeg = negPart->GetFirstMother();
1550  Long_t motherlabelPos = posPart->GetFirstMother();
1551 
1552 // cout << "mother neg " << motherlabelNeg << " mother pos " << motherlabelPos << endl;
1553  if (motherlabelNeg>-1 && motherlabelNeg == motherlabelPos && negPart->GetFirstMother() != -1){
1554  if (fEventCuts->IsConversionPrimaryESD( fMCEvent, negPart->GetFirstMother(), mcProdVtxX, mcProdVtxY, mcProdVtxZ)){
1555 
1556  TParticle* mother = (TParticle *)fMCEvent->Particle(motherlabelNeg);
1557  if (mother->GetPdgCode() == 22 ){
1558  if (!CheckVectorForDoubleCount(fVectorFoundGammas,motherlabelNeg ) ){
1559  if (ParticleIsConvertedPhoton(fMCEvent, mother, 0.9, 180.,250. )){
1560  fHistoRecMCGammaPtvsR->Fill(mother->Pt(),negPart->R());
1561  fHistoRecMCGammaPtvsPhi->Fill(mother->Pt(),mother->Phi());
1562  fHistoRecMCGammaRvsPhi->Fill(negPart->R(),mother->Phi());
1563  }
1564  if (ParticleIsConvertedPhoton(fMCEvent, mother, 1.4, 180.,250. )){
1565  fHistoRecMCGammaPtvsEta->Fill(mother->Pt(),mother->Eta());
1566  fHistoRecMCGammaRvsEta->Fill(negPart->R(),mother->Eta());
1567  fHistoRecMCGammaPhivsEta->Fill(mother->Phi(),mother->Eta());
1568  }
1569 // cout << "new gamma found" << endl;
1570  } else {
1571  if (ParticleIsConvertedPhoton(fMCEvent, mother, 0.9, 180.,250. )){
1572  fHistoRecMCGammaMultiPt->Fill(mother->Pt());
1573  fHistoRecMCGammaMultiPhi->Fill(mother->Phi());
1574  fHistoRecMCGammaMultiR->Fill(negPart->R());
1575  }
1576  if (ParticleIsConvertedPhoton(fMCEvent, mother, 1.4, 180.,250. )){
1577  fHistoRecMCGammaMultiPtvsEta->Fill(mother->Pt(),mother->Eta());
1578  }
1579 // cout << "this one I had already: " << motherlabelNeg << endl << "-----------------------" << endl;
1580  }
1581 // cout << "event gammas: " << endl;
1582 // for(Int_t iGamma=0; iGamma<fVectorFoundGammas.size(); iGamma++){cout << fVectorFoundGammas.at(iGamma) << ", ";}
1583  }
1584  }
1585  }
1586 }
1587 
1588 //_________________________________________________________________________________
1589 void AliV0ReaderV1::FillImpactParamHistograms( AliVTrack* pTrack, AliVTrack* nTrack, AliESDv0 *fCurrentV0, AliKFConversionPhoton *fCurrentMotherKF){
1590 
1591  // values of cuts to be introduced in 2016 to reduce ESD size
1592  Float_t fZmax = 25; //cm
1593  Float_t fYmax = 25; //cm
1594  Double_t kTPCMargin = 1.0; //cm
1595  Int_t kMaxTPCV0Conflicts = 1; //# conflicting clusters tolerated
1596 
1597  //conversion point
1598  Double_t convX, convY, convZ;
1599  fCurrentV0->GetXYZ(convX,convY,convZ);
1600  Double_t convR = TMath::Sqrt(convX*convX+convY*convY);
1601  //recalculated conversion point
1602  Double_t convXrecalc=fCurrentMotherKF->GetConversionX();
1603  Double_t convYrecalc=fCurrentMotherKF->GetConversionY();
1604  Double_t convZrecalc=fCurrentMotherKF->GetConversionZ();
1605  Double_t convRrecalc = fCurrentMotherKF->GetConversionRadius();
1606 
1607  //count V0s
1608  fHistoImpactParameterStudy->Fill(0);
1609 
1610  //count V0s with two TPC-only tracks
1611  AliESDtrack* positiveTrack = (AliESDtrack*) pTrack;
1612  AliESDtrack* negativeTrack = (AliESDtrack*) nTrack;
1613  Bool_t TPConly = kFALSE;
1614  if (!positiveTrack->IsOn(AliESDtrack::kITSin) && !negativeTrack->IsOn(AliESDtrack::kITSin)){
1615  fHistoImpactParameterStudy->Fill(1);
1616  TPConly = kTRUE;
1617  }
1618 
1619  Bool_t RemovedByZcut = kFALSE;
1620  Bool_t RemovedByYcut = kFALSE;
1621 
1622  //count V0s which have...
1623  if(TPConly){
1624  //not passed z cut: pos.tr. or neg.tr.
1625  if(((TMath::Abs(positiveTrack->GetZ()))>fZmax) || ((TMath::Abs(negativeTrack->GetZ()))>fZmax)){
1626  fHistoImpactParameterStudy->Fill(2);
1627  RemovedByZcut=kTRUE;
1628  }
1629 
1630  //not passed y cut: pos.tr. or neg.tr.
1631  if(((TMath::Abs(positiveTrack->GetY()))>fYmax) || ((TMath::Abs(negativeTrack->GetY()))>fYmax)){
1632  fHistoImpactParameterStudy->Fill(3);
1633  RemovedByYcut=kTRUE;
1634  }
1635  }
1636 
1637  //causality cut
1638  Bool_t RemovedByCausality=kFALSE;
1639  AliESDEvent *fESDEvent=dynamic_cast<AliESDEvent*>(fInputEvent);
1640  const Float_t rTPC[159]={
1641  85.225, 85.975, 86.725, 87.475, 88.225, 88.975, 89.725, 90.475, 91.225, 91.975, 92.725, 93.475, 94.225, 94.975, 95.725,
1642  96.475, 97.225, 97.975, 98.725, 99.475,100.225,100.975,101.725,102.475,103.225,103.975,104.725,105.475,106.225,106.975,
1643  107.725,108.475,109.225,109.975,110.725,111.475,112.225,112.975,113.725,114.475,115.225,115.975,116.725,117.475,118.225,
1644  118.975,119.725,120.475,121.225,121.975,122.725,123.475,124.225,124.975,125.725,126.475,127.225,127.975,128.725,129.475,
1645  130.225,130.975,131.725,135.100,136.100,137.100,138.100,139.100,140.100,141.100,142.100,143.100,144.100,145.100,146.100,
1646  147.100,148.100,149.100,150.100,151.100,152.100,153.100,154.100,155.100,156.100,157.100,158.100,159.100,160.100,161.100,
1647  162.100,163.100,164.100,165.100,166.100,167.100,168.100,169.100,170.100,171.100,172.100,173.100,174.100,175.100,176.100,
1648  177.100,178.100,179.100,180.100,181.100,182.100,183.100,184.100,185.100,186.100,187.100,188.100,189.100,190.100,191.100,
1649  192.100,193.100,194.100,195.100,196.100,197.100,198.100,199.350,200.850,202.350,203.850,205.350,206.850,208.350,209.850,
1650  211.350,212.850,214.350,215.850,217.350,218.850,220.350,221.850,223.350,224.850,226.350,227.850,229.350,230.850,232.350,
1651  233.850,235.350,236.850,238.350,239.850,241.350,242.850,244.350,245.850};
1652 
1653  // fill conversion radius histograms
1654  fHistoR->Fill(convR);
1655  fHistoRrecalc->Fill(convRrecalc);
1656  Double_t alpha = TMath::ATan2(convY,convX);
1657  if (alpha<0) alpha += TMath::Pi()*2;
1658  Int_t sec = alpha/(TMath::Pi()/9);
1659  alpha = (10.+sec*20.)*TMath::DegToRad();
1660  Double_t cs = TMath::Cos(alpha);
1661  Double_t sn = TMath::Sin(alpha);
1662  Double_t xsV0 = convX*cs - convY*sn;
1663  fHistoRviaAlpha->Fill(xsV0);
1664  Double_t alpha_r = TMath::ATan2(convYrecalc,convXrecalc);
1665  if (alpha_r<0) alpha_r += TMath::Pi()*2;
1666  Int_t sec_r = alpha_r/(TMath::Pi()/9);
1667  alpha_r = (10.+sec_r*20.)*TMath::DegToRad();
1668  Double_t cs_r = TMath::Cos(alpha_r);
1669  Double_t sn_r = TMath::Sin(alpha_r);
1670  Double_t xsV0_r = convXrecalc*cs_r - convYrecalc*sn_r;
1671  fHistoRviaAlphaRecalc->Fill(xsV0_r);
1672 
1673  if (convR > 80) { // conversion within TPC <-> TPC-only tracks
1674  fHistoImpactParameterStudy->Fill(4);
1675 
1676  for (Int_t it=2;it--;) {
1677  Int_t trId = fCurrentV0->GetIndex(it);
1678  AliESDtrack* tr = fESDEvent->GetTrack(trId);
1679  const TBits& bits = tr->GetTPCClusterMap();
1680  Int_t nConflict = 0;
1681  for (Int_t ic=0;ic<159;ic++) {
1682  if (rTPC[ic]>(xsV0-kTPCMargin)) break;
1683  if (bits.TestBitNumber(ic)){
1684  nConflict++;
1685  fHistoRdiff->Fill(xsV0-rTPC[ic]);
1686  }
1687  if (nConflict>kMaxTPCV0Conflicts) {
1688  fHistoImpactParameterStudy->Fill(5);
1689  RemovedByCausality=kTRUE;
1690  break;
1691  }
1692  }
1693  }
1694  }
1695 
1696  //not passed y or z o causality cut:
1697  Bool_t RemovedByAnyCut=kFALSE;
1698  if(RemovedByZcut||RemovedByYcut||RemovedByCausality){
1699  fHistoImpactParameterStudy->Fill(6);
1700  RemovedByAnyCut=kTRUE;
1701  }
1702 
1703  //Fill tree for further analysis
1704  Float_t posZ;
1705  Float_t posY;
1706  Float_t posX;
1707  Float_t posPt;
1708  Float_t negZ;
1709  Float_t negY;
1710  Float_t negX;
1711  Float_t negPt;
1712  Float_t R;
1713  TBranch *Branch_Pt = fImpactParamTree->Branch("posPt",&posPt,"posPt/F");
1714  TBranch *Branch_Y = fImpactParamTree->Branch("posY",&posY,"posY/F");
1715  TBranch *Branch_R = fImpactParamTree->Branch("R",&R,"R/F");
1716  posZ = positiveTrack->GetZ();
1717  posY = positiveTrack->GetY();
1718  posX = positiveTrack->GetX();
1719  posPt = positiveTrack->Pt();
1720  negZ = negativeTrack->GetZ();
1721  negY = negativeTrack->GetY();
1722  negX = negativeTrack->GetX();
1723  negPt = negativeTrack->Pt();
1724  R=convRrecalc;
1725  fImpactParamTree->Fill();
1726 
1727  // fill impact parameter histograms
1728  fHistoPosTrackImpactParamZ->Fill(posZ);
1729  fHistoPosTrackImpactParamY->Fill(posY);
1730  fHistoPosTrackImpactParamX->Fill(posX);
1731  fHistoPosTrackImpactParamZvsPt->Fill(posPt, posZ);
1732  fHistoPosTrackImpactParamYvsPt->Fill(posPt, posY);
1733  fHistoPosTrackImpactParamXvsPt->Fill(posPt, posX);
1734  fHistoNegTrackImpactParamZ->Fill(negZ);
1735  fHistoNegTrackImpactParamY->Fill(negY);
1736  fHistoNegTrackImpactParamX->Fill(negX);
1737  fHistoNegTrackImpactParamZvsPt->Fill(negPt, negZ);
1738  fHistoNegTrackImpactParamYvsPt->Fill(negPt, negY);
1739  fHistoNegTrackImpactParamXvsPt->Fill(negPt, negX);
1740 
1741  // fill comparison histos before / after new cuts
1742  fHistoPt->Fill(positiveTrack->Pt());
1743  fHistoImpactParamZvsR->Fill(convZrecalc,convRrecalc);
1744  //Float_t *DCAzPhoton;
1745  Float_t DCAzPhoton;
1746  //const AliVVertex *PrimVertex = fInputEvent->GetPrimaryVertex();
1747  AliAODConversionPhoton* fCurrentMother=(AliAODConversionPhoton*)fCurrentMotherKF;
1748  //AliAODConversionPhoton *fCurrentMother=dynamic_cast<AliAODConversionPhoton*>(fCurrentMotherKF);
1749  //fCurrentMotherKF->GetDistanceOfClossetApproachToPrimVtx(PrimVertex, DCAzPhoton);
1750  DCAzPhoton = fCurrentMother->GetDCAzToPrimVtx();
1751  fHistoDCAzPhoton->Fill(DCAzPhoton);
1752  if(!RemovedByAnyCut) {
1753  fHistoPt2->Fill(positiveTrack->Pt());
1754  fHistoImpactParamZvsR2->Fill(convZrecalc,convRrecalc);
1755  fHistoDCAzPhoton2->Fill(DCAzPhoton);
1756  }
1757 
1758  return;
1759 }
1760 
1761 //_________________________________________________________________________________
1762 Bool_t AliV0ReaderV1::CheckVectorOnly(vector<Int_t> &vec, Int_t tobechecked)
1763 {
1764  if(tobechecked > -1)
1765  {
1766  vector<Int_t>::iterator it;
1767  it = find (vec.begin(), vec.end(), tobechecked);
1768  if (it != vec.end()) return true;
1769  else return false;
1770  }
1771  return false;
1772 }
1773 
1774 //_________________________________________________________________________________
1776 {
1777  if(tobechecked > -1)
1778  {
1779  vector<Int_t>::iterator it;
1780  it = find (vec.begin(), vec.end(), tobechecked);
1781  if (it != vec.end()) return true;
1782  else{
1783  vec.push_back(tobechecked);
1784  return false;
1785  }
1786  }
1787  return false;
1788 }
1789 
1790 //________________________________________________________________________
1792 {
1793 
1794 }
1795 
1797  std::iterator<std::bidirectional_iterator_tag, AliConversionPhotonBase>(),
1798  fkData(reader),
1799  fCurrentIndex(position),
1800  fDirection(dir)
1801 {
1802 }
1803 
1805  std::iterator<std::bidirectional_iterator_tag, AliConversionPhotonBase>(other),
1806  fkData(other.fkData),
1807  fCurrentIndex(other.fCurrentIndex),
1808  fDirection(other.fDirection)
1809 {
1810 }
1811 
1813  if(this != &other){
1814  fkData = other.fkData;
1815  fCurrentIndex = other.fCurrentIndex;
1816  fDirection = other.fDirection;
1817  }
1818  return *this;
1819 }
1820 
1822  if(fkData != other.fkData) return true;
1823  return fCurrentIndex != other.fCurrentIndex;
1824 }
1825 
1827  iterator tmp(*this);
1828  operator++();
1829  return tmp;
1830 }
1831 
1834  fCurrentIndex++;
1835  } else {
1836  fCurrentIndex--;
1837  }
1838  return *this;
1839 }
1840 
1842  iterator tmp(*this);
1843  operator--();
1844  return tmp;
1845 }
1846 
1849  fCurrentIndex++;
1850  } else {
1851  fCurrentIndex--;
1852  }
1853  return *this;
1854 }
1855 
1857  return (*fkData)[fCurrentIndex];
1858 }
Int_t IsReaderPerformingRelabeling()
Int_t charge
Direction_t fDirection
Iterator in forward direction.
Definition: AliV0ReaderV1.h:59
void FillAODOutput()
double Double_t
Definition: External.C:58
Bool_t ParticleIsConvertedPhoton(AliMCEvent *mcEvent, TParticle *particle, Double_t etaMax, Double_t rMax, Double_t zMax)
anchored LHC13[d-e] pass 2 - JJ
Definition: External.C:236
void FindDeltaAODBranchName()
void SetConversionPoint(Double_t convpoint[3])
Bool_t CheckVectorForDoubleCount(vector< Int_t > &vec, Int_t tobechecked)
void SetMCLabelNegative(Int_t label)
Bool_t AreAODsRelabeled()
const AliV0ReaderV1 * fkData
V0 reader used to iterate over.
Definition: AliV0ReaderV1.h:57
void CreatePureMCHistosForV0FinderEffiESD()
Double_t mass
TList * list
TDirectory file where lists per trigger are stored in train ouput.
AliConversionPhotonBase * operator*()
Float_t GetDCAzToPrimVtx() const
virtual void Init()
Double_t GetPsiPair(const AliESDv0 *v0, const AliExternalTrackParam *positiveparam, const AliExternalTrackParam *negativeparam, const Double_t convpos[3]) const
void FillRecMCHistosForV0FinderEffiESD(AliESDv0 *currentV0)
Bool_t CheckVectorOnly(vector< Int_t > &vec, Int_t tobechecked)
anchored LHC13g pass 1 - JJ
anchored LHC13g pass 1 - JJ
int fCurrentIndex
Index of the current element.
Definition: AliV0ReaderV1.h:58
int Int_t
Definition: External.C:63
virtual ~AliV0ReaderV1()
Bool_t ProcessEvent(AliVEvent *inputEvent, AliMCEvent *mcEvent=NULL)
float Float_t
Definition: External.C:68
void SetMCLabelPositive(Int_t label)
void ConstructGamma(const AliKFParticle &fCurrentNegativeKFParticle, const AliKFParticle &fCurrentPositiveKFParticle)
void SetInvMassPair(Float_t mass)
iterator(const AliV0ReaderV1 *reader, Direction_t dir, int position)
Bool_t GetHelixCenter(const AliExternalTrackParam *track, Double_t center[2])
void RelabelAODPhotonCandidates(AliAODConversionPhoton *PhotonCandidate)
anchored LHC12[a-h] pass 2 - JJ
void SetChi2perNDF(Float_t chi2)
void CountTPCoutTracks()
anchored LHC13[d-e] pass 2 - GJ
Bool_t Data(TH1F *h, Double_t *rangefit, Bool_t writefit, Double_t &sgn, Double_t &errsgn, Double_t &bkg, Double_t &errbkg, Double_t &sgnf, Double_t &errsgnf, Double_t &sigmafit, Int_t &status)
virtual Bool_t Notify()
iterator & operator=(const iterator &other)
anchored LHC13[d-e] pass 2 - JJ
void SetTrackLabels(Int_t label1, Int_t label2)
anchored LHC11a pass 4 - JJ
virtual void Terminate(Option_t *)
const AliExternalTrackParam * GetExternalTrackParam(AliESDv0 *fCurrentV0, Int_t &tracklabel, Int_t charge)
anchored LHC13g pass 1 - JJ
AliKFConversionPhoton * ReconstructV0(AliESDv0 *fCurrentV0, Int_t currentV0Index)
void SetLabelPositive(Int_t label)
Track labels.
void SetLabelNegative(Int_t label)
bool operator!=(iterator &other) const
TFile * file
TList with histograms for a given trigger.
anchored LHC12[a-h] pass 2 - JJ - additional stat
void SetPsiPair(Float_t PsiPair)
void FillImpactParamHistograms(AliVTrack *ptrack, AliVTrack *ntrack, AliESDv0 *fCurrentV0, AliKFConversionPhoton *fCurrentMotherKF)
AliConversionPhotonBase * operator[](int index) const
Array index operator.
const char Option_t
Definition: External.C:48
anchored LHC11a pass 4 - JJ
Bool_t ProcessESDV0s()
bool Bool_t
Definition: External.C:53
Bool_t GetConversionPoint(const AliExternalTrackParam *pparam, const AliExternalTrackParam *nparam, Double_t convpos[3], Double_t dca[2])
Bool_t GetAODConversionGammas()
void UserCreateOutputObjects()
virtual void UserExec(Option_t *option)
Double_t GetConversionRadius() const
TDirectoryFile * dir