AliPhysics  15d9304 (15d9304)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnaChargedParticles.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: The ALICE Off-line Project. *
5  * Contributors are mentioned in the code where appropriate. *
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 // --- ROOT system ---
17 #include <TH2F.h>
18 #include <TDatabasePDG.h>
19 
20 //---- AliRoot system ----
21 #include "AliAnaChargedParticles.h"
22 #include "AliCaloTrackReader.h"
23 #include "AliAODPWG4Particle.h"
24 #include "AliMCEvent.h"
25 #include "AliFiducialCut.h"
26 #include "AliVTrack.h"
27 #include "AliVParticle.h"
28 #include "AliAODTrack.h"
29 #include "AliAODEvent.h"
30 #include "AliESDEvent.h"
31 
35 
36 //__________________________________________________
38 //__________________________________________________
41 fFillTrackBCHistograms(0), fFillVertexBC0Histograms(0),
42 fFillEtaPhiRegionHistograms(0),
43 fFillTrackMultHistograms(0),
44 fFillTrackDCAHistograms(0),
45 fMomentum(),
46 // Histograms
47 fhNTracks(0), fhSumPtTracks(0),
48 fhPt(0), fhPtNoCut(0),
49 fhPtCutDCA(0), fhPtCutDCABCOK(0),
50 fhPtNotPrimary(), fhPtNotSharedClusterCut(0),
51 fhPhiNeg(0), fhEtaNeg(0),
52 fhPhiPos(0), fhEtaPos(0),
53 fhEtaPhiPos(0), fhEtaPhiNeg(0),
54 fhTrackResolution(0),
55 fhPtVtxOutBC0(0), fhEtaPhiVtxOutBC0(0),
56 fhPtVtxInBC0(0), fhEtaPhiVtxInBC0(0),
57 fhPtSPDRefit(0), fhPtNoSPDRefit(0), fhPtNoSPDNoRefit(0),
58 fhEtaPhiSPDRefitPt02(0), fhEtaPhiNoSPDRefitPt02(0), fhEtaPhiNoSPDNoRefitPt02(0),
59 fhEtaPhiSPDRefitPt3(0), fhEtaPhiNoSPDRefitPt3(0), fhEtaPhiNoSPDNoRefitPt3(0),
60 // TOF
61 fhTOFSignal(0), fhTOFSignalPtCut(0), fhTOFSignalBCOK(0),
62 fhPtTOFSignal(0), fhPtTOFSignalDCACut(0),
63 fhPtTOFSignalVtxOutBC0(0), fhPtTOFSignalVtxInBC0(0),
64 fhPtTOFStatus0(0), fhEtaPhiTOFStatus0(0),
65 fhEtaPhiTOFBC0(0), fhEtaPhiTOFBCPlus(0), fhEtaPhiTOFBCMinus(0),
66 fhEtaPhiTOFBC0PileUpSPD(0),
67 fhEtaPhiTOFBCPlusPileUpSPD(0),
68 fhEtaPhiTOFBCMinusPileUpSPD(0),
69 fhProductionVertexBC(0),
70 fhPtNPileUpSPDVtx(0), fhPtNPileUpTrkVtx(0),
71 fhPtNPileUpSPDVtxBC0(0), fhPtNPileUpTrkVtxBC0(0)
72 {
73  for(Int_t i = 0; i < 7; i++)
74  {
75  fhPtPileUp [i] = 0;
76  fhPtTOFSignalPileUp[i] = 0;
80  }
81 
82  for(Int_t i = 0; i < 3; i++)
83  {
84  fhPtDCA [i] = 0 ;
85 
86  fhPtDCASPDRefit [i] = 0 ;
87  fhPtDCANoSPDRefit [i] = 0 ;
88  fhPtDCANoSPDNoRefit [i] = 0 ;
89 
90  fhPtDCAPileUp [i] = 0 ;
91  fhPtDCATOFBC0 [i] = 0 ;
92  fhPtDCATOFBCOut [i] = 0 ;
93  fhPtDCAPileUpTOFBC0 [i] = 0 ;
94  fhPtDCANoTOFHit [i] = 0 ;
95  fhPtDCAPileUpNoTOFHit [i] = 0 ;
96 
97  fhPtDCAVtxOutBC0 [i] = 0 ;
98  fhPtDCAVtxInBC0 [i] = 0 ;
99  fhPtDCAVtxOutBC0PileUp[i] = 0 ;
100  fhPtDCAVtxInBC0PileUp [i] = 0 ;
101  fhPtDCAVtxOutBC0NoTOFHit[i] = 0 ;
102  fhPtDCAVtxInBC0NoTOFHit [i] = 0 ;
105  }
106 
107  for(Int_t i = 0; i < 18; i++)
108  {
109  for(Int_t j = 0; j < 2; j++)
110  {
111  fhPtPerRegion [i][j] = 0;
112  fhSumPtPerRegion[i][j] = 0;
113  }
114  }
115 
116  // MC
117  for(Int_t imcPart = 0; imcPart < 6; imcPart++)
118  {
119  fhPtMCPart [imcPart] = 0;
120  fhPtMCPrimPart [imcPart] = 0;
121  fhPhiMCPart [imcPart] = 0;
122  fhPhiMCPrimPart[imcPart] = 0;
123  fhEtaMCPart [imcPart] = 0;
124  fhEtaMCPrimPart[imcPart] = 0;
125  }
126 
127  for(Int_t icut = 0; icut < 10; icut++)
128  {
129  fhPtTrackNTracks [icut] = 0;
130  fhPtTrackSumPtTracks[icut] = 0;
131  }
132 
133  //Initialize parameters
134  InitParameters();
135 }
136 
137 //__________________________________________________
139 //__________________________________________________
141 {
142  if ( !GetMC() ) return;
143 
144  Int_t pdg = 0 ;
145  Int_t nprim = GetMC()->GetNumberOfTracks() ;
146 
147  AliVParticle * primary = 0;
148 
149  for(Int_t i=0 ; i < nprim; i++)
150  {
151  if ( !GetReader()->AcceptParticleMCLabel( i ) ) continue ;
152 
153  primary = GetMC()->GetTrack(i) ;
154  if ( !primary )
155  {
156  AliWarning("Primaries pointer not available!!");
157  continue;
158  }
159 
160  if( primary->MCStatusCode() != 1 ) continue;
161 
162  //Int_t charge = (Int_t )TDatabasePDG::Instance()->GetParticle(primary->GetPdgCode())->Charge();
163  // if( TMath::Abs(charge) == 0 ) continue;
164  if(TMath::Abs(primary->Charge()) == 0 ) continue;
165 
166  pdg = TMath::Abs(primary->PdgCode());
167 
168  // Protection against floating point exception
169  if ( primary->E() == TMath::Abs(primary->Pz()) ||
170  (primary->E() - primary->Pz()) < 1e-3 ||
171  (primary->E() + primary->Pz()) < 0 ) continue ;
172 
173  // Charged kinematics
174  primary->Momentum(fMomentum);
175 
176  Int_t mcType = kmcUnknown;
177  if (pdg==211 ) mcType = kmcPion;
178  else if(pdg==2212) mcType = kmcProton;
179  else if(pdg==321 ) mcType = kmcKaon;
180  else if(pdg==11 ) mcType = kmcElectron;
181  else if(pdg==13 ) mcType = kmcMuon;
182 
183  //printf("pdg %d, charge %f, mctype %d\n",pdg, charge, mcType);
184 
185  Float_t ptPrim = fMomentum.Pt();
186  Float_t etaPrim = fMomentum.Eta();
187  Float_t phiPrim = fMomentum.Phi();
188  if(phiPrim < 0) phiPrim+=TMath::TwoPi();
189 
190  Bool_t in = GetFiducialCut()->IsInFiducialCut(etaPrim,phiPrim,kCTS) ;
191 
192  if(in)
193  fhPtMCPrimPart[mcType]->Fill(ptPrim, GetEventWeight());
194 
195  fhEtaMCPrimPart [mcType]->Fill(ptPrim, etaPrim, GetEventWeight());
196  fhPhiMCPrimPart [mcType]->Fill(ptPrim, phiPrim, GetEventWeight());
197  }
198 }
199 
200 //_______________________________________________________
203 //_______________________________________________________
205 {
206  TList * outputContainer = new TList() ;
207  outputContainer->SetName("ChargedParticleHistos") ;
208 
212 
213  Int_t ntofbins = GetHistogramRanges()->GetHistoTimeBins();
216 
220 
224 
226  fhNTracks = new TH2F
227  ("hNTracks",
228  Form("Number of tracks per event with |#eta|<%2.2f",GetReader()->GetTrackMultiplicityEtaCut()),
229  nmultbin,multmin,multmax, nptcuts,0,nptcuts);
230  fhNTracks->SetXTitle("# of tracks");
231  fhNTracks->SetYTitle("#it{p}_{min, T} GeV/#it{c}");
232  for(Int_t icut = 0; icut<nptcuts; icut++)
233  fhNTracks->GetYaxis()->SetBinLabel(icut+1 ,Form("%2.2f", GetReader()->GetTrackMultiplicityPtCut(icut)));
234  outputContainer->Add(fhNTracks);
235 
236  fhSumPtTracks = new TH2F
237  ("hSumPtTracks",
238  Form("#Sigma #it{p}_{T} per event with |#eta|<%2.2f",GetReader()->GetTrackMultiplicityEtaCut()),
239  nsumbin,summin,summax, nptcuts,0,nptcuts);
240  fhSumPtTracks->SetXTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
241  fhSumPtTracks->SetYTitle("#it{p}_{min, T} GeV/#it{c}");
242  for(Int_t icut = 0; icut<nptcuts; icut++)
243  fhSumPtTracks->GetYaxis()->SetBinLabel(icut+1 ,Form("%2.2f", GetReader()->GetTrackMultiplicityPtCut(icut)));
244  outputContainer->Add(fhSumPtTracks);
245 
247  {
248  for(Int_t icut = 0; icut < nptcuts; icut++)
249  {
250  fhPtTrackNTracks[icut] = new TH2F
251  (Form("hPtTrackNTracks_PtCut%d",icut),
252  Form("Number of tracks per event with |#eta|<%2.2f and #it{p}_{T} > %2.2f GeV/#it{c}",
253  GetReader()->GetTrackMultiplicityEtaCut(),GetReader()->GetTrackMultiplicityPtCut(icut)),
254  nptbins,ptmin,ptmax, nmultbin,multmin,multmax);
255  fhPtTrackNTracks[icut]->SetYTitle("# of tracks");
256  fhPtTrackNTracks[icut]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
257  outputContainer->Add(fhPtTrackNTracks[icut]);
258 
259  fhPtTrackSumPtTracks[icut] = new TH2F
260  (Form("hPtTrackSumPtTracks_PtCut%d",icut),
261  Form("#Sigma #it{p}_{T} per event with |#eta|<%2.2f and #it{p}_{T} > %2.2f GeV/#it{c}",
262  GetReader()->GetTrackMultiplicityEtaCut(),GetReader()->GetTrackMultiplicityPtCut(icut)),
263  nptbins,ptmin,ptmax, nsumbin,summin,summax);
264  fhPtTrackSumPtTracks[icut]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
265  fhPtTrackSumPtTracks[icut]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
266  outputContainer->Add(fhPtTrackSumPtTracks[icut]);
267  }
268  }
269 
270  fhPt = new TH1F ("hPt","#it{p}_{T} distribution", nptbins,ptmin,ptmax);
271  fhPt->SetXTitle("#it{p}_{T} (GeV/#it{c})");
272  outputContainer->Add(fhPt);
273 
275  {
276  for(Int_t i = 0; i < 18; i++)
277  {
278  for(Int_t j = 0; j < 2; j++)
279  {
280  fhPtPerRegion[i][j] = new TH1F
281  (Form("hPt_Sector%d_Side%d",i,j),
282  Form("#it{p}_{T} distribution per region (%d,%d)",i,j),
283  nptbins,ptmin,ptmax);
284  fhPtPerRegion[i][j]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
285  outputContainer->Add(fhPtPerRegion[i][j]);
286 
287  fhSumPtPerRegion[i][j] = new TH1F
288  (Form("hSumPt_Sector%d_Side%d",i,j),
289  Form("#Sigma #it{p}_{T} distribution per region (%d,%d)",i,j),
290  nptbins,ptmin,ptmax);
291  fhSumPtPerRegion[i][j]->SetXTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
292  outputContainer->Add(fhSumPtPerRegion[i][j]);
293  }
294  }
295  }
296 
297  fhPtNoCut = new TH1F ("hPtNoCut","#it{p}_{T} distribution, raw tracks", nptbins,ptmin,ptmax);
298  fhPtNoCut->SetXTitle("#it{p}_{T} (GeV/#it{c})");
299  outputContainer->Add(fhPtNoCut);
300 
302  {
303  if(!GetReader()->IsDCACutOn())
304  {
305  fhPtCutDCA = new TH1F ("hPtCutDCA","#it{p}_{T} distribution, cut DCA", nptbins,ptmin,ptmax);
306  fhPtCutDCA->SetXTitle("#it{p}_{T} (GeV/#it{c})");
307  outputContainer->Add(fhPtCutDCA);
308  }
309 
310  if(fFillVertexBC0Histograms && !GetReader()->IsDCACutOn())
311  {
312  fhPtCutDCABCOK = new TH1F ("hPtCutDCABCOK","#it{p}_{T} distribution, DCA cut, track BC=0 or -100", nptbins,ptmin,ptmax);
313  fhPtCutDCABCOK->SetXTitle("#it{p}_{T} (GeV/#it{c})");
314  outputContainer->Add(fhPtCutDCABCOK);
315  }
316  }
317 
318  if( GetReader()->GetDataType() == AliCaloTrackReader::kAOD )
319  {
320  fhPtNotPrimary = new TH1F ("hPtNotPrimary","#it{p}_{T} distribution, not primary", nptbins,ptmin,ptmax);
321  fhPtNotPrimary->SetXTitle("#it{p}_{T} (GeV/#it{c})");
322  outputContainer->Add(fhPtNotPrimary);
323 
324  fhPtNotSharedClusterCut = new TH1F ("hPtNotSharedClusterCut","#it{p}_{T} distribution, shared clusters cut out", nptbins,ptmin,ptmax);
325  fhPtNotSharedClusterCut->SetXTitle("#it{p}_{T} (GeV/#it{c})");
326  outputContainer->Add(fhPtNotSharedClusterCut);
327  }
328 
329  fhPhiNeg = new TH2F ("hPhiNegative","#varphi of negative charges distribution",
330  nptbins,ptmin,ptmax, nphibins,phimin,phimax);
331  fhPhiNeg->SetYTitle("#varphi (rad)");
332  fhPhiNeg->SetXTitle("#it{p}_{T} (GeV/#it{c})");
333  outputContainer->Add(fhPhiNeg);
334 
335  fhEtaNeg = new TH2F ("hEtaNegative","#eta of negative charges distribution",
336  nptbins,ptmin,ptmax, netabins,etamin,etamax);
337  fhEtaNeg->SetYTitle("#eta ");
338  fhEtaNeg->SetXTitle("#it{p}_{T} (GeV/#it{c})");
339  outputContainer->Add(fhEtaNeg);
340 
341  fhPhiPos = new TH2F ("hPhiPositive","#varphi of positive charges distribution",
342  nptbins,ptmin,ptmax, nphibins,phimin,phimax);
343  fhPhiPos->SetYTitle("#varphi (rad)");
344  fhPhiPos->SetXTitle("#it{p}_{T} (GeV/#it{c})");
345  outputContainer->Add(fhPhiPos);
346 
347  fhEtaPos = new TH2F ("hEtaPositive","#eta of positive charges distribution",
348  nptbins,ptmin,ptmax, netabins,etamin,etamax);
349  fhEtaPos->SetYTitle("#eta ");
350  fhEtaPos->SetXTitle("#it{p}_{T} (GeV/#it{c})");
351  outputContainer->Add(fhEtaPos);
352 
353  fhEtaPhiPos = new TH2F ("hEtaPhiPositive","#eta vs #varphi of positive charge",netabins,etamin,etamax, nphibins,phimin,phimax);
354  fhEtaPhiPos->SetXTitle("#eta ");
355  fhEtaPhiPos->SetYTitle("#varphi (rad)");
356  outputContainer->Add(fhEtaPhiPos);
357 
358  fhEtaPhiNeg = new TH2F ("hEtaPhiNegative","#eta vs #varphi of negative charge",netabins,etamin,etamax, nphibins,phimin,phimax);
359  fhEtaPhiNeg->SetXTitle("#eta ");
360  fhEtaPhiNeg->SetYTitle("#varphi (rad)");
361  outputContainer->Add(fhEtaPhiNeg);
362 
363  if( GetReader()->GetDataType() == AliCaloTrackReader::kESD )
364  {
365  fhTrackResolution = new TH2F ("hTrackResolution","Track resolution: #sigma_{#it{p}_{T}} vs #it{p}_{T}, ESDs",
366  nptbins,ptmin,ptmax,600,0,0.3);
367  fhTrackResolution->SetXTitle("#it{p}_{T} (GeV/#it{c})");
368  fhTrackResolution->SetYTitle("#sigma_{#it{p}_{T}} / #it{p}_{T} (GeV/#it{c})");
369  outputContainer->Add(fhTrackResolution);
370  }
371 
373  {
374  fhPtVtxOutBC0 = new TH1F ("hPtVtxOutBC0","#it{p}_{T} distribution, vertex in BC=0", nptbins,ptmin,ptmax);
375  fhPtVtxOutBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
376  outputContainer->Add(fhPtVtxOutBC0);
377 
378  fhEtaPhiVtxOutBC0 = new TH2F ("hEtaPhiVtxOutBC0","#eta vs #varphi of all charges with vertex in BC=0",netabins,etamin,etamax, nphibins,phimin,phimax);
379  fhEtaPhiVtxOutBC0->SetXTitle("#eta ");
380  fhEtaPhiVtxOutBC0->SetYTitle("#varphi (rad)");
381  outputContainer->Add(fhEtaPhiVtxOutBC0);
382 
383  fhPtVtxInBC0 = new TH1F ("hPtVtxInBC0","#it{p}_{T} distribution, vertex in BC=0", nptbins,ptmin,ptmax);
384  fhPtVtxInBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
385  outputContainer->Add(fhPtVtxInBC0);
386 
387  fhEtaPhiVtxInBC0 = new TH2F ("hEtaPhiVtxInBC0","#eta vs #varphi of all charges with vertex in BC=0",netabins,etamin,etamax, nphibins,phimin,phimax);
388  fhEtaPhiVtxInBC0->SetXTitle("#eta ");
389  fhEtaPhiVtxInBC0->SetYTitle("#varphi (rad)");
390  outputContainer->Add(fhEtaPhiVtxInBC0);
391  }
392 
393  fhPtSPDRefit = new TH1F ("hPtSPDRefit","#it{p}_{T} distribution of tracks with SPD and ITS refit", nptbins,ptmin,ptmax);
394  fhPtSPDRefit->SetXTitle("#it{p}_{T} (GeV/#it{c})");
395  outputContainer->Add(fhPtSPDRefit);
396 
397  fhEtaPhiSPDRefitPt02 = new TH2F ("hEtaPhiSPDRefitPt02","#eta vs #varphi of tracks with SPD and ITS refit, #it{p}_{T}< 2 GeV/#it{c}",
398  netabins,etamin,etamax, nphibins,phimin,phimax);
399  fhEtaPhiSPDRefitPt02->SetXTitle("#eta ");
400  fhEtaPhiSPDRefitPt02->SetYTitle("#varphi (rad)");
401  outputContainer->Add(fhEtaPhiSPDRefitPt02);
402 
403  fhEtaPhiSPDRefitPt3 = new TH2F ("hEtaPhiSPDRefitPt3","#eta vs #varphi of tracks with SPD and ITS refit, #it{p}_{T}> 3 GeV/#it{c}",
404  netabins,etamin,etamax, nphibins,phimin,phimax);
405  fhEtaPhiSPDRefitPt3->SetXTitle("#eta ");
406  fhEtaPhiSPDRefitPt3->SetYTitle("#varphi (rad)");
407  outputContainer->Add(fhEtaPhiSPDRefitPt3);
408 
409  fhPtNoSPDRefit = new TH1F ("hPtNoSPDRefit","#it{p}_{T} distribution of constrained tracks no SPD and with ITSRefit",
410  nptbins,ptmin,ptmax);
411  fhPtNoSPDRefit->SetXTitle("#it{p}_{T} (GeV/#it{c})");
412  outputContainer->Add(fhPtNoSPDRefit);
413 
414  fhEtaPhiNoSPDRefitPt02 = new TH2F ("hEtaPhiNoSPDRefitPt02","#eta vs #varphi of constrained tracks no SPD and with ITSRefit, #it{p}_{T}< 2 GeV/#it{c}",
415  netabins,etamin,etamax, nphibins,phimin,phimax);
416  fhEtaPhiNoSPDRefitPt02->SetXTitle("#eta ");
417  fhEtaPhiNoSPDRefitPt02->SetYTitle("#varphi (rad)");
418  outputContainer->Add(fhEtaPhiNoSPDRefitPt02);
419 
420  fhEtaPhiNoSPDRefitPt3 = new TH2F ("hEtaPhiNoSPDRefitPt3","#eta vs #varphi of of constrained tracks no SPD and with ITSRefit, #it{p}_{T}> 3 GeV/#it{c}",
421  netabins,etamin,etamax, nphibins,phimin,phimax);
422  fhEtaPhiNoSPDRefitPt3->SetXTitle("#eta ");
423  fhEtaPhiNoSPDRefitPt3->SetYTitle("#varphi (rad)");
424  outputContainer->Add(fhEtaPhiNoSPDRefitPt3);
425 
426  fhPtNoSPDNoRefit = new TH1F ("hPtNoSPDNoRefit","#it{p}_{T} distribution of constrained tracks with no SPD requierement and without ITSRefit",
427  nptbins,ptmin,ptmax);
428  fhPtNoSPDNoRefit->SetXTitle("#it{p}_{T} (GeV/#it{c})");
429  outputContainer->Add(fhPtNoSPDNoRefit);
430 
431  fhEtaPhiNoSPDNoRefitPt02 = new TH2F ("hEtaPhiNoSPDNoRefitPt02",
432  "#eta vs #varphi of constrained tracks with no SPD requierement and without ITSRefit, #it{p}_{T}< 2 GeV/#it{c}",
433  netabins,etamin,etamax, nphibins,phimin,phimax);
434  fhEtaPhiNoSPDNoRefitPt02->SetXTitle("#eta ");
435  fhEtaPhiNoSPDNoRefitPt02->SetYTitle("#varphi (rad)");
436  outputContainer->Add(fhEtaPhiNoSPDNoRefitPt02);
437 
438  fhEtaPhiNoSPDNoRefitPt3 = new TH2F ("hEtaPhiNoSPDNoRefitPt3",
439  "#eta vs #varphi of constrained tracks with no SPD requierement and without ITSRefit, #it{p}_{T}> 3 GeV/#it{c}",
440  netabins,etamin,etamax, nphibins,phimin,phimax);
441  fhEtaPhiNoSPDNoRefitPt3->SetXTitle("#eta ");
442  fhEtaPhiNoSPDNoRefitPt3->SetYTitle("#varphi (rad)");
443  outputContainer->Add(fhEtaPhiNoSPDNoRefitPt3);
444 
446  {
447  fhProductionVertexBC = new TH1F("hProductionVertexBC", "tracks production vertex bunch crossing ", 41 , -20 , 20 ) ;
448  fhProductionVertexBC->SetYTitle("# tracks");
449  fhProductionVertexBC->SetXTitle("Bunch crossing");
450  outputContainer->Add(fhProductionVertexBC);
451  }
452 
453  fhTOFSignal = new TH1F ("hTOFSignal","TOF signal", ntofbins,mintof,maxtof);
454  fhTOFSignal->SetXTitle("TOF signal (ns)");
455  outputContainer->Add(fhTOFSignal);
456 
458  {
459  fhTOFSignalBCOK = new TH1F ("hTOFSignalBCOK","TOF signal", ntofbins,mintof,maxtof);
460  fhTOFSignalBCOK->SetXTitle("TOF signal (ns)");
461  outputContainer->Add(fhTOFSignalBCOK);
462  }
463 
464  fhTOFSignalPtCut = new TH1F ("hTOFSignalPtCut","TOF signal", ntofbins,mintof,maxtof);
465  fhTOFSignalPtCut->SetXTitle("TOF signal (ns)");
466  outputContainer->Add(fhTOFSignalPtCut);
467 
468  fhPtTOFSignal = new TH2F ("hPtTOFSignal","TOF signal", nptbins,ptmin,ptmax,ntofbins,mintof,maxtof);
469  fhPtTOFSignal->SetYTitle("TOF signal (ns)");
470  fhPtTOFSignal->SetXTitle("#it{p}_{T} (GeV/#it{c})");
471  outputContainer->Add(fhPtTOFSignal);
472 
473  if(!GetReader()->IsDCACutOn() && fFillTrackDCAHistograms)
474  {
475  fhPtTOFSignalDCACut = new TH2F ("hPtTOFSignalDCACut","TOF signal after DCA cut", nptbins,ptmin,ptmax,ntofbins,mintof,maxtof);
476  fhPtTOFSignalDCACut->SetYTitle("TOF signal (ns)");
477  fhPtTOFSignalDCACut->SetXTitle("#it{p}_{T} (GeV/#it{c})");
478  outputContainer->Add(fhPtTOFSignalDCACut);
479  }
480 
482  {
483  fhPtTOFSignalVtxOutBC0 = new TH2F ("hPtTOFSignalVtxOutBC0","TOF signal, vtx BC!=0", nptbins,ptmin,ptmax,ntofbins,mintof,maxtof);
484  fhPtTOFSignalVtxOutBC0->SetYTitle("TOF signal (ns)");
485  fhPtTOFSignalVtxOutBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
486  outputContainer->Add(fhPtTOFSignalVtxOutBC0);
487 
488  fhPtTOFSignalVtxInBC0 = new TH2F ("hPtTOFSignalVtxInBC0","TOF signal, vtx BC=0", nptbins,ptmin,ptmax,ntofbins,mintof,maxtof);
489  fhPtTOFSignalVtxInBC0->SetYTitle("TOF signal (ns)");
490  fhPtTOFSignalVtxInBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
491  outputContainer->Add(fhPtTOFSignalVtxInBC0);
492  }
493 
494  if(IsPileUpAnalysisOn())
495  {
496  TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ;
497 
498  for(Int_t i = 0 ; i < 7 ; i++)
499  {
500  fhPtPileUp[i] = new TH1F(Form("hPtPileUp%s",pileUpName[i].Data()),
501  Form("Track #it{p}_{T}distribution, %s Pile-Up event",pileUpName[i].Data()),
502  nptbins,ptmin,ptmax);
503  fhPtPileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
504  outputContainer->Add(fhPtPileUp[i]);
505 
506  fhPtTOFSignalPileUp[i] = new TH2F(Form("hPtTOFSignalPileUp%s",pileUpName[i].Data()),
507  Form("Track TOF vs #it{p}_{T}distribution, %s Pile-Up event",pileUpName[i].Data()),
508  nptbins,ptmin,ptmax,ntofbins,mintof,maxtof);
509  fhPtTOFSignalPileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
510  fhPtTOFSignalPileUp[i]->SetXTitle("TOF signal (ns)");
511  outputContainer->Add(fhPtTOFSignalPileUp[i]);
512 
514  {
515  fhPtTOFSignalVtxOutBC0PileUp[i] = new TH2F(Form("hPtTOFSignalVtxOutBC0PileUp%s",pileUpName[i].Data()),
516  Form("Track TOF vs #it{p}_{T}distribution, %s Pile-Up event, vtx BC!=0",pileUpName[i].Data()),
517  nptbins,ptmin,ptmax,ntofbins,mintof,maxtof);
518  fhPtTOFSignalVtxOutBC0PileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
519  fhPtTOFSignalVtxOutBC0PileUp[i]->SetXTitle("TOF signal (ns)");
520  outputContainer->Add(fhPtTOFSignalVtxOutBC0PileUp[i]);
521 
522  fhPtTOFSignalVtxInBC0PileUp[i] = new TH2F(Form("hPtTOFSignalVtxInBC0PileUp%s",pileUpName[i].Data()),
523  Form("Track TOF vs #it{p}_{T}distribution, %s Pile-Up event, vtx BC=0",pileUpName[i].Data()),
524  nptbins,ptmin,ptmax,ntofbins,mintof,maxtof);
525  fhPtTOFSignalVtxInBC0PileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
526  fhPtTOFSignalVtxInBC0PileUp[i]->SetXTitle("TOF signal (ns)");
527  outputContainer->Add(fhPtTOFSignalVtxInBC0PileUp[i]);
528  }
529 
531  {
532  fhProductionVertexBCPileUp[i] = new TH1F(Form("hProductionVertexBCPileUp%s",pileUpName[i].Data()),
533  Form("tracks production vertex bunch crossing, %s Pile-Up event",pileUpName[i].Data()),
534  41 , -20 , 20 ) ;
535  fhProductionVertexBCPileUp[i]->SetYTitle("# tracks");
536  fhProductionVertexBCPileUp[i]->SetXTitle("Bunch crossing");
537  outputContainer->Add(fhProductionVertexBCPileUp[i]);
538  }
539  }
540 
542  {
543  fhEtaPhiTOFBC0 = new TH2F ("hEtaPhiTOFBC0","#eta vs #varphi for tracks with hit on TOF, and tof corresponding to BC=0",netabins,etamin,etamax, nphibins,phimin,phimax);
544  fhEtaPhiTOFBC0->SetXTitle("#eta ");
545  fhEtaPhiTOFBC0->SetYTitle("#varphi (rad)");
546  outputContainer->Add(fhEtaPhiTOFBC0);
547 
548  fhEtaPhiTOFBCPlus = new TH2F ("hEtaPhiTOFBCPlus","#eta vs #varphi for tracks with hit on TOF, and tof corresponding to BC>0",netabins,etamin,etamax, nphibins,phimin,phimax);
549  fhEtaPhiTOFBCPlus->SetXTitle("#eta ");
550  fhEtaPhiTOFBCPlus->SetYTitle("#varphi (rad)");
551  outputContainer->Add(fhEtaPhiTOFBCPlus);
552 
553  fhEtaPhiTOFBCMinus = new TH2F ("hEtaPhiTOFBCMinus","#eta vs #varphi for tracks with hit on TOF, and tof corresponding to BC<0",netabins,etamin,etamax, nphibins,phimin,phimax);
554  fhEtaPhiTOFBCMinus->SetXTitle("#eta ");
555  fhEtaPhiTOFBCMinus->SetYTitle("#varphi (rad)");
556  outputContainer->Add(fhEtaPhiTOFBCMinus);
557 
558  if(IsPileUpAnalysisOn())
559  {
560  fhEtaPhiTOFBC0PileUpSPD = new TH2F ("hEtaPhiTOFBC0PileUpSPD","#eta vs #varphi for tracks with hit on TOF, and tof corresponding to BC=0, SPD pile-up",netabins,etamin,etamax, nphibins,phimin,phimax);
561  fhEtaPhiTOFBC0PileUpSPD->SetXTitle("#eta ");
562  fhEtaPhiTOFBC0PileUpSPD->SetYTitle("#varphi (rad)");
563  outputContainer->Add(fhEtaPhiTOFBC0PileUpSPD);
564 
565  fhEtaPhiTOFBCPlusPileUpSPD = new TH2F ("hEtaPhiTOFBCPlusPileUpSPD","#eta vs #varphi for tracks with hit on TOF, and tof corresponding to BC>0, SPD pile-up",netabins,etamin,etamax, nphibins,phimin,phimax);
566  fhEtaPhiTOFBCPlusPileUpSPD->SetXTitle("#eta ");
567  fhEtaPhiTOFBCPlusPileUpSPD->SetYTitle("#varphi (rad)");
568  outputContainer->Add(fhEtaPhiTOFBCPlusPileUpSPD);
569 
570  fhEtaPhiTOFBCMinusPileUpSPD = new TH2F ("hEtaPhiTOFBCMinusPileUpSPD","#eta vs #varphi for tracks with hit on TOF, and tof corresponding to BC<0, SPD pile-up",netabins,etamin,etamax, nphibins,phimin,phimax);
571  fhEtaPhiTOFBCMinusPileUpSPD->SetXTitle("#eta ");
572  fhEtaPhiTOFBCMinusPileUpSPD->SetYTitle("#varphi (rad)");
573  outputContainer->Add(fhEtaPhiTOFBCMinusPileUpSPD);
574  }
575  }
576  }
577 
578  fhPtTOFStatus0 = new TH1F ("hPtTOFStatus0","#it{p}_{T} distribution of tracks not hitting TOF", nptbins,ptmin,ptmax);
579  fhPtTOFStatus0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
580  outputContainer->Add(fhPtTOFStatus0);
581 
582  fhEtaPhiTOFStatus0 = new TH2F ("hEtaPhiTOFStatus0","#eta vs #varphi for tracks without hit on TOF",netabins,etamin,etamax, nphibins,phimin,phimax);
583  fhEtaPhiTOFStatus0->SetXTitle("#eta ");
584  fhEtaPhiTOFStatus0->SetYTitle("#varphi (rad)");
585  outputContainer->Add(fhEtaPhiTOFStatus0);
586 
587  TString dcaName[] = {"xy","z","Cons"} ;
588  Int_t ndcabins = 800;
589  Int_t mindca = -4;
590  Int_t maxdca = 4;
591 
593  {
594  for(Int_t i = 0 ; i < 3 ; i++)
595  {
596  fhPtDCA[i] = new TH2F(Form("hPtDCA%s",dcaName[i].Data()),
597  Form("Track DCA%s vs #it{p}_{T}distribution",dcaName[i].Data()),
598  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
599  fhPtDCA[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
600  fhPtDCA[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
601  outputContainer->Add(fhPtDCA[i]);
602 
603  fhPtDCASPDRefit[i] = new TH2F(Form("hPtDCA%sSPDRefit",dcaName[i].Data()),
604  Form("Track DCA%s vs #it{p}_{T}distribution of tracks with SPD and ITS refit",dcaName[i].Data()),
605  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
606  fhPtDCASPDRefit[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
607  fhPtDCASPDRefit[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
608  outputContainer->Add(fhPtDCASPDRefit[i]);
609 
610  fhPtDCANoSPDRefit[i] = new TH2F(Form("hPtDCA%sNoSPDRefit",dcaName[i].Data()),
611  Form("Track DCA%s vs #it{p}_{T}distributionof constrained tracks no SPD and with ITSRefit",dcaName[i].Data()),
612  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
613  fhPtDCANoSPDRefit[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
614  fhPtDCANoSPDRefit[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
615  outputContainer->Add(fhPtDCANoSPDRefit[i]);
616 
617  fhPtDCANoSPDNoRefit[i] = new TH2F(Form("hPtDCA%sNoSPDNoRefit",dcaName[i].Data()),
618  Form("Track DCA%s vs #it{p}_{T}distribution, constrained tracks with no SPD requierement and without ITSRefit",dcaName[i].Data()),
619  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
620  fhPtDCANoSPDNoRefit[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
621  fhPtDCANoSPDNoRefit[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
622  outputContainer->Add(fhPtDCANoSPDNoRefit[i]);
623 
625  {
626  fhPtDCATOFBC0[i] = new TH2F(Form("hPtDCA%sTOFBC0",dcaName[i].Data()),
627  Form("Track DCA%s vs #it{p}_{T}distribution, BC=0",dcaName[i].Data()),
628  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
629  fhPtDCATOFBC0[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
630  fhPtDCATOFBC0[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
631  outputContainer->Add(fhPtDCATOFBC0[i]);
632 
633  fhPtDCATOFBCOut[i] = new TH2F(Form("hPtDCA%sTOFBCOut",dcaName[i].Data()),
634  Form("Track DCA%s vs #it{p}_{T}distribution, BC!=0",dcaName[i].Data()),
635  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
636  fhPtDCATOFBCOut[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
637  fhPtDCATOFBCOut[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
638  outputContainer->Add(fhPtDCATOFBCOut[i]);
639  }
640 
641  fhPtDCANoTOFHit[i] = new TH2F(Form("hPtDCA%sNoTOFHit",dcaName[i].Data()),
642  Form("Track (no TOF hit) DCA%s vs #it{p}_{T}distribution",dcaName[i].Data()),
643  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
644  fhPtDCANoTOFHit[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
645  fhPtDCANoTOFHit[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
646  outputContainer->Add(fhPtDCANoTOFHit[i]);
647 
649  {
650  fhPtDCAVtxOutBC0[i] = new TH2F(Form("hPtDCA%sVtxOutBC0",dcaName[i].Data()),
651  Form("Track DCA%s vs #it{p}_{T}distribution, vertex with BC!=0",dcaName[i].Data()),
652  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
653  fhPtDCAVtxOutBC0[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
654  fhPtDCAVtxOutBC0[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
655  outputContainer->Add(fhPtDCAVtxOutBC0[i]);
656 
657  fhPtDCAVtxOutBC0NoTOFHit[i] = new TH2F(Form("hPtDCA%sVtxOutBC0NoTOFHit",dcaName[i].Data()),
658  Form("Track (no TOF hit) DCA%s vs #it{p}_{T}distribution, vertex with BC!=0",dcaName[i].Data()),
659  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
660  fhPtDCAVtxOutBC0NoTOFHit[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
661  fhPtDCAVtxOutBC0NoTOFHit[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
662  outputContainer->Add(fhPtDCAVtxOutBC0NoTOFHit[i]);
663 
664  fhPtDCAVtxInBC0[i] = new TH2F(Form("hPtDCA%sVtxInBC0",dcaName[i].Data()),
665  Form("Track DCA%s vs #it{p}_{T}distribution, vertex with BC==0",dcaName[i].Data()),
666  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
667  fhPtDCAVtxInBC0[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
668  fhPtDCAVtxInBC0[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
669  outputContainer->Add(fhPtDCAVtxInBC0[i]);
670 
671  fhPtDCAVtxInBC0NoTOFHit[i] = new TH2F(Form("hPtDCA%sVtxInBC0NoTOFHit",dcaName[i].Data()),
672  Form("Track (no TOF hit) DCA%s vs #it{p}_{T}distribution, vertex with BC==0",dcaName[i].Data()),
673  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
674  fhPtDCAVtxInBC0NoTOFHit[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
675  fhPtDCAVtxInBC0NoTOFHit[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
676  outputContainer->Add(fhPtDCAVtxInBC0NoTOFHit[i]);
677  }
678 
679  if(IsPileUpAnalysisOn())
680  {
681  fhPtDCAPileUp[i] = new TH2F(Form("hPtDCA%sPileUp",dcaName[i].Data()),
682  Form("Track DCA%s vs #it{p}_{T}distribution, SPD Pile-Up",dcaName[i].Data()),
683  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
684  fhPtDCAPileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
685  fhPtDCAPileUp[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
686  outputContainer->Add(fhPtDCAPileUp[i]);
687 
689  {
690  fhPtDCAPileUpTOFBC0[i] = new TH2F(Form("hPtDCA%sPileUpTOFBC0",dcaName[i].Data()),
691  Form("Track DCA%s vs #it{p}_{T}distribution",dcaName[i].Data()),
692  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
693  fhPtDCAPileUpTOFBC0[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
694  fhPtDCAPileUpTOFBC0[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
695  outputContainer->Add(fhPtDCAPileUpTOFBC0[i]);
696  }
697 
698  fhPtDCAPileUpNoTOFHit[i] = new TH2F(Form("hPtDCA%sPileUpNoTOFHit",dcaName[i].Data()),
699  Form("Track (no TOF hit) DCA%s vs #it{p}_{T}distribution, SPD Pile-Up, vertex with BC!=0",dcaName[i].Data()),
700  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
701  fhPtDCAPileUpNoTOFHit[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
702  fhPtDCAPileUpNoTOFHit[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
703  outputContainer->Add(fhPtDCAPileUpNoTOFHit[i]);
704 
706  {
707  fhPtDCAVtxOutBC0PileUp[i] = new TH2F(Form("hPtDCA%sPileUpVtxOutBC0",dcaName[i].Data()),
708  Form("Track DCA%s vs #it{p}_{T}distribution, SPD Pile-Up, vertex with BC!=0",dcaName[i].Data()),
709  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
710  fhPtDCAVtxOutBC0PileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
711  fhPtDCAVtxOutBC0PileUp[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
712  outputContainer->Add(fhPtDCAVtxOutBC0PileUp[i]);
713 
714  fhPtDCAVtxOutBC0PileUpNoTOFHit[i] = new TH2F(Form("hPtDCA%sVtxOutBC0PileUpNoTOFHit",dcaName[i].Data()),
715  Form("Track (no TOF hit) DCA%s vs #it{p}_{T}distribution, SPD Pile-Up, vertex with BC!=0",dcaName[i].Data()),
716  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
717  fhPtDCAVtxOutBC0PileUpNoTOFHit[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
718  fhPtDCAVtxOutBC0PileUpNoTOFHit[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
719  outputContainer->Add(fhPtDCAVtxOutBC0PileUpNoTOFHit[i]);
720 
721  fhPtDCAVtxInBC0PileUp[i] = new TH2F(Form("hPtDCA%sPileUpVtxInBC0",dcaName[i].Data()),
722  Form("Track DCA%s vs #it{p}_{T}distribution, SPD Pile-Up,vertex with BC==0",dcaName[i].Data()),
723  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
724  fhPtDCAVtxInBC0PileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
725  fhPtDCAVtxInBC0PileUp[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
726  outputContainer->Add(fhPtDCAVtxInBC0PileUp[i]);
727 
728  fhPtDCAVtxInBC0PileUpNoTOFHit[i] = new TH2F(Form("hPtDCA%sVtxInBC0PileUpNoTOFHit",dcaName[i].Data()),
729  Form("Track (no TOF hit) DCA%s vs #it{p}_{T}distribution, SPD Pile-Up, vertex with BC==0",dcaName[i].Data()),
730  nptbins,ptmin,ptmax,ndcabins,mindca,maxdca);
731  fhPtDCAVtxInBC0PileUpNoTOFHit[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
732  fhPtDCAVtxInBC0PileUpNoTOFHit[i]->SetYTitle(Form("DCA_{%s}",dcaName[i].Data()));
733  outputContainer->Add(fhPtDCAVtxInBC0PileUpNoTOFHit[i]);
734  }
735  }
736  }
737  }
738 
739  if(IsDataMC())
740  {
741  //enum mvType{kmcPion = 0, kmcProton = 1, kmcKaon = 2, kmcMuon = 3, kmcElectron = 4, kmcUnknown = 4 };
742 
743  TString histoName[] = {"Pion","Proton","Kaon","Muon","Electron","Unknown"};
744  TString titleName[] = {"#pi^{#pm}","p^{#pm}","K^{#pm}","#mu^{#pm}","e^{#pm}","x^{#pm}"};
745 
746  for(Int_t imcPart = 0; imcPart < 6; imcPart++)
747  {
748  fhPtMCPart[imcPart] = new TH1F (Form("hPtMC%s",histoName[imcPart].Data()),
749  Form("reconstructed #it{p}_{T} distribution from %s",titleName[imcPart].Data()),
750  nptbins,ptmin,ptmax);
751  fhPtMCPart[imcPart]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
752  outputContainer->Add(fhPtMCPart[imcPart]);
753 
754  fhPhiMCPart[imcPart] = new TH2F (Form("hPhiMC%s",histoName[imcPart].Data()),
755  Form("reconstructed #varphi vs #it{p}_{T} distribution from %s",titleName[imcPart].Data()),
756  nptbins,ptmin,ptmax, nphibins,phimin,phimax);
757  fhPhiMCPart[imcPart]->SetYTitle("#varphi (rad)");
758  fhPhiMCPart[imcPart]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
759  outputContainer->Add(fhPhiMCPart[imcPart]);
760 
761  fhEtaMCPart[imcPart] = new TH2F (Form("hEtaMC%s",histoName[imcPart].Data()),
762  Form("reconstructed #eta vs #it{p}_{T} distribution from %s",titleName[imcPart].Data()),
763  nptbins,ptmin,ptmax, netabins,etamin,etamax);
764  fhEtaMCPart[imcPart]->SetYTitle("#eta ");
765  fhEtaMCPart[imcPart]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
766  outputContainer->Add(fhEtaMCPart[imcPart]);
767 
768  fhPtMCPrimPart[imcPart] = new TH1F (Form("hPtMCPrimary%s",histoName[imcPart].Data()),
769  Form("generated #it{p}_{T} distribution from %s",titleName[imcPart].Data()),
770  nptbins,ptmin,ptmax);
771  fhPtMCPrimPart[imcPart]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
772  outputContainer->Add(fhPtMCPrimPart[imcPart]);
773 
774  fhPhiMCPrimPart[imcPart] = new TH2F (Form("hPhiMCPrimary%s",histoName[imcPart].Data()),
775  Form("generated #varphi vs #it{p}_{T} distribution from %s",titleName[imcPart].Data()),
776  nptbins,ptmin,ptmax, nphibins,phimin,phimax);
777  fhPhiMCPrimPart[imcPart]->SetYTitle("#varphi (rad)");
778  fhPhiMCPrimPart[imcPart]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
779  outputContainer->Add(fhPhiMCPrimPart[imcPart]);
780 
781  fhEtaMCPrimPart[imcPart] = new TH2F (Form("hEtaMCPrimary%s",histoName[imcPart].Data()),
782  Form("generated #eta vs #it{p}_{T} distribution from %s",titleName[imcPart].Data()),
783  nptbins,ptmin,ptmax, netabins,etamin,etamax);
784  fhEtaMCPrimPart[imcPart]->SetYTitle("#eta ");
785  fhEtaMCPrimPart[imcPart]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
786  outputContainer->Add(fhEtaMCPrimPart[imcPart]);
787  }
788  }
789 
790  fhPtNPileUpSPDVtx = new TH2F ("hPt_NPileUpVertSPD","#it{p}_{T} of track vs N pile-up SPD vertex",
791  nptbins,ptmin,ptmax,20,0,20);
792  fhPtNPileUpSPDVtx->SetYTitle("# vertex ");
793  fhPtNPileUpSPDVtx->SetXTitle("#it{p}_{T} (GeV/#it{c})");
794  outputContainer->Add(fhPtNPileUpSPDVtx);
795 
796  fhPtNPileUpTrkVtx = new TH2F ("hPt_NPileUpVertTracks","#it{p}_{T} of track vs N pile-up Tracks vertex",
797  nptbins,ptmin,ptmax, 20,0,20 );
798  fhPtNPileUpTrkVtx->SetYTitle("# vertex ");
799  fhPtNPileUpTrkVtx->SetXTitle("#it{p}_{T} (GeV/#it{c})");
800  outputContainer->Add(fhPtNPileUpTrkVtx);
801 
803  {
804  fhPtNPileUpSPDVtxBC0 = new TH2F ("hPt_NPileUpVertSPD_BC0","#it{p}_{T} of track vs N pile-up SPD vertex",
805  nptbins,ptmin,ptmax,20,0,20);
806  fhPtNPileUpSPDVtxBC0->SetYTitle("# vertex ");
807  fhPtNPileUpSPDVtxBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
808  outputContainer->Add(fhPtNPileUpSPDVtxBC0);
809 
810  fhPtNPileUpTrkVtxBC0 = new TH2F ("hPt_NPileUpVertTracks_BC0","#it{p}_{T} of track vs N pile-up Tracks vertex",
811  nptbins,ptmin,ptmax, 20,0,20 );
812  fhPtNPileUpTrkVtxBC0->SetYTitle("# vertex ");
813  fhPtNPileUpTrkVtxBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
814  outputContainer->Add(fhPtNPileUpTrkVtxBC0);
815  }
816 
817  return outputContainer;
818 }
819 
820 //___________________________________________
822 //___________________________________________
824 {
825  SetOutputAODClassName("AliAODPWG4Particle");
826  SetOutputAODName("PWG4Particle");
827 
828  AddToHistogramsName("AnaCharged_");
829 }
830 
831 //____________________________________________________________
833 //____________________________________________________________
835 {
836  if(! opt)
837  return;
838 
839  printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
841 
842  printf("Min Pt = %3.2f\n", GetMinPt());
843  printf("Max Pt = %3.2f\n", GetMaxPt());
844 }
845 
846 //_________________________________
848 //_________________________________
850 {
851  if(!GetReader()->IsCTSSwitchedOn())
852  AliFatal("STOP!: You want to use CTS tracks in analysis but not read!! \n!!Check the configuration file!!");
853 }
854 
855 //_________________________________________________
858 //_________________________________________________
860 {
861  if(!GetCTSTracks() || GetCTSTracks()->GetEntriesFast() == 0) return ;
862 
863  Int_t ntracks = GetCTSTracks()->GetEntriesFast();
864  Double_t vert[3] = {0,0,0}; //vertex ;
865 
866  AliDebug(1,Form("In CTS aod entries %d", ntracks));
867 
868  AliVEvent * event = GetReader()->GetInputEvent();
869  AliESDEvent* esdEv = dynamic_cast<AliESDEvent*> (event);
870  AliAODEvent* aodEv = dynamic_cast<AliAODEvent*> (event);
871 
872  Int_t vtxBC = GetReader()->GetVertexBC();
873  if(!GetReader()->IsDCACutOn()) vtxBC = GetReader()->GetVertexBC(event->GetPrimaryVertex());
874 
876  {
877  fhProductionVertexBC->Fill(vtxBC, GetEventWeight());
878 
879  if(IsPileUpAnalysisOn())
880  {
881  if(GetReader()->IsPileUpFromSPD()) fhProductionVertexBCPileUp[0]->Fill(vtxBC, GetEventWeight());
882  if(GetReader()->IsPileUpFromEMCal()) fhProductionVertexBCPileUp[1]->Fill(vtxBC, GetEventWeight());
883  if(GetReader()->IsPileUpFromSPDOrEMCal()) fhProductionVertexBCPileUp[2]->Fill(vtxBC, GetEventWeight());
884  if(GetReader()->IsPileUpFromSPDAndEMCal()) fhProductionVertexBCPileUp[3]->Fill(vtxBC, GetEventWeight());
885  if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhProductionVertexBCPileUp[4]->Fill(vtxBC, GetEventWeight());
886  if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhProductionVertexBCPileUp[5]->Fill(vtxBC, GetEventWeight());
887  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhProductionVertexBCPileUp[6]->Fill(vtxBC, GetEventWeight());
888  }
889  }
890 
891  // N pile up vertices
892  Int_t nVtxSPD = -1;
893  Int_t nVtxTrk = -1;
894 
895  if (esdEv)
896  {
897  nVtxSPD = esdEv->GetNumberOfPileupVerticesSPD();
898  nVtxTrk = esdEv->GetNumberOfPileupVerticesTracks();
899  }//ESD
900  else if (aodEv)
901  {
902  nVtxSPD = aodEv->GetNumberOfPileupVerticesSPD();
903  nVtxTrk = aodEv->GetNumberOfPileupVerticesTracks();
904  }//AOD
905 
906  //printf("AliAnaChargedParticles::MakeAnalysisFillAOD() - primary vertex BC %d\n",vtxBC);
907 
908  Double_t bz = event->GetMagneticField();
909 
910  // Fill AODParticle with CTS aods
911  Float_t pt = 0;
912  Float_t phi = 0;
913  Float_t eta = 0;
914  Int_t evtIndex = 0;
915  for(Int_t i = 0; i < ntracks; i++)
916  {
917  AliVTrack * track = (AliVTrack*) (GetCTSTracks()->At(i));
918 
919  pt = track->Pt();
920  eta = track->Eta();
921  phi = track->Phi();
922 
923  fhPtNoCut->Fill(pt, GetEventWeight());
924 
925  fhPtNPileUpSPDVtx->Fill(pt, nVtxSPD, GetEventWeight());
926  fhPtNPileUpTrkVtx->Fill(pt, nVtxTrk, GetEventWeight());
927 
928  AliAODTrack * aodTrack = dynamic_cast<AliAODTrack*>(track);
929  AliESDtrack * esdTrack = dynamic_cast<AliESDtrack*>(track);
930 
931  if ( esdTrack )
932  {
933  fhTrackResolution->Fill(pt, TMath::Sqrt(esdTrack->GetCovariance()[14])*pt, GetEventWeight());
934  }
935 
936  if ( aodTrack )
937  {
938  Double_t frac = Double_t(aodTrack->GetTPCnclsS()) / Double_t(aodTrack->GetTPCncls());
939 
940  if ( frac > GetReader()->GetTPCSharedClusterFraction() )
942 
943  if ( aodTrack->GetType()!= AliAODTrack::kPrimary )
944  fhPtNotPrimary->Fill(pt, GetEventWeight());
945  }
946 
947  // TOF
948  ULong_t status = track->GetStatus();
949  Bool_t okTOF = (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ;
950  Double32_t tof = track->GetTOFsignal()*1e-3;
951 
952  Int_t trackBC = 1000;
953  if(okTOF)
954  {
955  fhTOFSignal ->Fill(tof, GetEventWeight());
956  fhPtTOFSignal->Fill(pt , tof, GetEventWeight());
957 
959  {
960  if(TMath::Abs(vtxBC) > 0 && vtxBC!=AliVTrack::kTOFBCNA)
961  fhPtTOFSignalVtxOutBC0->Fill(pt, tof, GetEventWeight());
962  else
963  fhPtTOFSignalVtxInBC0 ->Fill(pt, tof, GetEventWeight());
964  }
965 
967  {
968  trackBC = track->GetTOFBunchCrossing(bz);
969 
970  if(trackBC==0)
971  fhTOFSignalBCOK->Fill(tof, GetEventWeight());
972  }
973  }
974 
975  // BC0
977  {
978  if(TMath::Abs(vtxBC) > 0 && vtxBC!=AliVTrack::kTOFBCNA)
979  {
980  fhPtVtxOutBC0 ->Fill(pt , GetEventWeight());
981  fhEtaPhiVtxOutBC0->Fill(eta, phi, GetEventWeight());
982  }
983  else
984  {
985  fhPtVtxInBC0 ->Fill(pt , GetEventWeight());
986  fhEtaPhiVtxInBC0->Fill(eta, phi, GetEventWeight());
987 
988  fhPtNPileUpSPDVtxBC0->Fill(pt, nVtxSPD, GetEventWeight());
989  fhPtNPileUpTrkVtxBC0->Fill(pt, nVtxTrk, GetEventWeight());
990  }
991  }
992 
993  // DCA
994  Double_t dcaCons = -999;
995  Double_t dca[2] = {1e6,1e6};
996  Double_t covar[3] = {1e6,1e6,1e6};
997 
999  {
1000  if(aodTrack)
1001  {
1002  dcaCons = aodTrack->DCA();
1003  //vtxBC = aodTrack->GetProdVertex()->GetBC();
1004  }
1005 
1006  track->PropagateToDCA(GetReader()->GetInputEvent()->GetPrimaryVertex(),bz,100.,dca,covar);
1007 
1008  Float_t trackDCA = dca[0];
1009 
1010  if(dcaCons == -999)
1011  {
1012  fhPtDCA[0]->Fill(pt, dca[0], GetEventWeight());
1013  fhPtDCA[1]->Fill(pt, dca[1], GetEventWeight());
1014  }
1015  else
1016  {
1017  trackDCA = dcaCons;
1018  fhPtDCA[2]->Fill(pt, dcaCons, GetEventWeight());
1019  }
1020 
1021  if ( GetReader()->AcceptDCA(pt,trackDCA) && !GetReader()->IsDCACutOn() )
1022  fhPtCutDCA->Fill(pt, GetEventWeight());
1023 
1025  {
1026  if(TMath::Abs(vtxBC) > 0 && vtxBC!=AliVTrack::kTOFBCNA)
1027  {
1028  if(dcaCons == -999)
1029  {
1030  fhPtDCAVtxOutBC0[0]->Fill(pt, dca[0], GetEventWeight());
1031  fhPtDCAVtxOutBC0[1]->Fill(pt, dca[1], GetEventWeight());
1032  }
1033  else
1034  fhPtDCAVtxOutBC0[2]->Fill(pt, dcaCons, GetEventWeight());
1035  }
1036  else
1037  {
1038  if ( GetReader()->AcceptDCA(pt,trackDCA) && !GetReader()->IsDCACutOn() )
1039  fhPtCutDCABCOK->Fill(pt, GetEventWeight());
1040 
1041  if(dcaCons == -999)
1042  {
1043  fhPtDCAVtxInBC0[0]->Fill(pt, dca[0], GetEventWeight());
1044  fhPtDCAVtxInBC0[1]->Fill(pt, dca[1], GetEventWeight());
1045  }
1046  else
1047  fhPtDCAVtxInBC0[2]->Fill(pt, dcaCons, GetEventWeight());
1048  }
1049  }
1050 
1051  if(IsPileUpAnalysisOn() && GetReader()->IsPileUpFromSPD())
1052  {
1053  if(dcaCons == -999)
1054  {
1055  fhPtDCAPileUp[0]->Fill(pt, dca[0], GetEventWeight());
1056  fhPtDCAPileUp[1]->Fill(pt, dca[1], GetEventWeight());
1057  }
1058  else
1059  fhPtDCAPileUp[2]->Fill(pt, dcaCons, GetEventWeight());
1060 
1062  {
1063  if(TMath::Abs(vtxBC) > 0 && vtxBC!=AliVTrack::kTOFBCNA)
1064  {
1065  if(dcaCons == -999)
1066  {
1067  fhPtDCAVtxOutBC0PileUp[0]->Fill(pt, dca[0], GetEventWeight());
1068  fhPtDCAVtxOutBC0PileUp[1]->Fill(pt, dca[1], GetEventWeight());
1069  }
1070  else fhPtDCAVtxOutBC0PileUp[2]->Fill(pt, dcaCons, GetEventWeight());
1071  }
1072  else
1073  {
1074  if(dcaCons == -999)
1075  {
1076  fhPtDCAVtxInBC0PileUp[0]->Fill(pt, dca[0], GetEventWeight());
1077  fhPtDCAVtxInBC0PileUp[1]->Fill(pt, dca[1], GetEventWeight());
1078  }
1079  else fhPtDCAVtxInBC0PileUp[2]->Fill(pt, dcaCons, GetEventWeight());
1080  }
1081  }
1082  }
1083 
1084  //printf("track pT %2.2f, DCA Cons %f, DCA1 %f, DCA2 %f, TOFBC %d, oktof %d, tof %f\n",
1085  // pt,dcaCons,dca[0],dca[1],track->GetTOFBunchCrossing(bz),okTOF, tof);
1086 
1087 
1088  // if( vtxBC == 0 && trackBC !=0 && trackBC!=AliVTrack::kTOFBCNA)
1089  // printf("TOF Signal %e, BC %d, pt %f, dca_xy %f, dca_z %f, dca_tpc %f \n", tof,trackBC, pt,dca[0],dca[1],dcaCons);
1090 
1091  if(!okTOF)
1092  {
1093  if(dcaCons == -999)
1094  {
1095  fhPtDCANoTOFHit[0]->Fill(pt, dca[0], GetEventWeight());
1096  fhPtDCANoTOFHit[1]->Fill(pt, dca[1], GetEventWeight());
1097  }
1098  else
1099  fhPtDCANoTOFHit[2]->Fill(pt, dcaCons, GetEventWeight());
1100 
1102  {
1103  if(TMath::Abs(vtxBC) > 0 && vtxBC!=AliVTrack::kTOFBCNA)
1104  {
1105  if(dcaCons == -999)
1106  {
1107  fhPtDCAVtxOutBC0NoTOFHit[0]->Fill(pt, dca[0], GetEventWeight());
1108  fhPtDCAVtxOutBC0NoTOFHit[1]->Fill(pt, dca[1], GetEventWeight());
1109  }
1110  else
1111  fhPtDCAVtxOutBC0NoTOFHit[2]->Fill(pt, dcaCons, GetEventWeight());
1112  }
1113  else
1114  {
1115  if(dcaCons == -999)
1116  {
1117  fhPtDCAVtxInBC0NoTOFHit[0]->Fill(pt, dca[0], GetEventWeight());
1118  fhPtDCAVtxInBC0NoTOFHit[1]->Fill(pt, dca[1], GetEventWeight());
1119  }
1120  else
1121  fhPtDCAVtxInBC0NoTOFHit[2]->Fill(pt, dcaCons, GetEventWeight());
1122 
1123  }
1124  }
1125 
1126  if(IsPileUpAnalysisOn() && GetReader()->IsPileUpFromSPD())
1127  {
1128  if(dcaCons == -999)
1129  {
1130  fhPtDCAPileUpNoTOFHit[0]->Fill(pt, dca[0], GetEventWeight());
1131  fhPtDCAPileUpNoTOFHit[1]->Fill(pt, dca[1], GetEventWeight());
1132  }
1133  else
1134  fhPtDCAPileUpNoTOFHit[2]->Fill(pt, dcaCons, GetEventWeight());
1135 
1137  {
1138  if(TMath::Abs(vtxBC) > 0 && vtxBC!=AliVTrack::kTOFBCNA)
1139  {
1140  if(dcaCons == -999)
1141  {
1142  fhPtDCAVtxOutBC0PileUpNoTOFHit[0]->Fill(pt, dca[0], GetEventWeight());
1143  fhPtDCAVtxOutBC0PileUpNoTOFHit[1]->Fill(pt, dca[1], GetEventWeight());
1144  }
1145  else
1146  fhPtDCAVtxOutBC0PileUpNoTOFHit[2]->Fill(pt, dcaCons, GetEventWeight());
1147  }
1148  else
1149  {
1150  if(dcaCons == -999)
1151  {
1152  fhPtDCAVtxInBC0PileUpNoTOFHit[0]->Fill(pt, dca[0], GetEventWeight());
1153  fhPtDCAVtxInBC0PileUpNoTOFHit[1]->Fill(pt, dca[1], GetEventWeight());
1154  }
1155  else
1156  fhPtDCAVtxInBC0PileUpNoTOFHit[2]->Fill(pt, dcaCons, GetEventWeight());
1157 
1158  }
1159  }
1160  }
1161  } // No TOF
1162  else
1163  {
1164  if(GetReader()->AcceptDCA(pt,trackDCA) && !GetReader()->IsDCACutOn() )
1165  fhPtTOFSignalDCACut->Fill(pt, tof, GetEventWeight());
1166 
1168  {
1169 
1170  if(trackBC==0)
1171  {
1172 
1173  if(dcaCons == -999)
1174  {
1175  fhPtDCATOFBC0[0]->Fill(pt, dca[0], GetEventWeight());
1176  fhPtDCATOFBC0[1]->Fill(pt, dca[1], GetEventWeight());
1177  }
1178  else
1179  fhPtDCATOFBC0[2]->Fill(pt, dcaCons, GetEventWeight());
1180 
1181  if(IsPileUpAnalysisOn() && GetReader()->IsPileUpFromSPD())
1182  {
1183  if(dcaCons == -999)
1184  {
1185  fhPtDCAPileUpTOFBC0[0]->Fill(pt, dca[0], GetEventWeight());
1186  fhPtDCAPileUpTOFBC0[1]->Fill(pt, dca[1], GetEventWeight());
1187  }
1188  else
1189  fhPtDCAPileUpTOFBC0[2]->Fill(pt, dcaCons, GetEventWeight());
1190  }
1191  }
1192  else if(trackBC!=AliVTrack::kTOFBCNA)
1193  {
1194  if(dcaCons == -999)
1195  {
1196  fhPtDCATOFBCOut[0]->Fill(pt, dca[0], GetEventWeight());
1197  fhPtDCATOFBCOut[1]->Fill(pt, dca[1], GetEventWeight());
1198  }
1199  else
1200  fhPtDCATOFBCOut[2]->Fill(pt, dcaCons, GetEventWeight());
1201  }
1202  }
1203  }
1204  } // DCA
1205 
1206  // Pile-up
1207  //
1208  if(IsPileUpAnalysisOn())
1209  {
1210  if(GetReader()->IsPileUpFromSPD()) fhPtTOFSignalPileUp[0]->Fill(pt, tof, GetEventWeight());
1211  if(GetReader()->IsPileUpFromEMCal()) fhPtTOFSignalPileUp[1]->Fill(pt, tof, GetEventWeight());
1212  if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtTOFSignalPileUp[2]->Fill(pt, tof, GetEventWeight());
1213  if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtTOFSignalPileUp[3]->Fill(pt, tof, GetEventWeight());
1214  if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtTOFSignalPileUp[4]->Fill(pt, tof, GetEventWeight());
1215  if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtTOFSignalPileUp[5]->Fill(pt, tof, GetEventWeight());
1216  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtTOFSignalPileUp[6]->Fill(pt, tof, GetEventWeight());
1217 
1219  {
1220  if (trackBC == 0 )
1221  {
1222  fhEtaPhiTOFBC0 ->Fill(eta, phi, GetEventWeight());
1223  if(IsPileUpAnalysisOn() && GetReader()->IsPileUpFromSPD())
1224  fhEtaPhiTOFBC0PileUpSPD->Fill(eta, phi, GetEventWeight());
1225  }
1226  else if (trackBC < 0 )
1227  {
1228  fhEtaPhiTOFBCPlus ->Fill(eta, phi, GetEventWeight());
1229  if(IsPileUpAnalysisOn() && GetReader()->IsPileUpFromSPD())
1230  fhEtaPhiTOFBCPlusPileUpSPD ->Fill(eta, phi, GetEventWeight());
1231  }
1232  else if (trackBC > 0)
1233  {
1234  fhEtaPhiTOFBCMinus->Fill(eta, phi, GetEventWeight());
1235  if(IsPileUpAnalysisOn() && GetReader()->IsPileUpFromSPD())
1236  fhEtaPhiTOFBCMinusPileUpSPD->Fill(eta, phi, GetEventWeight());
1237  }
1238  }
1239 
1241  {
1242  if(TMath::Abs(vtxBC) > 0 && vtxBC!=AliVTrack::kTOFBCNA)
1243  {
1244  if(GetReader()->IsPileUpFromSPD()) fhPtTOFSignalVtxOutBC0PileUp[0]->Fill(pt, tof, GetEventWeight());
1245  if(GetReader()->IsPileUpFromEMCal()) fhPtTOFSignalVtxOutBC0PileUp[1]->Fill(pt, tof, GetEventWeight());
1246  if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtTOFSignalVtxOutBC0PileUp[2]->Fill(pt, tof, GetEventWeight());
1247  if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtTOFSignalVtxOutBC0PileUp[3]->Fill(pt, tof, GetEventWeight());
1248  if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtTOFSignalVtxOutBC0PileUp[4]->Fill(pt, tof, GetEventWeight());
1249  if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtTOFSignalVtxOutBC0PileUp[5]->Fill(pt, tof, GetEventWeight());
1250  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtTOFSignalVtxOutBC0PileUp[6]->Fill(pt, tof, GetEventWeight());
1251  }
1252  else
1253  {
1254  if(GetReader()->IsPileUpFromSPD()) fhPtTOFSignalVtxInBC0PileUp[0]->Fill(pt, tof, GetEventWeight());
1255  if(GetReader()->IsPileUpFromEMCal()) fhPtTOFSignalVtxInBC0PileUp[1]->Fill(pt, tof, GetEventWeight());
1256  if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtTOFSignalVtxInBC0PileUp[2]->Fill(pt, tof, GetEventWeight());
1257  if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtTOFSignalVtxInBC0PileUp[3]->Fill(pt, tof, GetEventWeight());
1258  if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtTOFSignalVtxInBC0PileUp[4]->Fill(pt, tof, GetEventWeight());
1259  if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtTOFSignalVtxInBC0PileUp[5]->Fill(pt, tof, GetEventWeight());
1260  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtTOFSignalVtxInBC0PileUp[6]->Fill(pt, tof, GetEventWeight());
1261  }
1262  }
1263  }
1264 
1265  // Fill AODParticle after some selection
1266  //
1267  fMomentum.SetPxPyPzE(track->Px(),track->Py(),track->Pz(),0);
1269 
1270  AliDebug(1,Form("Track pt %2.2f, eta %2.2f, phi %2.2f in fiducial cut %d",pt,eta,phi,in));
1271 
1272  // Acceptance selection
1273  if(IsFiducialCutOn() && ! in ) continue ;
1274 
1275  // Momentum selection
1276  if(pt < GetMinPt() || pt > GetMaxPt()) continue;
1277 
1278  if(okTOF) fhTOFSignalPtCut->Fill(tof, GetEventWeight());
1279  else
1280  {
1281  fhPtTOFStatus0 ->Fill(pt, GetEventWeight());
1282  fhEtaPhiTOFStatus0->Fill(eta, phi, GetEventWeight());
1283  }
1284 
1285  Bool_t bITSRefit = (status & AliVTrack::kITSrefit) == AliVTrack::kITSrefit;
1286  Bool_t bConstrained = kFALSE;
1287  if (aodTrack) bConstrained = aodTrack->IsGlobalConstrained();
1288  else if(esdTrack) bConstrained = (!esdTrack->HasPointOnITSLayer(0) && !esdTrack->HasPointOnITSLayer(1));
1289  //printf("Track %d, pt %2.2f, eta %2.2f, phi %2.2f, SPDRefit %d, refit %d, dcaCons %2.2f\n",
1290  // i, pt, eta, phi, bConstrained, bITSRefit, dcaCons);
1291 
1292  if(bConstrained)
1293  {
1294  if(bITSRefit)
1295  {
1296  fhPtNoSPDRefit->Fill(pt, GetEventWeight());
1297  if(pt < 2)fhEtaPhiNoSPDRefitPt02->Fill(eta, phi, GetEventWeight());
1298  if(pt > 3)fhEtaPhiNoSPDRefitPt3 ->Fill(eta, phi, GetEventWeight());
1299 
1301  {
1302  if(dcaCons == -999)
1303  {
1304  fhPtDCANoSPDRefit[0]->Fill(pt, dca[0], GetEventWeight());
1305  fhPtDCANoSPDRefit[1]->Fill(pt, dca[1], GetEventWeight());
1306  }
1307  else
1308  fhPtDCANoSPDRefit[2]->Fill(pt, dcaCons, GetEventWeight());
1309  }
1310  }
1311  else
1312  {
1313  fhPtNoSPDNoRefit->Fill(pt, GetEventWeight());
1314  if(pt < 2)fhEtaPhiNoSPDNoRefitPt02->Fill(eta, phi, GetEventWeight());
1315  if(pt > 3)fhEtaPhiNoSPDNoRefitPt3 ->Fill(eta, phi, GetEventWeight());
1316 
1318  {
1319  if(dcaCons == -999)
1320  {
1321  fhPtDCANoSPDNoRefit[0]->Fill(pt, dca[0], GetEventWeight());
1322  fhPtDCANoSPDNoRefit[1]->Fill(pt, dca[1], GetEventWeight());
1323  }
1324  else
1325  fhPtDCANoSPDNoRefit[2]->Fill(pt, dcaCons, GetEventWeight());
1326  }
1327  }
1328  }
1329  else
1330  {
1331  fhPtSPDRefit->Fill(pt, GetEventWeight());
1332  if(pt < 2)fhEtaPhiSPDRefitPt02->Fill(eta, phi, GetEventWeight());
1333  if(pt > 3)fhEtaPhiSPDRefitPt3 ->Fill(eta, phi, GetEventWeight());
1334 
1336  {
1337  if(dcaCons == -999)
1338  {
1339  fhPtDCASPDRefit[0]->Fill(pt, dca[0], GetEventWeight());
1340  fhPtDCASPDRefit[1]->Fill(pt, dca[1], GetEventWeight());
1341  }
1342  else
1343  fhPtDCASPDRefit[2]->Fill(pt, dcaCons, GetEventWeight());
1344  }
1345  }
1346 
1347  // Mixed event
1348  if (GetMixedEvent())
1349  {
1350  evtIndex = GetMixedEvent()->EventIndex(GetReader()->GetTrackID(track)) ; // needed instead of track->GetID() since AOD needs some manipulations
1351  }
1352 
1353  GetVertex(vert,evtIndex);
1354  if(TMath::Abs(vert[2])> GetZvertexCut()) return;
1355 
1356  AliAODPWG4Particle tr = AliAODPWG4Particle(track->Px(),track->Py(),track->Pz(),0);
1357  tr.SetDetectorTag(kCTS);
1358  tr.SetLabel(track->GetLabel());
1359  tr.SetTrackLabel(GetReader()->GetTrackID(track),-1); // needed instead of track->GetID() since AOD needs some manipulations
1360  tr.SetChargedBit(track->Charge()>0);
1361 
1362  AddAODParticle(tr);
1363  } // loop
1364 
1365  AliDebug(1,Form("Final aod branch entries %d", GetOutputAODBranch()->GetEntriesFast()));
1366 }
1367 
1368 //________________________________________________________
1370 //________________________________________________________
1372 {
1374 
1375  // Loop on stored AODParticles
1376  Int_t naod = GetOutputAODBranch()->GetEntriesFast();
1377 
1378  // Fill event track multiplicity and sum pT histograms
1379  // Calculated in the reader to be used everywhere, so not redone here.
1380  for(Int_t icut = 0; icut < GetReader()->GetTrackMultiplicityNPtCut(); icut++)
1381  {
1382  fhNTracks ->Fill(GetReader()->GetTrackMultiplicity(icut),icut, GetEventWeight()) ;
1383  fhSumPtTracks->Fill(GetReader()->GetTrackSumPt (icut),icut, GetEventWeight()) ;
1384  }
1385 
1386  AliDebug(1,Form("AOD branch entries %d", naod));
1387 
1388  Float_t pt = 0;
1389  Float_t phi = 0;
1390  Float_t eta = 0;
1391 
1392  Float_t sum[18][2];
1393  for(Int_t i = 0; i < 18; i++)
1394  for(Int_t j = 0; j < 2; j++)
1395  sum[i][j] = 0;
1396 
1397  for(Int_t iaod = 0; iaod < naod ; iaod++)
1398  {
1399  AliAODPWG4Particle* track = (AliAODPWG4Particle*) (GetOutputAODBranch()->At(iaod));
1400 
1401  pt = track->Pt();
1402  eta = track->Eta();
1403  phi = track->Phi();
1404 
1405  fhPt->Fill(pt, GetEventWeight());
1406 
1407  // Fill event track multiplicity and sum pT histograms vs track pT
1408  // Calculated in the reader to be used everywhere, so not redone here.
1410  {
1411  for(Int_t icut = 0; icut < GetReader()->GetTrackMultiplicityNPtCut(); icut++)
1412  {
1413  fhPtTrackNTracks[icut]->Fill(pt, GetReader()->GetTrackMultiplicity(icut), GetEventWeight()) ;
1414 
1415  // discount the "trigger" pT from the sum pT if not cutted already
1416  Float_t shift = pt;
1417  if ( pt > GetReader()->GetTrackMultiplicityPtCut(icut) ) shift = 0;
1418  fhPtTrackSumPtTracks[icut]->Fill(pt, GetReader()->GetTrackSumPt(icut)-shift, GetEventWeight()) ;
1419  }
1420  }
1421 
1423  {
1424  Int_t sector = GetTrackSector(phi);
1425  Bool_t side = GetTrackSide (eta);
1426 
1427  //printf("track eta %2.2f, side %d, phi %2.2f sector %d\n",
1428  // eta, GetTrackSide(eta), phi, GetTrackSector(phi));
1429 
1430  fhPtPerRegion[sector][side]->Fill(pt, GetEventWeight());
1431  sum[sector][side]+=pt;
1432  }
1433 
1434  if(track->GetChargedBit())
1435  {
1436  fhPhiPos ->Fill(pt, phi, GetEventWeight());
1437  fhEtaPos ->Fill(pt, eta, GetEventWeight());
1438  fhEtaPhiPos->Fill(eta, phi, GetEventWeight());
1439  }
1440  else
1441  {
1442  fhPhiNeg ->Fill(pt, phi, GetEventWeight());
1443  fhEtaNeg ->Fill(pt, eta, GetEventWeight());
1444  fhEtaPhiNeg->Fill(eta, phi, GetEventWeight());
1445  }
1446 
1447  if(IsPileUpAnalysisOn())
1448  {
1449  if(GetReader()->IsPileUpFromSPD()) {fhPtPileUp[0]->Fill(pt, GetEventWeight());}
1450  if(GetReader()->IsPileUpFromEMCal()) {fhPtPileUp[1]->Fill(pt, GetEventWeight());}
1451  if(GetReader()->IsPileUpFromSPDOrEMCal()) {fhPtPileUp[2]->Fill(pt, GetEventWeight());}
1452  if(GetReader()->IsPileUpFromSPDAndEMCal()) {fhPtPileUp[3]->Fill(pt, GetEventWeight());}
1453  if(GetReader()->IsPileUpFromSPDAndNotEMCal()) {fhPtPileUp[4]->Fill(pt, GetEventWeight());}
1454  if(GetReader()->IsPileUpFromEMCalAndNotSPD()) {fhPtPileUp[5]->Fill(pt, GetEventWeight());}
1455  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) {fhPtPileUp[6]->Fill(pt, GetEventWeight());}
1456  }
1457 
1458  if(IsDataMC())
1459  {
1460  // Play with the MC stack if available
1461  Int_t mompdg = -1;
1462  Int_t label = track->GetLabel();
1463 
1464  if(label >= 0)
1465  {
1466  AliVParticle * mom = GetMC()->GetTrack(label);
1467  mompdg =TMath::Abs(mom->PdgCode());
1468  }
1469 
1470  Int_t mcType = kmcUnknown;
1471  if (mompdg==211 ) mcType = kmcPion;
1472  else if(mompdg==2212) mcType = kmcProton;
1473  else if(mompdg==321 ) mcType = kmcKaon;
1474  else if(mompdg==11 ) mcType = kmcElectron;
1475  else if(mompdg==13 ) mcType = kmcMuon;
1476 
1477  fhPtMCPart [mcType]->Fill(pt, GetEventWeight());
1478  fhEtaMCPart[mcType]->Fill(pt, eta, GetEventWeight());
1479  fhPhiMCPart[mcType]->Fill(pt, phi, GetEventWeight());
1480 
1481  } // Work with stack also
1482 
1483  } // aod branch loop
1484 
1486  {
1487  for(Int_t i = 0; i < 18; i++)
1488  {
1489  for(Int_t j = 0; j < 2; j++)
1490  {
1491  fhSumPtPerRegion[i][j]->Fill(sum[i][j], GetEventWeight());
1492  }
1493  }
1494  }
1495 }
Float_t GetHistoPtMax() const
Int_t pdg
TH2F * fhPtDCAVtxInBC0PileUpNoTOFHit[3]
! DCA (xy,z,constrained) of all tracks, vertex BC=0, SPD pile-up, no hit in TOF
Float_t GetHistoPtMin() const
virtual TObjArray * GetCTSTracks() const
TH2F * fhPtDCANoTOFHit[3]
! DCA (xy,z,constrained) of all tracks, no hit in TOF
TH2F * fhPtDCAPileUpNoTOFHit[3]
! DCA (xy,z,constrained) of all tracks, SPD pile-up, no hit in TOF
TH2F * fhPtDCATOFBCOut[3]
! DCA (xy,z,constrained) of all tracks, hit in TOF and BC!=0
Bool_t fFillTrackBCHistograms
Fill histograms for tracks with TOF BC=0 or not related histograms.
TH2F * fhPtTOFSignalVtxInBC0
! TOF signal vs track pT, good status
double Double_t
Definition: External.C:58
Int_t GetTrackSector(Float_t trackPhi) const
TH1F * fhPtNotSharedClusterCut
! pT spectra of tracks not passing the shared clusters cut (AOD)
virtual void AddToHistogramsName(TString add)
Bool_t GetTrackSide(Float_t trackEta) const
Definition: External.C:236
TH2F * fhPtTOFSignalVtxInBC0PileUp[7]
! TOF signal vs track pT, good status, pile-up
TH1F * fhTOFSignalPtCut
! TOF signal pt and acceptance cut
TH2F * fhPtDCAVtxOutBC0PileUp[3]
! DCA (xy,z,constrained) of all tracks, vertex BC!=0, SPD pile-up
TH2F * fhPtDCAVtxOutBC0NoTOFHit[3]
! DCA (xy,z,constrained) of all tracks, vertex BC!=0, no hit in TOF
TH2F * fhPtTrackSumPtTracks[10]
! Track sum pT distribution per event vs track pT, different pT cuts
TH2F * fhPtTOFSignalPileUp[7]
! TOF signal vs track pT, good status, pile-up
virtual void GetVertex(Double_t vertex[3]) const
Int_t GetHistoTrackMultiplicityMax() const
TH2F * fhPtTOFSignalDCACut
! TOF signal vs track pT, good status
TH2F * fhPtNPileUpSPDVtx
! cluster pt vs number of spd pile-up vertices
Int_t GetVertexBC(const AliVVertex *vtx)
virtual AliVEvent * GetInputEvent() const
TH1F * fhProductionVertexBCPileUp[7]
! Check BC of production vertex, pile-up
TH2F * fhEtaPhiNoSPDRefitPt3
! eta-phi distribution of constrained tracks no SPD and with ITSRefit, pT > 3 GeV ...
TH2F * fhEtaPhiTOFBCMinusPileUpSPD
! eta/phi of tracks passing TOF status selection, tracks in BC<0, pile-up spd
TH2F * fhPhiMCPart[6]
! phi distribution vs pT, 6 hadron ID
virtual Float_t GetZvertexCut() const
Maximal number of events for mixin.
TH2F * fhEtaPhiPos
! eta vs phi distribution of positive charge
TH2F * fhEtaPhiNoSPDRefitPt02
! eta-phi distribution of constrained tracks no SPD and with ITSRefit, 0 < pT < 2 GeV ...
void FillPrimaryHistograms()
Fill primary generated particles histograms if MC data is available.
TH2F * fhPtTOFSignalVtxOutBC0PileUp[7]
! TOF signal vs track pT, good status, pile-up
Bool_t fFillTrackMultHistograms
Fill track pT spectrum histograms vs track multiplicity or track sum pt.
virtual void SetOutputAODClassName(TString name)
TH2F * fhSumPtTracks
! Track sum pT distribution per event, different pT cuts
TH2F * fhEtaMCPrimPart[6]
! Number of generated charged hadrons vs eta coming from MC particle, 6 hadron ID ...
TH2F * fhEtaPhiTOFStatus0
! eta/phi of tracks not passing TOF status selection
Int_t GetHistoPhiBins() const
TH2F * fhEtaPhiNeg
! eta vs phi distribution of negative charge
TH2F * fhPtDCAVtxInBC0NoTOFHit[3]
! DCA (xy,z,constrained) of all tracks, vertex BC=0, no hit in TOF
TH2F * fhPtDCA[3]
! DCA (xy,z,constrained) of all tracks
Bool_t fFillTrackDCAHistograms
Fill track DCA histograms.
TH2F * fhPtDCAPileUp[3]
! DCA (xy,z,constrained) of all tracks, SPD pile-up
Int_t GetHistoTrackMultiplicityMin() const
TH1F * fhPt
! pT distribution
virtual TClonesArray * GetOutputAODBranch() const
TH2F * fhEtaPhiTOFBC0PileUpSPD
! eta/phi of tracks passing TOF status selection, tracks in BC=0, pile-up spd
TH1F * fhPtPileUp[7]
! pT distribution, pile-up defined events
TH2F * fhPtTOFSignalVtxOutBC0
! TOF signal vs track pT, good status
Float_t GetHistoPhiMin() const
TH2F * fhPhiNeg
! phi distribution vs pT, negative
void MakeAnalysisFillHistograms()
Fill histograms for the selected tracks.
virtual void SetOutputAODName(TString name)
TH1F * fhPtNoSPDRefit
! pT distribution of constrained tracks no SPD and with ITSRefit
TH2F * fhEtaPhiTOFBCPlusPileUpSPD
! eta/phi of tracks passing TOF status selection, tracks in BC>0, pile-up spd
const Double_t etamin
Base class for CaloTrackCorr analysis algorithms.
void Init()
Init. Check that tracks are read, if not abort.
virtual AliFiducialCut * GetFiducialCut()
int Int_t
Definition: External.C:63
TH1F * fhPtNotPrimary
! pT spectra of tracks not declared as primary (AOD)
TH1F * fhPtVtxInBC0
! pT distribution of tracks from a vertex with BC=0
TH2F * fhPtNPileUpTrkVtx
! cluster pt vs number of track pile-up vertices
virtual AliHistogramRanges * GetHistogramRanges()
TH2F * fhEtaNeg
! eta distribution vs pT, negative
float Float_t
Definition: External.C:68
const Double_t ptmax
TH2F * fhPtDCAVtxOutBC0PileUpNoTOFHit[3]
! DCA (xy,z,constrained) of all tracks, vertex BC!=0, SPD pile-up, no hit in TOF
TH2F * fhEtaPhiSPDRefitPt3
! eta-phi distribution of tracks with SPD and ITS refit, pT > 3 GeV
TH1F * fhPtTOFStatus0
! pT of tracks not passing TOF status selection
Bool_t IsInFiducialCut(Float_t eta, Float_t phi, Int_t det) const
TH2F * fhEtaPhiNoSPDNoRefitPt3
! eta-phi distribution of constrained tracks with no SPD requierement and without ITSRefit...
TH1F * fhSumPtPerRegion[18][2]
! pT distribution in TPC regions
void Print(const Option_t *opt) const
Print some relevant parameters set for the analysis.
TH2F * fhEtaPhiTOFBC0
! eta/phi of tracks passing TOF status selection, tracks in BC=0
TH2F * fhPhiMCPrimPart[6]
! Number of generated charged hadrons vs phi coming from MC particle, 6 hadron ID ...
TH1F * fhPtVtxOutBC0
! pT distribution of tracks from a vertex with BC!=0
const Double_t ptmin
Int_t GetHistoNPtSumBins() const
unsigned long ULong_t
Definition: External.C:38
TH2F * fhPtNPileUpSPDVtxBC0
! cluster pt vs number of spd pile-up vertices, track in BC=0
virtual Float_t GetTPCSharedClusterFraction() const
Bool_t fFillEtaPhiRegionHistograms
Fill track pT spectrum histograms in different eta-phi windows.
virtual Double_t GetEventWeight() const
TH2F * fhPtTOFSignal
! TOF signal vs track pT, good status
TH1F * fhProductionVertexBC
! Check BC of production vertex
Int_t GetHistoTrackMultiplicityBins() const
TH2F * fhPtDCAPileUpTOFBC0[3]
! DCA (xy,z,constrained) of all tracks, hit in TOF and BC=0
Float_t GetHistoEtaMin() const
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)
TH1F * fhTOFSignal
! TOF signal
TH1F * fhPtCutDCA
! pT distribution, Apply DCA cut
Float_t GetHistoPtSumMin() const
TH2F * fhPtDCATOFBC0[3]
! DCA (xy,z,constrained) of all tracks, hit in TOF and BC=0
TH2F * fhNTracks
! Track multiplicity distribution per event, different pT cuts
TH2F * fhEtaMCPart[6]
! eta distribution vs pT, 6 hadron ID
TH1F * fhPtNoSPDNoRefit
! pT distribution of constrained tracks with no SPD requierement and without ITSRefit ...
void InitParameters()
Initialize the parameters of the analysis.
Float_t GetHistoEtaMax() const
virtual void AddAODParticle(AliAODPWG4Particle part)
Int_t GetHistoPtBins() const
TH1F * fhPtMCPart[6]
! pT distribution, 6 hadron ID
Track selection for correlation analysis.
Bool_t fFillVertexBC0Histograms
Fill histograms for tracks with vertex BC=0 or not related histograms.
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
TH2F * fhEtaPhiVtxInBC0
! eta/phi distribution of tracks from a vertex with BC=0
TH2F * fhPhiPos
! phi distribution vs pT, positive
TH1F * fhPtMCPrimPart[6]
! Number of generated charged hadrons vs pT coming from MC particle, 6 hadron ID
TH2F * fhEtaPos
! eta distribution vs pT, positive
TH2F * fhPtDCANoSPDRefit[3]
! DCA (xy,z,constrained) of constrained tracks no SPD and with ITSRefit
TH1F * fhPtCutDCABCOK
! pT distribution, Apply DCA cut, BC=0 or -100
const Double_t etamax
TH2F * fhPtTrackNTracks[10]
! Track multiplicity distribution per event vs track pT, different pT cuts
TH2F * fhPtDCAVtxInBC0[3]
! DCA (xy,z,constrained) of all tracks, vertex BC==0
TH2F * fhEtaPhiNoSPDNoRefitPt02
! eta-phi distribution of constrained tracks with no SPD requierement and without ITSRefit...
virtual void Print(const Option_t *) const
Print some relevant parameters set for the analysis.
Int_t GetHistoTimeBins() const
TH1F * fhTOFSignalBCOK
! TOF signal pt and acceptance cut
TH2F * fhEtaPhiSPDRefitPt02
! eta-phi distribution of tracks with SPD and ITS refit, 0 < pT < 2 GeV
const char Option_t
Definition: External.C:48
TH2F * fhPtDCAVtxInBC0PileUp[3]
! DCA (xy,z,constrained) of all tracks, vertex BC==0, SPD pile-up
Float_t GetHistoTimeMax() const
TH2F * fhPtNPileUpTrkVtxBC0
! cluster pt vs number of track pile-up vertices, track in BC=0
Float_t GetHistoTimeMin() const
Float_t GetHistoPhiMax() const
AliAnaChargedParticles()
Default constructor. Initialize parameters with default values.
bool Bool_t
Definition: External.C:53
virtual AliCaloTrackReader * GetReader() const
Int_t GetHistoEtaBins() const
TH2F * fhEtaPhiTOFBCMinus
! eta/phi of tracks passing TOF status selection, tracks in BC<0
TH1F * fhPtSPDRefit
! pT distribution of tracks with SPD and ITS refit
TH2F * fhPtDCASPDRefit[3]
! DCA (xy,z,constrained) of tracks with SPD and ITS refit
TH2F * fhEtaPhiTOFBCPlus
! eta/phi of tracks passing TOF status selection, tracks in BC>0
TH2F * fhEtaPhiVtxOutBC0
! eta/phi distribution of tracks from a vertex with BC!=0
TH2F * fhPtDCAVtxOutBC0[3]
! DCA (xy,z,constrained) of all tracks, vertex BC!=0
TLorentzVector fMomentum
! Temporary momentum container
Float_t GetHistoPtSumMax() const
TH1F * fhPtPerRegion[18][2]
! pT distribution in TPC regions
TH2F * fhPtDCANoSPDNoRefit[3]
! DCA (xy,z,constrained) of constrained tracks with no SPD requierement and without ITSRefit ...
Int_t nptbins
Int_t GetTrackMultiplicityNPtCut() const
TH1F * fhPtNoCut
! pT distribution, no cut
virtual AliMixedEvent * GetMixedEvent() const
TH2F * fhTrackResolution
! track resolution sigma pT vs pT, ESDs
const Double_t phimin