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