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