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