]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
changed methods in AliAODPWG4Particle (G. Conesa)
[u/mrichter/AliRoot.git] / PWG4 / JetTasks / AliPWG4HighPtTrackQA.cxx
CommitLineData
d756027f 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//-----------------------------------------------------------------------
17// This class stores QA variables as function of pT for different type
18// of tracks and track selection criteria
19// Output: Histograms for different set of cuts
20//-----------------------------------------------------------------------
21// Author : Marta Verweij - UU
22//-----------------------------------------------------------------------
23
24#ifndef ALIPWG4HIGHPTTRACKQA_CXX
25#define ALIPWG4HIGHPTTRACKQA_CXX
26
27#include "AliPWG4HighPtTrackQA.h"
28
29#include "TH1.h"
30#include "TH2.h"
31#include "TH3.h"
32#include "TProfile.h"
33#include "TList.h"
34#include "TFile.h"
35#include "TChain.h"
36#include "TH3F.h"
37#include "TKey.h"
38#include "TSystem.h"
39#include "TBits.h"
40
41#include "AliAnalysisManager.h"
42#include "AliESDInputHandler.h"
43#include "AliMCEvent.h"
44#include "AliMCEventHandler.h"
45#include "AliStack.h"
46#include "AliESDtrack.h"
47#include "AliESDtrackCuts.h"
48#include "AliExternalTrackParam.h"
49#include "AliLog.h"
50#include "AliGenPythiaEventHeader.h"
51#include "AliGenCocktailEventHeader.h"
52#include "AliCentrality.h"
53#include "AliAODVertex.h"
54#include "AliAODEvent.h"
55//#include "AliAnalysisHelperJetTasks.h"
56
57using namespace std; //required for resolving the 'cout' symbol
58
59ClassImp(AliPWG4HighPtTrackQA)
60
61AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA()
62: AliAnalysisTaskSE(),
63 fDataType(kESD),
64 fEvent(0x0),
65 fESD(0x0),
66 fVtx(0x0),
44684f3b 67 fTrackCuts(0x0),
68 fTrackCutsITSLoose(0x0),
69 fTrackCutsTPConly(0x0),
d756027f 70 fTrackType(0),
71 fFilterMask(0),
aa3ba8d2 72 fSigmaConstrainedMax(-1.),
d756027f 73 fPtMax(100.),
74 fIsPbPb(0),
75 fCentClass(10),
0f76d8ae 76 fNVariables(20),
d756027f 77 fVariables(0x0),
78 fAvgTrials(1),
79 fNEventAll(0),
80 fNEventSel(0),
81 fNEventReject(0),
82 fh1Centrality(0x0),
83 fh1Xsec(0),
84 fh1Trials(0),
85 fh1PtHard(0),
86 fh1PtHardTrials(0),
87 fh1NTracksAll(0x0),
88 fh1NTracksReject(0x0),
89 fh1NTracksSel(0x0),
90 fPtAll(0),
91 fPtSel(0),
92 fPtPhi(0x0),
93 fPtEta(0x0),
94 fPtDCA2D(0x0),
95 fPtDCAZ(0x0),
96 fPtNClustersTPC(0x0),
0f76d8ae 97 fPtNClustersTPCIter1(0x0),
d756027f 98 fPtNPointITS(0x0),
99 fPtChi2C(0x0),
100 fPtNSigmaToVertex(0x0),
101 fPtRelUncertainty1Pt(0x0),
05cb235d 102 fPtRelUncertainty1PtNClus(0x0),
0f76d8ae 103 fPtRelUncertainty1PtNClusIter1(0x0),
05cb235d 104 fPtRelUncertainty1PtChi2(0x0),
0f76d8ae 105 fPtRelUncertainty1PtChi2Iter1(0x0),
106 fPtRelUncertainty1PtPhi(0x0),
05cb235d 107 fPtRelUncertainty1PtTrkLength(0x0),
2b553e6f 108 fPtUncertainty1Pt(0x0),
d756027f 109 fPtChi2PerClusterTPC(0x0),
0f76d8ae 110 fPtChi2PerClusterTPCIter1(0x0),
d756027f 111 fPtNCrossedRows(0x0),
112 fPtNCrossedRowsNClusF(0x0),
113 fPtNCrRNCrRNClusF(0x0),
2b553e6f 114 fPtSigmaY2(0x0),
115 fPtSigmaZ2(0x0),
116 fPtSigmaSnp2(0x0),
117 fPtSigmaTgl2(0x0),
118 fPtSigma1Pt2(0x0),
aa3ba8d2 119 fProfPtSigmaY2(0x0),
120 fProfPtSigmaZ2(0x0),
121 fProfPtSigmaSnp2(0x0),
122 fProfPtSigmaTgl2(0x0),
123 fProfPtSigma1Pt2(0x0),
124 fProfPtSigma1Pt(0x0),
125 fProfPtPtSigma1Pt(0x0),
126 fSystTrackCuts(0x0),
d756027f 127 fHistList(0)
128{
0f76d8ae 129 SetNVariables(20);
aa3ba8d2 130
131 fPtBinEdges[0][0] = 10.;
132 fPtBinEdges[0][1] = 1.;
133 fPtBinEdges[1][0] = 20.;
134 fPtBinEdges[1][1] = 2.;
b1041e3b 135 fPtBinEdges[2][0] = 100.;
aa3ba8d2 136 fPtBinEdges[2][1] = 5.;
137
d756027f 138}
139//________________________________________________________________________
140AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA(const char *name):
141 AliAnalysisTaskSE(name),
142 fDataType(kESD),
143 fEvent(0x0),
144 fESD(0x0),
145 fVtx(0x0),
44684f3b 146 fTrackCuts(0x0),
147 fTrackCutsITSLoose(0x0),
148 fTrackCutsTPConly(0x0),
d756027f 149 fTrackType(0),
150 fFilterMask(0),
aa3ba8d2 151 fSigmaConstrainedMax(-1.),
d756027f 152 fPtMax(100.),
153 fIsPbPb(0),
154 fCentClass(10),
0f76d8ae 155 fNVariables(20),
d756027f 156 fVariables(0x0),
157 fAvgTrials(1),
158 fNEventAll(0),
159 fNEventSel(0),
160 fNEventReject(0),
161 fh1Centrality(0x0),
162 fh1Xsec(0),
163 fh1Trials(0),
164 fh1PtHard(0),
165 fh1PtHardTrials(0),
166 fh1NTracksAll(0x0),
167 fh1NTracksReject(0x0),
168 fh1NTracksSel(0x0),
169 fPtAll(0),
170 fPtSel(0),
171 fPtPhi(0x0),
172 fPtEta(0x0),
173 fPtDCA2D(0x0),
174 fPtDCAZ(0x0),
175 fPtNClustersTPC(0x0),
0f76d8ae 176 fPtNClustersTPCIter1(0x0),
d756027f 177 fPtNPointITS(0x0),
178 fPtChi2C(0x0),
179 fPtNSigmaToVertex(0x0),
180 fPtRelUncertainty1Pt(0x0),
05cb235d 181 fPtRelUncertainty1PtNClus(0x0),
0f76d8ae 182 fPtRelUncertainty1PtNClusIter1(0x0),
05cb235d 183 fPtRelUncertainty1PtChi2(0x0),
0f76d8ae 184 fPtRelUncertainty1PtChi2Iter1(0x0),
185 fPtRelUncertainty1PtPhi(0x0),
05cb235d 186 fPtRelUncertainty1PtTrkLength(0x0),
2b553e6f 187 fPtUncertainty1Pt(0x0),
d756027f 188 fPtChi2PerClusterTPC(0x0),
0f76d8ae 189 fPtChi2PerClusterTPCIter1(0x0),
d756027f 190 fPtNCrossedRows(0x0),
191 fPtNCrossedRowsNClusF(0x0),
192 fPtNCrRNCrRNClusF(0x0),
2b553e6f 193 fPtSigmaY2(0x0),
194 fPtSigmaZ2(0x0),
195 fPtSigmaSnp2(0x0),
196 fPtSigmaTgl2(0x0),
197 fPtSigma1Pt2(0x0),
aa3ba8d2 198 fProfPtSigmaY2(0x0),
199 fProfPtSigmaZ2(0x0),
200 fProfPtSigmaSnp2(0x0),
201 fProfPtSigmaTgl2(0x0),
202 fProfPtSigma1Pt2(0x0),
203 fProfPtSigma1Pt(0x0),
204 fProfPtPtSigma1Pt(0x0),
205 fSystTrackCuts(0x0),
d756027f 206 fHistList(0)
207{
208 //
209 // Constructor. Initialization of Inputs and Outputs
210 //
211 AliDebug(2,Form("AliPWG4HighPtTrackQA Calling Constructor"));
212
0f76d8ae 213 SetNVariables(20);
d756027f 214
aa3ba8d2 215 fPtBinEdges[0][0] = 10.;
216 fPtBinEdges[0][1] = 1.;
217 fPtBinEdges[1][0] = 20.;
218 fPtBinEdges[1][1] = 2.;
b1041e3b 219 fPtBinEdges[2][0] = 100.;
aa3ba8d2 220 fPtBinEdges[2][1] = 5.;
221
d756027f 222 // Input slot #0 works with a TChain ESD
223 DefineInput(0, TChain::Class());
224 // Output slot #1 write into a TList
225 DefineOutput(1, TList::Class());
226}
227
aa3ba8d2 228//________________________________________________________________________
229void AliPWG4HighPtTrackQA::SetPtBinEdges(Int_t region, Double_t ptmax, Double_t ptBinWidth) {
230
231 if(region<3) {
232 fPtBinEdges[region][0] = ptmax;
233 fPtBinEdges[region][1] = ptBinWidth;
234 }
235 else {
236 AliError("Only 3 regions alowed. Use region 0/1/2\n");
237 return;
238 }
239
240}
241
d756027f 242//________________________________________________________________________
243void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
244 //Create output objects
245 AliDebug(2,Form(">> AliPWG4HighPtTrackQA::UserCreateOutputObjects \n"));
246
247 Bool_t oldStatus = TH1::AddDirectoryStatus();
248 TH1::AddDirectory(kFALSE);
249
250 OpenFile(1);
251 fHistList = new TList();
252 fHistList->SetOwner(kTRUE);
253
254 Float_t fgkPtMin = 0.;
59869f97 255 // Float_t fgkPtMax = fPtMax;
d756027f 256
aa3ba8d2 257 //fPtBinEdges[region][0] = ptmax of region ; fPtBinEdges[region][1] = binWidth of region
d756027f 258 const Float_t ptmin1 = fgkPtMin;
aa3ba8d2 259 const Float_t ptmax1 = fPtBinEdges[0][0];
d756027f 260 const Float_t ptmin2 = ptmax1 ;
aa3ba8d2 261 const Float_t ptmax2 = fPtBinEdges[1][0];
d756027f 262 const Float_t ptmin3 = ptmax2 ;
b1041e3b 263 const Float_t ptmax3 = fPtBinEdges[2][0];//fgkPtMax;
aa3ba8d2 264 const Int_t nbin11 = (int)((ptmax1-ptmin1)/fPtBinEdges[0][1]);
265 const Int_t nbin12 = (int)((ptmax2-ptmin2)/fPtBinEdges[1][1])+nbin11;
2793fe00 266 const Int_t nbin13 = (int)((ptmax3-ptmin3)/fPtBinEdges[2][1])+nbin12;
d756027f 267 Int_t fgkNPtBins=nbin13;
268 //Create array with low edges of each bin
269 Double_t *binsPt=new Double_t[fgkNPtBins+1];
270 for(Int_t i=0; i<=fgkNPtBins; i++) {
271 if(i<=nbin11) binsPt[i]=(Double_t)ptmin1 + (ptmax1-ptmin1)/nbin11*(Double_t)i ;
272 if(i<=nbin12 && i>nbin11) binsPt[i]=(Double_t)ptmin2 + (ptmax2-ptmin2)/(nbin12-nbin11)*((Double_t)i-(Double_t)nbin11) ;
273 if(i<=nbin13 && i>nbin12) binsPt[i]=(Double_t)ptmin3 + (ptmax3-ptmin3)/(nbin13-nbin12)*((Double_t)i-(Double_t)nbin12) ;
274 }
275
276 Int_t fgkNPhiBins = 18*6;
277 Float_t kMinPhi = 0.;
278 Float_t kMaxPhi = 2.*TMath::Pi();
279 Double_t *binsPhi = new Double_t[fgkNPhiBins+1];
280 for(Int_t i=0; i<=fgkNPhiBins; i++) binsPhi[i]=(Double_t)kMinPhi + (kMaxPhi-kMinPhi)/fgkNPhiBins*(Double_t)i ;
281
282 Int_t fgkNEtaBins=20;
283 Float_t fgkEtaMin = -1.;
284 Float_t fgkEtaMax = 1.;
285 Double_t *binsEta=new Double_t[fgkNEtaBins+1];
286 for(Int_t i=0; i<=fgkNEtaBins; i++) binsEta[i]=(Double_t)fgkEtaMin + (fgkEtaMax-fgkEtaMin)/fgkNEtaBins*(Double_t)i ;
287
288 Int_t fgkNNClustersTPCBins=80;
289 Float_t fgkNClustersTPCMin = 0.5;
290 Float_t fgkNClustersTPCMax = 160.5;
291 Double_t *binsNClustersTPC=new Double_t[fgkNNClustersTPCBins+1];
292 for(Int_t i=0; i<=fgkNNClustersTPCBins; i++) binsNClustersTPC[i]=(Double_t)fgkNClustersTPCMin + (fgkNClustersTPCMax-fgkNClustersTPCMin)/fgkNNClustersTPCBins*(Double_t)i ;
293
294 Int_t fgkNDCA2DBins=80;
295 Float_t fgkDCA2DMin = -0.2;
296 Float_t fgkDCA2DMax = 0.2;
aa3ba8d2 297 if(fTrackType==1 || fTrackType==2 || fTrackType==4) {
2b553e6f 298 fgkDCA2DMin = -2.;
299 fgkDCA2DMax = 2.;
300 }
d756027f 301 Double_t *binsDCA2D=new Double_t[fgkNDCA2DBins+1];
302 for(Int_t i=0; i<=fgkNDCA2DBins; i++) binsDCA2D[i]=(Double_t)fgkDCA2DMin + (fgkDCA2DMax-fgkDCA2DMin)/fgkNDCA2DBins*(Double_t)i ;
303
304 Int_t fgkNDCAZBins=80;
305 Float_t fgkDCAZMin = -2.;
306 Float_t fgkDCAZMax = 2.;
aa3ba8d2 307 if(fTrackType==1 || fTrackType==2 || fTrackType==4) {
2b553e6f 308 fgkDCAZMin = -5.;
309 fgkDCAZMax = 5.;
310 }
d756027f 311 Double_t *binsDCAZ=new Double_t[fgkNDCAZBins+1];
312 for(Int_t i=0; i<=fgkNDCAZBins; i++) binsDCAZ[i]=(Double_t)fgkDCAZMin + (fgkDCAZMax-fgkDCAZMin)/fgkNDCAZBins*(Double_t)i ;
313
314 Int_t fgkNNPointITSBins=9;
315 Float_t fgkNPointITSMin = -0.5;
316 Float_t fgkNPointITSMax = 8.5;
317 Double_t *binsNPointITS=new Double_t[fgkNNPointITSBins+1];
318 for(Int_t i=0; i<=fgkNNPointITSBins; i++) binsNPointITS[i]=(Double_t)fgkNPointITSMin + (fgkNPointITSMax-fgkNPointITSMin)/fgkNNPointITSBins*(Double_t)i ;
319
0f76d8ae 320 Int_t fgkNNSigmaToVertexBins=20;
d756027f 321 Float_t fgkNSigmaToVertexMin = 0.;
322 Float_t fgkNSigmaToVertexMax = 8.;
323 Double_t *binsNSigmaToVertex=new Double_t[fgkNNSigmaToVertexBins+1];
324 for(Int_t i=0; i<=fgkNNSigmaToVertexBins; i++) binsNSigmaToVertex[i]=(Double_t)fgkNSigmaToVertexMin + (fgkNSigmaToVertexMax-fgkNSigmaToVertexMin)/fgkNNSigmaToVertexBins*(Double_t)i ;
325
326 Int_t fgkNChi2CBins=20;
327 Float_t fgkChi2CMin = 0.;
2b553e6f 328 Float_t fgkChi2CMax = 100.;
d756027f 329 Double_t *binsChi2C=new Double_t[fgkNChi2CBins+1];
330 for(Int_t i=0; i<=fgkNChi2CBins; i++) binsChi2C[i]=(Double_t)fgkChi2CMin + (fgkChi2CMax-fgkChi2CMin)/fgkNChi2CBins*(Double_t)i ;
331
332 Int_t fgkNRel1PtUncertaintyBins=30;
333 Float_t fgkRel1PtUncertaintyMin = 0.;
334 Float_t fgkRel1PtUncertaintyMax = 0.3;
c3ff0a6e 335 if(fTrackType!=0 && fTrackType!=3) {
0f76d8ae 336 fgkNRel1PtUncertaintyBins = 50;
337 fgkRel1PtUncertaintyMax = 1.;
338 }
d756027f 339 Double_t *binsRel1PtUncertainty=new Double_t[fgkNRel1PtUncertaintyBins+1];
340 for(Int_t i=0; i<=fgkNRel1PtUncertaintyBins; i++) binsRel1PtUncertainty[i]=(Double_t)fgkRel1PtUncertaintyMin + (fgkRel1PtUncertaintyMax-fgkRel1PtUncertaintyMin)/fgkNRel1PtUncertaintyBins*(Double_t)i ;
341
2b553e6f 342 Int_t fgkNUncertainty1PtBins = 30;
343 Float_t fgkUncertainty1PtMin = 0.;
344 Float_t fgkUncertainty1PtMax = 0.1;
aa3ba8d2 345 if(fTrackType==1 || fTrackType==2 || fTrackType==4)
346 fgkUncertainty1PtMax = 0.2;
2b553e6f 347 Double_t *binsUncertainty1Pt=new Double_t[fgkNUncertainty1PtBins+1];
348 for(Int_t i=0; i<=fgkNUncertainty1PtBins; i++) binsUncertainty1Pt[i]=(Double_t)fgkUncertainty1PtMin + (fgkUncertainty1PtMax-fgkUncertainty1PtMin)/fgkNUncertainty1PtBins*(Double_t)i ;
349
d756027f 350 Float_t fgkChi2PerClusMin = 0.;
351 Float_t fgkChi2PerClusMax = 4.;
352 Int_t fgkNChi2PerClusBins = (int)(fgkChi2PerClusMax*10.);
353 Double_t *binsChi2PerClus=new Double_t[fgkNChi2PerClusBins+1];
354 for(Int_t i=0; i<=fgkNChi2PerClusBins; i++) binsChi2PerClus[i]=(Double_t)fgkChi2PerClusMin + (fgkChi2PerClusMax-fgkChi2PerClusMin)/fgkNChi2PerClusBins*(Double_t)i ;
355
356 Int_t fgkNCrossedRowsNClusFBins = 50;
357 Float_t fgkNCrossedRowsNClusFMin = 0.;
358 Float_t fgkNCrossedRowsNClusFMax = 1.;
359 Double_t *binsNCrossedRowsNClusF=new Double_t[fgkNCrossedRowsNClusFBins+1];
360 for(Int_t i=0; i<=fgkNCrossedRowsNClusFBins; i++) binsNCrossedRowsNClusF[i]=(Double_t)fgkNCrossedRowsNClusFMin + (fgkNCrossedRowsNClusFMax-fgkNCrossedRowsNClusFMin)/fgkNCrossedRowsNClusFBins*(Double_t)i ;
361
2b553e6f 362 Float_t fgk1PtMin = 0.;
363 Float_t fgk1PtMax = 6.;
aa3ba8d2 364 Float_t binEdge1Pt1 = 1.;
365 Float_t binWidth1Pt1 = 0.05;
366 Int_t fgkN1PtBins1 = (int)((binEdge1Pt1-fgk1PtMin)/binWidth1Pt1);
367 Float_t binWidth1Pt2 = 0.1;
368 Int_t fgkN1PtBins2 = (int)((fgk1PtMax-binEdge1Pt1)/binWidth1Pt2);
369 Int_t fgkN1PtBins = fgkN1PtBins1+fgkN1PtBins2;
2b553e6f 370 Double_t *bins1Pt=new Double_t[fgkN1PtBins+1];
aa3ba8d2 371
372 for(Int_t i=0; i<=fgkN1PtBins; i++) {
373 if(i<=fgkN1PtBins1)
374 bins1Pt[i]=(Double_t)fgk1PtMin + (Double_t)(binEdge1Pt1-fgk1PtMin)/(Double_t)fgkN1PtBins1*(Double_t)i;
375 if(i<=fgkN1PtBins && i>fgkN1PtBins1)
376 bins1Pt[i]=(Double_t)binEdge1Pt1 + (Double_t)(fgk1PtMax-binEdge1Pt1)/(Double_t)fgkN1PtBins2*(Double_t)(i-fgkN1PtBins1);
377 }
2b553e6f 378
379 Int_t fgkNSigmaY2Bins = 50;
380 Float_t fgkSigmaY2Min = 0.;
aa3ba8d2 381 Float_t fgkSigmaY2Max = 1.;
382 if(fTrackType==1) fgkSigmaY2Max = 4.;
383 if(fTrackType==2 || fTrackType==4) fgkSigmaY2Max = 0.1;
2b553e6f 384 Double_t *binsSigmaY2=new Double_t[fgkNSigmaY2Bins+1];
385 for(Int_t i=0; i<=fgkNSigmaY2Bins; i++) binsSigmaY2[i]=(Double_t)fgkSigmaY2Min + (fgkSigmaY2Max-fgkSigmaY2Min)/fgkNSigmaY2Bins*(Double_t)i ;
386
387 Int_t fgkNSigmaZ2Bins = 50;
388 Float_t fgkSigmaZ2Min = 0.;
aa3ba8d2 389 Float_t fgkSigmaZ2Max = 0.4;
2b553e6f 390 Double_t *binsSigmaZ2=new Double_t[fgkNSigmaZ2Bins+1];
391 for(Int_t i=0; i<=fgkNSigmaZ2Bins; i++) binsSigmaZ2[i]=(Double_t)fgkSigmaZ2Min + (fgkSigmaZ2Max-fgkSigmaZ2Min)/fgkNSigmaZ2Bins*(Double_t)i ;
392
393 Int_t fgkNSigmaSnp2Bins = 50;
394 Float_t fgkSigmaSnp2Min = 0.;
aa3ba8d2 395 Float_t fgkSigmaSnp2Max = 0.05;
396 if(fTrackType==1) fgkSigmaSnp2Max = 0.2;
397 if(fTrackType==2 || fTrackType==4) fgkSigmaSnp2Max = 0.1;
2b553e6f 398 Double_t *binsSigmaSnp2=new Double_t[fgkNSigmaSnp2Bins+1];
399 for(Int_t i=0; i<=fgkNSigmaSnp2Bins; i++) binsSigmaSnp2[i]=(Double_t)fgkSigmaSnp2Min + (fgkSigmaSnp2Max-fgkSigmaSnp2Min)/fgkNSigmaSnp2Bins*(Double_t)i ;
400
401 Int_t fgkNSigmaTgl2Bins = 50;
402 Float_t fgkSigmaTgl2Min = 0.;
aa3ba8d2 403 Float_t fgkSigmaTgl2Max = 0.1;
404 if(fTrackType==1) fgkSigmaTgl2Max = 0.2;
405 if(fTrackType==2 || fTrackType==4) fgkSigmaTgl2Max = 0.1;
2b553e6f 406 Double_t *binsSigmaTgl2=new Double_t[fgkNSigmaTgl2Bins+1];
407 for(Int_t i=0; i<=fgkNSigmaTgl2Bins; i++) binsSigmaTgl2[i]=(Double_t)fgkSigmaTgl2Min + (fgkSigmaTgl2Max-fgkSigmaTgl2Min)/fgkNSigmaTgl2Bins*(Double_t)i ;
408
409 Int_t fgkNSigma1Pt2Bins = 50;
410 Float_t fgkSigma1Pt2Min = 0.;
aa3ba8d2 411 Float_t fgkSigma1Pt2Max = 1.;
2b553e6f 412 Double_t *binsSigma1Pt2=new Double_t[fgkNSigma1Pt2Bins+1];
413 for(Int_t i=0; i<=fgkNSigma1Pt2Bins; i++) binsSigma1Pt2[i]=(Double_t)fgkSigma1Pt2Min + (fgkSigma1Pt2Max-fgkSigma1Pt2Min)/fgkNSigma1Pt2Bins*(Double_t)i ;
414
415
d756027f 416 fNEventAll = new TH1F("fNEventAll","NEventAll",1,-0.5,0.5);
417 fHistList->Add(fNEventAll);
418 fNEventSel = new TH1F("fNEventSel","NEvent Selected for analysis",1,-0.5,0.5);
419 fHistList->Add(fNEventSel);
420 fNEventReject = new TH1F("fNEventReject","Reason events are rejectected for analysis",20,0,20);
421 //Set labels
422 fNEventReject->Fill("noESD",0);
423 fNEventReject->Fill("Trigger",0);
424 fNEventReject->Fill("NTracks<2",0);
425 fNEventReject->Fill("noVTX",0);
426 fNEventReject->Fill("VtxStatus",0);
427 fNEventReject->Fill("NCont<2",0);
428 fNEventReject->Fill("ZVTX>10",0);
429 fNEventReject->Fill("cent",0);
430 fNEventReject->Fill("cent>90",0);
431 fHistList->Add(fNEventReject);
432
433 fh1Centrality = new TH1F("fh1Centrality","fh1Centrality; Centrality %",100,0,100);
434 fHistList->Add(fh1Centrality);
435
436 fh1Xsec = new TProfile("fh1Xsec","xsec from pyxsec.root",1,0,1);
437 fh1Xsec->GetXaxis()->SetBinLabel(1,"<#sigma>");
438 fHistList->Add(fh1Xsec);
439
440 fh1Trials = new TH1F("fh1Trials","trials root file",1,0,1);
441 fh1Trials->GetXaxis()->SetBinLabel(1,"#sum{ntrials}");
442 fHistList->Add(fh1Trials);
443
444 fh1PtHard = new TH1F("fh1PtHard","PYTHIA Pt hard;p_{T,hard}",350,-.5,349.5);
445 fHistList->Add(fh1PtHard);
446 fh1PtHardTrials = new TH1F("fh1PtHardTrials","PYTHIA Pt hard weight with trials;p_{T,hard}",350,-.5,349.5);
447 fHistList->Add(fh1PtHardTrials);
448
449 fh1NTracksAll = new TH1F("fh1NTracksAll","fh1NTracksAll",1,-0.5,0.5);
450 fHistList->Add(fh1NTracksAll);
451
452 fh1NTracksReject = new TH1F("fh1NTracksReject","fh1NTracksReject",1,-0.5,0.5);
453 fh1NTracksReject->Fill("noESDtrack",0);
454 fh1NTracksReject->Fill("noTPCInner",0);
455 fh1NTracksReject->Fill("FillTPC",0);
456 fh1NTracksReject->Fill("noTPConly",0);
457 fh1NTracksReject->Fill("relate",0);
458 fh1NTracksReject->Fill("trackCuts",0);
459 fh1NTracksReject->Fill("laser",0);
2b553e6f 460 fh1NTracksReject->Fill("chi2",0);
d756027f 461 fHistList->Add(fh1NTracksReject);
462
463 fh1NTracksSel = new TH1F("fh1NTracksSel","fh1NTracksSel",1,-0.5,0.5);
464 fHistList->Add(fh1NTracksSel);
465
aa3ba8d2 466 fSystTrackCuts = new TH1F("fSystTrackCuts","fSystTrackCuts",1,-0.5,0.5);
467 fSystTrackCuts->Fill("noCut",0);
468 fSystTrackCuts->Fill("eta",0);
469 fSystTrackCuts->Fill("0.15<pT<1e10",0);
470 fSystTrackCuts->Fill("kink",0);
471 fSystTrackCuts->Fill("NClusterTPC",0);
472 fSystTrackCuts->Fill("Chi2PerNClusTPC",0);
473 fSystTrackCuts->Fill("DCA2D",0);
474 fHistList->Add(fSystTrackCuts);
475
d756027f 476
477 fPtAll = new TH1F("fPtAll","PtAll",fgkNPtBins, binsPt);
478 fHistList->Add(fPtAll);
479 fPtSel = new TH1F("fPtSel","PtSel",fgkNPtBins, binsPt);
480 fHistList->Add(fPtSel);
481
482 fPtPhi = new TH2F("fPtPhi","fPtPhi",fgkNPtBins,binsPt,fgkNPhiBins,binsPhi);
483 fHistList->Add(fPtPhi);
484
485 fPtEta = new TH2F("fPtEta","fPtEta",fgkNPtBins,binsPt,fgkNEtaBins,binsEta);
486 fHistList->Add(fPtEta);
487
488 fPtDCA2D = new TH2F("fPtDCA2D","fPtDCA2D",fgkNPtBins,binsPt,fgkNDCA2DBins,binsDCA2D);
489 fHistList->Add(fPtDCA2D);
490
491 fPtDCAZ = new TH2F("fPtDCAZ","fPtDCAZ",fgkNPtBins,binsPt,fgkNDCAZBins,binsDCAZ);
492 fHistList->Add(fPtDCAZ);
493
494 fPtNClustersTPC = new TH2F("fPtNClustersTPC","fPtNClustersTPC",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
495 fHistList->Add(fPtNClustersTPC);
0f76d8ae 496
497 fPtNClustersTPCIter1 = new TH2F("fPtNClustersTPCIter1","fPtNClustersTPCIter1",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
498 fHistList->Add(fPtNClustersTPCIter1);
d756027f 499
500 fPtNPointITS = new TH2F("fPtNPointITS","fPtNPointITS",fgkNPtBins,binsPt,fgkNNPointITSBins,binsNPointITS);
501 fHistList->Add(fPtNPointITS);
502
503 fPtChi2C = new TH2F("fPtChi2C","fPtChi2C",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C);
504 fHistList->Add(fPtChi2C);
505
506 fPtNSigmaToVertex = new TH2F("fPtNSigmaToVertex","fPtNSigmaToVertex",fgkNPtBins,binsPt,fgkNNSigmaToVertexBins,binsNSigmaToVertex);
507 fHistList->Add(fPtNSigmaToVertex);
508
509 fPtRelUncertainty1Pt = new TH2F("fPtRelUncertainty1Pt","fPtRelUncertainty1Pt",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty);
510 fHistList->Add(fPtRelUncertainty1Pt);
2b553e6f 511
05cb235d 512 fPtRelUncertainty1PtNClus = new TH3F("fPtRelUncertainty1PtNClus","fPtRelUncertainty1PtNClus",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
513 fHistList->Add(fPtRelUncertainty1PtNClus);
514
0f76d8ae 515 fPtRelUncertainty1PtNClusIter1 = new TH3F("fPtRelUncertainty1PtNClusIter1","fPtRelUncertainty1PtNClusIter1",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
516 fHistList->Add(fPtRelUncertainty1PtNClusIter1);
517
05cb235d 518 fPtRelUncertainty1PtChi2 = new TH3F("fPtRelUncertainty1PtChi2","fPtRelUncertainty1PtChi2",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNChi2PerClusBins,binsChi2PerClus);
519 fHistList->Add(fPtRelUncertainty1PtChi2);
520
0f76d8ae 521 fPtRelUncertainty1PtChi2Iter1 = new TH3F("fPtRelUncertainty1PtChi2Iter1","fPtRelUncertainty1PtChi2Iter1",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNChi2PerClusBins,binsChi2PerClus);
522 fHistList->Add(fPtRelUncertainty1PtChi2Iter1);
523
524 fPtRelUncertainty1PtPhi = new TH3F("fPtRelUncertainty1PtPhi","fPtRelUncertainty1PtPhi",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNPhiBins,binsPhi);
525 fHistList->Add(fPtRelUncertainty1PtPhi);
526
05cb235d 527 fPtRelUncertainty1PtTrkLength = new TH3F("fPtRelUncertainty1PtTrkLength","fPtRelUncertainty1PtTrkLength",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
528 fHistList->Add(fPtRelUncertainty1PtTrkLength);
529
2b553e6f 530 fPtUncertainty1Pt = new TH2F("fPtUncertainty1Pt","fPtUncertainty1Pt",fgkNPtBins,binsPt,fgkNUncertainty1PtBins,binsUncertainty1Pt);
531 fHistList->Add(fPtUncertainty1Pt);
d756027f 532
533 fPtChi2PerClusterTPC = new TH2F("fPtChi2PerClusterTPC","fPtChi2PerClusterTPC",fgkNPtBins,binsPt,fgkNChi2PerClusBins,binsChi2PerClus);
534 fHistList->Add(fPtChi2PerClusterTPC);
0f76d8ae 535
536 fPtChi2PerClusterTPCIter1 = new TH2F("fPtChi2PerClusterTPCIter1","fPtChi2PerClusterTPCIter1",fgkNPtBins,binsPt,fgkNChi2PerClusBins,binsChi2PerClus);
537 fHistList->Add(fPtChi2PerClusterTPCIter1);
d756027f 538
539 fPtNCrossedRows = new TH2F("fPtNCrossedRows","fPtNCrossedRows",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
540 fHistList->Add(fPtNCrossedRows);
541
542 fPtNCrossedRowsNClusF = new TH2F("fPtNCrossedRowsNClusF","fPtNCrossedRowsNClusF",fgkNPtBins,binsPt,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF);
543 fHistList->Add(fPtNCrossedRowsNClusF);
544
545 fPtNCrRNCrRNClusF = new TH3F("fPtNCrRNCrRNClusF","fPtNCrRNCrRNClusF",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF);
546 fHistList->Add(fPtNCrRNCrRNClusF);
2b553e6f 547
aa3ba8d2 548 fPtSigmaY2 = new TH2F("fPtSigmaY2","fPtSigmaY2",fgkN1PtBins,bins1Pt,fgkNSigmaY2Bins,binsSigmaY2);
2b553e6f 549 fHistList->Add(fPtSigmaY2);
550
551 fPtSigmaZ2 = new TH2F("fPtSigmaZ2","fPtSigmaZ2",fgkN1PtBins,bins1Pt,fgkNSigmaZ2Bins,binsSigmaZ2);
552 fHistList->Add(fPtSigmaZ2);
553
aa3ba8d2 554 fPtSigmaSnp2 = new TH2F("fPtSigmaSnp2","fPtSigmaSnp2",fgkN1PtBins,bins1Pt,fgkNSigmaSnp2Bins,binsSigmaSnp2);
2b553e6f 555 fHistList->Add(fPtSigmaSnp2);
556
aa3ba8d2 557 fPtSigmaTgl2 = new TH2F("fPtSigmaTgl2","fPtSigmaTgl2",fgkN1PtBins,bins1Pt,fgkNSigmaTgl2Bins,binsSigmaTgl2);
2b553e6f 558 fHistList->Add(fPtSigmaTgl2);
559
aa3ba8d2 560 fPtSigma1Pt2 = new TH2F("fPtSigma1Pt2","fPtSigma1Pt2",fgkN1PtBins,bins1Pt,fgkNSigma1Pt2Bins,binsSigma1Pt2);
2b553e6f 561 fHistList->Add(fPtSigma1Pt2);
562
aa3ba8d2 563 fProfPtSigmaY2 = new TProfile("fProfPtSigmaY2","fProfPtSigmaY2",fgkN1PtBins,bins1Pt);
564 fHistList->Add(fProfPtSigmaY2);
565
566 fProfPtSigmaZ2 = new TProfile("fProfPtSigmaZ2","fProfPtSigmaZ2",fgkN1PtBins,bins1Pt);
567 fHistList->Add(fProfPtSigmaZ2);
568
569 fProfPtSigmaSnp2 = new TProfile("fProfPtSigmaSnp2","fProfPtSigmaSnp2",fgkN1PtBins,bins1Pt);
570 fHistList->Add(fProfPtSigmaSnp2);
571
572 fProfPtSigmaTgl2 = new TProfile("fProfPtSigmaTgl2","fProfPtSigmaTgl2",fgkN1PtBins,bins1Pt);
573 fHistList->Add(fProfPtSigmaTgl2);
574
575 fProfPtSigma1Pt2 = new TProfile("fProfPtSigma1Pt2","fProfPtSigma1Pt2",fgkN1PtBins,bins1Pt);
576 fHistList->Add(fProfPtSigma1Pt2);
577
578 fProfPtSigma1Pt = new TProfile("fProfPtSigma1Pt","fProfPtSigma1Pt;p_{T};#sigma(1/p_{T})",fgkNPtBins,binsPt);
579 fHistList->Add(fProfPtSigma1Pt);
580
581 fProfPtPtSigma1Pt = new TProfile("fProfPtPtSigma1Pt","fProfPtPtSigma1Pt;p_{T};p_{T}#sigma(1/p_{T})",fgkNPtBins,binsPt);
582 fHistList->Add(fProfPtPtSigma1Pt);
583
d756027f 584 TH1::AddDirectory(oldStatus);
585
586 PostData(1, fHistList);
587
588 if(binsPhi) delete [] binsPhi;
589 if(binsPt) delete [] binsPt;
590 if(binsNClustersTPC) delete [] binsNClustersTPC;
591 if(binsDCA2D) delete [] binsDCA2D;
592 if(binsDCAZ) delete [] binsDCAZ;
593 if(binsNPointITS) delete [] binsNPointITS;
594 if(binsNSigmaToVertex) delete [] binsNSigmaToVertex;
595 if(binsChi2C) delete [] binsChi2C;
596 if(binsEta) delete [] binsEta;
597 if(binsRel1PtUncertainty) delete [] binsRel1PtUncertainty;
2b553e6f 598 if(binsUncertainty1Pt) delete [] binsUncertainty1Pt;
d756027f 599 if(binsChi2PerClus) delete [] binsChi2PerClus;
600 if(binsChi2PerClus) delete [] binsNCrossedRowsNClusF;
2b553e6f 601 if(bins1Pt) delete [] bins1Pt;
602 if(binsSigmaY2) delete [] binsSigmaY2;
603 if(binsSigmaZ2) delete [] binsSigmaZ2;
604 if(binsSigmaSnp2) delete [] binsSigmaSnp2;
605 if(binsSigmaTgl2) delete [] binsSigmaTgl2;
606 if(binsSigma1Pt2) delete [] binsSigma1Pt2;
d756027f 607}
608
609//________________________________________________________________________
610Bool_t AliPWG4HighPtTrackQA::SelectEvent() {
611 //
612 // Decide if event should be selected for analysis
613 //
614
615 // Checks following requirements:
616 // - fEvent available
617 // - trigger info from AliPhysicsSelection
618 // - MCevent available
619 // - number of reconstructed tracks > 1
620 // - primary vertex reconstructed
621 // - z-vertex < 10 cm
622 // - centrality in case of PbPb
623
624 Bool_t selectEvent = kTRUE;
625
626 //fEvent object available?
627 if (!fEvent) {
628 AliDebug(2,Form("ERROR: fInputEvent not available\n"));
629 fNEventReject->Fill("noAliVEvent",1);
630 selectEvent = kFALSE;
631 return selectEvent;
632 }
633
634 //Check if number of reconstructed tracks is larger than 1
635 if(!fEvent->GetNumberOfTracks() || fEvent->GetNumberOfTracks()<2) {
636 fNEventReject->Fill("NTracks<2",1);
637 selectEvent = kFALSE;
638 return selectEvent;
639 }
640
641 //Check if vertex is reconstructed
1ea145ef 642 if(fDataType==kESD&&dynamic_cast<AliESDEvent*>(fEvent)) {
643 fVtx = ((AliESDEvent*)fEvent)->GetPrimaryVertexSPD();
d756027f 644
645 if(!fVtx) {
646 fNEventReject->Fill("noVTX",1);
647 selectEvent = kFALSE;
648 return selectEvent;
649 }
650
651 if(!fVtx->GetStatus()) {
652 fNEventReject->Fill("VtxStatus",1);
653 selectEvent = kFALSE;
654 return selectEvent;
655 }
656
657 // Need vertex cut
658 if(fVtx->GetNContributors()<2) {
659 fNEventReject->Fill("NCont<2",1);
660 selectEvent = kFALSE;
661 return selectEvent;
662 }
663
664 //Check if z-vertex < 10 cm
665 double primVtx[3];
666 fVtx->GetXYZ(primVtx);
667 if(TMath::Sqrt(primVtx[0]*primVtx[0] + primVtx[1]*primVtx[1])>1. || TMath::Abs(primVtx[2]>10.)){
668 fNEventReject->Fill("ZVTX>10",1);
669 selectEvent = kFALSE;
670 return selectEvent;
671 }
672 }
1ea145ef 673 else if(fDataType==kAOD&&dynamic_cast<AliAODEvent*>(fEvent)) {
674 const AliAODVertex *vtx = ((AliAODEvent*)fEvent)->GetPrimaryVertexSPD();
d756027f 675 if(!vtx) {
676 fNEventReject->Fill("noVTX",1);
677 selectEvent = kFALSE;
678 return selectEvent;
679 }
680
681 // Need vertex cut
682 if(vtx->GetNContributors()<2) {
683 fNEventReject->Fill("NCont<2",1);
684 selectEvent = kFALSE;
685 return selectEvent;
686 }
687
688 //Check if z-vertex < 10 cm
689 double primVtx[3];
690 vtx->GetXYZ(primVtx);
691 if(TMath::Sqrt(primVtx[0]*primVtx[0] + primVtx[1]*primVtx[1])>1. || TMath::Abs(primVtx[2]>10.)){
692 fNEventReject->Fill("ZVTX>10",1);
693 selectEvent = kFALSE;
694 return selectEvent;
695 }
696
697 }
698
699 //Centrality selection should only be done in case of PbPb
700 if(IsPbPb()) {
701 Float_t cent = 0.;
702 if(fCentClass!=CalculateCentrality(fEvent) && fCentClass!=10) {
703 fNEventReject->Fill("cent",1);
704 selectEvent = kFALSE;
705 return selectEvent;
706 }
707 else {
708 if(fDataType==kESD) {
709 if(dynamic_cast<AliESDEvent*>(fEvent)->GetCentrality()) {
710 cent = dynamic_cast<AliESDEvent*>(fEvent)->GetCentrality()->GetCentralityPercentile("V0M");
711 }
712 }
713 else if(fDataType==kAOD) {
714 if(dynamic_cast<AliAODEvent*>(fEvent)->GetHeader()->GetCentrality())
715 cent = dynamic_cast<AliAODEvent*>(fEvent)->GetHeader()->GetCentrality();
716 }
717 if(cent>90.) {
718 fNEventReject->Fill("cent>90",1);
719 selectEvent = kFALSE;
720 return selectEvent;
721 }
722 fh1Centrality->Fill(cent);
723 }
724 }
725
726 return selectEvent;
727
728}
729
730//________________________________________________________________________
731Int_t AliPWG4HighPtTrackQA::CalculateCentrality(AliVEvent *ev){
669e2312 732 //
733 // Get centrality from ESD or AOD
734 //
735
d756027f 736 if(fDataType==kESD)
737 return CalculateCentrality(dynamic_cast<AliESDEvent*>(ev));
738 else if(fDataType==kAOD)
739 return CalculateCentrality(dynamic_cast<AliAODEvent*>(ev));
740 else
741 return 5;
742}
743
744//________________________________________________________________________
745Int_t AliPWG4HighPtTrackQA::CalculateCentrality(AliESDEvent *esd){
669e2312 746 //
747 // Get centrality from ESD
748 //
d756027f 749
669e2312 750 Float_t cent = -1;
1ea145ef 751
752 if(esd){
753 if(esd->GetCentrality()){
754 cent = esd->GetCentrality()->GetCentralityPercentile("V0M");
669e2312 755 if(fDebug>3) printf("centrality: %f\n",cent);
1ea145ef 756 }
d756027f 757 }
758
669e2312 759 return GetCentralityClass(cent);
d756027f 760
761}
762
763//________________________________________________________________________
764Int_t AliPWG4HighPtTrackQA::CalculateCentrality(AliAODEvent *aod){
669e2312 765 //
766 // Get centrality from AOD
767 //
d756027f 768
669e2312 769 if(!aod) return 5;
d756027f 770 Float_t cent = aod->GetHeader()->GetCentrality();
669e2312 771 if(fDebug>3) printf("centrality: %f\n",cent);
772
773 return GetCentralityClass(cent);
774
775}
776
777//________________________________________________________________________
778Int_t AliPWG4HighPtTrackQA::GetCentralityClass(Float_t cent) {
779 //
780 // Get centrality class
781 //
782
783 if(cent<0) return 5; // OB - cent sometimes negative
784 if(cent>80) return 4;
785 if(cent>50) return 3;
786 if(cent>30) return 2;
787 if(cent>10) return 1;
d756027f 788 return 0;
789
790}
791
792//________________________________________________________________________
793void AliPWG4HighPtTrackQA::UserExec(Option_t *) {
794 // Main loop
795 // Called for each event
796 AliDebug(2,Form(">> AliPWG4HighPtTrackQA::UserExec \n"));
797
798 fEvent = InputEvent();
799 fESD = dynamic_cast<AliESDEvent*>(InputEvent());
800
801 // All events without selection
802 fNEventAll->Fill(0.);
803
804 if(!SelectEvent()) {
805 // Post output data
806 PostData(1, fHistList);
807 return;
808 }
809
810
811 //Need to keep track of selected events
812 fNEventSel->Fill(0.);
813
814 fVariables = new TArrayF(fNVariables);
815
816 if(fDataType==kESD) DoAnalysisESD();
817 if(fDataType==kAOD) DoAnalysisAOD();
818
819 //Delete old fVariables
820 if(fVariables) delete fVariables;
821
822 // Post output data
823 PostData(1, fHistList);
824
825}
826
827//________________________________________________________________________
828void AliPWG4HighPtTrackQA::DoAnalysisESD() {
05cb235d 829 //
830 // Run analysis on ESD
831 //
d756027f 832
833 if(!fESD) {
834 PostData(1, fHistList);
835 return;
836 }
837
838 // ---- Get MC Header information (for MC productions in pThard bins) ----
839 Double_t ptHard = 0.;
840 Double_t nTrials = 1; // trials for MC trigger weight for real data
841
842 AliMCEventHandler *eventHandlerMC = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
843 if (eventHandlerMC) {
844
845 if(eventHandlerMC->MCEvent()){
846 AliGenPythiaEventHeader* pythiaGenHeader = GetPythiaEventHeader(eventHandlerMC->MCEvent());
847 if(pythiaGenHeader){
848 nTrials = pythiaGenHeader->Trials();
849 ptHard = pythiaGenHeader->GetPtHard();
850
851 fh1PtHard->Fill(ptHard);
852 fh1PtHardTrials->Fill(ptHard,nTrials);
853
854 fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
855 }
856 }
857 }
858
859 Int_t nTracks = fESD->GetNumberOfTracks();
860 AliDebug(2,Form("nTracks ESD%d", nTracks));
861
862 /*
863 Variables to be put in fVariables
864 0: pt
865 1: phi
866 2: eta
867 3: dca2D
868 4: dcaZ
869 5: nClustersTPC
870 6: nPointITS
871 7: chi2C
872 8: nSigmaToVertex
05cb235d 873 9: trackLengthTPC
d756027f 874 10: chi2PerClusterTPC
875 11: #crossed rows
876 12: (#crossed rows)/(#findable clusters)
2b553e6f 877 13: SigmaY2
878 14: SigmaZ2
879 15: SigmaSnp2
880 16: SigmaTgl2
881 17: Sigma1Pt2
0f76d8ae 882 18: NClustersTPCIter1
883 19: Chi2TPCIter1
d756027f 884 */
885
886 for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
887 fh1NTracksAll->Fill(0.);
888
889 //Get track for analysis
2b553e6f 890 AliESDtrack *track = 0x0;
d756027f 891 AliESDtrack *esdtrack = fESD->GetTrack(iTrack);
892 if(!esdtrack) {
893 fh1NTracksReject->Fill("noESDtrack",1);
894 continue;
895 }
896
aa3ba8d2 897 if(fTrackType==4) {
898 FillSystematicCutHist(esdtrack);
899 if (!(fTrackCuts->AcceptTrack(esdtrack))) {
900 fh1NTracksReject->Fill("trackCuts",1);
901 continue;
902 }
903 }
904
d756027f 905 if(fTrackType==1)
906 track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
aa3ba8d2 907 else if(fTrackType==2 || fTrackType==4) {
d756027f 908 track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
909 if(!track) {
910 fh1NTracksReject->Fill("noTPConly",1);
d756027f 911 continue;
912 }
913 AliExternalTrackParam exParam;
914 Bool_t relate = track->RelateToVertexTPC(fVtx,fESD->GetMagneticField(),kVeryBig,&exParam);
915 if( !relate ) {
916 fh1NTracksReject->Fill("relate",1);
fb4a2fc7 917 if(track) delete track;
d756027f 918 continue;
919 }
920 track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
921 }
44684f3b 922 else if(fTrackType==5 || fTrackType==6) {
923 if(fTrackCuts->AcceptTrack(esdtrack)) {
924 continue;
925 }
926 else {
927 if( !(fTrackCutsITSLoose->AcceptTrack(esdtrack)) && fTrackCutsTPConly->AcceptTrack(esdtrack) ) {
928
929 if(fTrackType==5) {
930 //use TPConly constrained track
931 track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
2bdab66e 932 if(!track) {
933 fh1NTracksReject->Fill("noTPConly",1);
934 continue;
935 }
44684f3b 936 AliExternalTrackParam exParam;
937 Bool_t relate = track->RelateToVertexTPC(fVtx,fESD->GetMagneticField(),kVeryBig,&exParam);
938 if( !relate ) {
939 fh1NTracksReject->Fill("relate",1);
fb4a2fc7 940 if(track) delete track;
44684f3b 941 continue;
942 }
943 track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
944 }
945 else if(fTrackType==6) {
946 //use global constrained track
fb4a2fc7 947 track = esdtrack;
44684f3b 948 track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
949
950 }
951 }
952 }
953 }
d3a3f33d 954 else if(fTrackType==7) {
955 //use global constrained track
956 track = esdtrack;
031aac8e 957 // track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
d3a3f33d 958 }
d756027f 959 else
960 track = esdtrack;
961
962 if(!track) {
d756027f 963 continue;
964 }
965
fb4a2fc7 966 if(fTrackType==2 || fTrackType==4 || fTrackType==5) {
2b553e6f 967 //Cut on chi2 of constrained fit
aa3ba8d2 968 if(track->GetConstrainedChi2TPC() > fSigmaConstrainedMax*fSigmaConstrainedMax && fSigmaConstrainedMax>0.) {
2b553e6f 969 fh1NTracksReject->Fill("chi2",1);
fb4a2fc7 970 if(track) delete track;
2b553e6f 971 continue;
972 }
973 }
974
aa3ba8d2 975 if(fTrackType!=4)
976 FillSystematicCutHist(track);
977
d756027f 978 fPtAll->Fill(track->Pt());
979
44684f3b 980 if (!(fTrackCuts->AcceptTrack(track)) && fTrackType!=4 && fTrackType!=5 && fTrackType!=6) {
d756027f 981 fh1NTracksReject->Fill("trackCuts",1);
fb4a2fc7 982 if(fTrackType==1 || fTrackType==2) {
983 if(track) delete track;
984 }
d756027f 985 continue;
986 }
aa3ba8d2 987
031aac8e 988 if(fTrackType==7) {
989 if(esdtrack->GetConstrainedParam())
990 track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
991 else
992 continue;
993 }
994
d756027f 995 fh1NTracksSel->Fill(0.);
996
997 fVariables->Reset(0.);
998
2b553e6f 999 fVariables->SetAt(track->Pt(),0);
1000 fVariables->SetAt(track->Phi(),1);
1001 fVariables->SetAt(track->Eta(),2);
d756027f 1002
1003 Float_t dca2D = 0.;
1004 Float_t dcaz = 0.;
031aac8e 1005
1006 if(fTrackType==1 || fTrackType==2 || fTrackType==4) {
1007 track->GetImpactParametersTPC(dca2D,dcaz); //TPConly
d756027f 1008 }
031aac8e 1009 else
1010 track->GetImpactParameters(dca2D,dcaz); //Global
1011
d756027f 1012 fVariables->SetAt(dca2D,3);
aa3ba8d2 1013 fVariables->SetAt(dcaz,5);
d756027f 1014
1015 fVariables->SetAt((float)track->GetTPCNcls(),5);
1016
1017 Int_t nPointITS = 0;
1018 UChar_t itsMap = track->GetITSClusterMap();
1019 for (Int_t i=0; i < 6; i++) {
1020 if (itsMap & (1 << i))
1021 nPointITS ++;
1022 }
1023 fVariables->SetAt((float)nPointITS,6);
2b553e6f 1024 Float_t chi2C = (float)track->GetConstrainedChi2();
aa3ba8d2 1025 if(fTrackType==1 || fTrackType==2 || fTrackType==4)
2b553e6f 1026 chi2C = (float)track->GetConstrainedChi2TPC();
1027 fVariables->SetAt(chi2C,7);
d756027f 1028 fVariables->SetAt(fTrackCuts->GetSigmaToVertex(track),8);// Calculates the number of sigma to the vertex for a track.
1029
05cb235d 1030 fVariables->SetAt(GetTrackLengthTPC(track),9);
d756027f 1031
1032 if(fVariables->At(5)>0.) fVariables->SetAt(track->GetTPCchi2()/fVariables->At(5),10);
1033
d756027f 1034 fVariables->SetAt(track->GetTPCClusterInfo(2,1),11); //#crossed rows
44684f3b 1035 Float_t crossedRowsTPCNClsF = 1.;//track->GetTPCClusterInfo(2,0);
1036 if(track->GetTPCNclsF()>0.) crossedRowsTPCNClsF = fVariables->At(11)/track->GetTPCNclsF();
d756027f 1037 fVariables->SetAt(crossedRowsTPCNClsF,12);//(#crossed rows)/(#findable clusters)
2b553e6f 1038 fVariables->SetAt(track->GetSigmaY2(),13);
1039 fVariables->SetAt(track->GetSigmaZ2(),14);
1040 fVariables->SetAt(track->GetSigmaSnp2(),15);
1041 fVariables->SetAt(track->GetSigmaTgl2(),16);
1042 fVariables->SetAt(track->GetSigma1Pt2(),17);
0f76d8ae 1043
1044 fVariables->SetAt(track->GetTPCNclsIter1(),18);
1045 fVariables->SetAt(track->GetTPCchi2Iter1(),19);
d756027f 1046
1047 FillHistograms();
1048
1049 // int mult = fTrackCuts->CountAcceptedTracks(fESD);
1050
fb4a2fc7 1051 if(fTrackType==1 || fTrackType==2 || fTrackType==4 || fTrackType==5) {
1052 if(track) delete track;
1053 }
d756027f 1054
1055 }//track loop
1056
1057}
1058
1059//________________________________________________________________________
1060void AliPWG4HighPtTrackQA::DoAnalysisAOD() {
1061
1062 AliAODEvent *aod = dynamic_cast<AliAODEvent*>(fEvent);
1ea145ef 1063 if(!aod)return;
c3ff0a6e 1064 AliExternalTrackParam *exParam = new AliExternalTrackParam();
d756027f 1065 for (Int_t iTrack = 0; iTrack < fEvent->GetNumberOfTracks(); iTrack++) {
1066
1067 AliAODTrack *aodtrack = aod->GetTrack(iTrack);
1068 if( !aodtrack->TestFilterMask(fFilterMask) ) continue;
1069
1070 fVariables->Reset(0.);
1071
1072 fVariables->SetAt(aodtrack->Pt(),0);
1073 fVariables->SetAt(aodtrack->Phi(),1);
1074 fVariables->SetAt(aodtrack->Eta(),2);
1075
1076 Double_t dca[2] = {1e6,1e6};
1077 Double_t covar[3] = {1e6,1e6,1e6};
1078 if(aodtrack->PropagateToDCA(fEvent->GetPrimaryVertex(),fEvent->GetMagneticField(),100.,dca,covar)) {
1079 fVariables->SetAt(dca[0],3);
1080 fVariables->SetAt(dca[1],4);
1081 }
1082
1083 fVariables->SetAt((float)aodtrack->GetTPCNcls(),5);
1084 fVariables->SetAt((float)aodtrack->GetITSNcls(),6);
aa3ba8d2 1085 fVariables->SetAt(aodtrack->Chi2perNDF(),7);
d756027f 1086 fVariables->SetAt(0.,8);
c3ff0a6e 1087 fVariables->SetAt(GetTrackLengthTPC(aodtrack),9);
d756027f 1088 fVariables->SetAt(aodtrack->Chi2perNDF(),10);
1089 fVariables->SetAt(GetTPCClusterInfo(aodtrack,2),11);
1090 Float_t crossedRowsTPCNClsF = 0.;
1091 if(aodtrack->GetTPCNclsF()>0.) crossedRowsTPCNClsF = fVariables->At(11)/aodtrack->GetTPCNclsF();
1092 fVariables->SetAt(crossedRowsTPCNClsF,12);
c3ff0a6e 1093
1094 //get covariance matrix
1095 Double_t cov[21] = {0,};
1096 aodtrack->GetCovMatrix(cov);
1097 Double_t pxpypz[3] = {0,};
1098 aodtrack->PxPyPz(pxpypz);
1099 Double_t xyz[3] = {0,};
1100 aodtrack->GetXYZ(xyz);
1101 Short_t sign = aodtrack->Charge();
1102 exParam->Set(xyz,pxpypz,cov,sign);
1103
1104 fVariables->SetAt(exParam->GetSigmaY2(),13);
1105 fVariables->SetAt(exParam->GetSigmaZ2(),14);
1106 fVariables->SetAt(exParam->GetSigmaSnp2(),15);
1107 fVariables->SetAt(exParam->GetSigmaTgl2(),16);
1108 fVariables->SetAt(exParam->GetSigma1Pt2(),17);
1109
1110 fVariables->SetAt(0.,18);
1111 fVariables->SetAt(0.,19);
d756027f 1112
1113 fPtAll->Fill(fVariables->At(0));
1114
1115 FillHistograms();
1116
1117 }
1118
1119}
1120
1121//________________________________________________________________________
1122void AliPWG4HighPtTrackQA::FillHistograms() {
1123
1124 fPtSel->Fill(fVariables->At(0));
1125 fPtPhi->Fill(fVariables->At(0),fVariables->At(1));
1126 fPtEta->Fill(fVariables->At(0),fVariables->At(2));
1127 fPtDCA2D->Fill(fVariables->At(0),fVariables->At(3));
1128 fPtDCAZ->Fill(fVariables->At(0),fVariables->At(4));
1129 fPtNClustersTPC->Fill(fVariables->At(0),fVariables->At(5));
1130 fPtNPointITS->Fill(fVariables->At(0),fVariables->At(6));
c3ff0a6e 1131
1132
1133 fPtNClustersTPCIter1->Fill(fVariables->At(0),fVariables->At(18));
1134 if(fVariables->At(18)>0.)
1135 fPtChi2PerClusterTPCIter1->Fill(fVariables->At(0),fVariables->At(19)/fVariables->At(18));
1136
1137 fPtChi2C->Fill(fVariables->At(0),fVariables->At(7));
1138 fPtNSigmaToVertex->Fill(fVariables->At(0),fVariables->At(8));
1139 fPtRelUncertainty1Pt->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)));
1140 fPtRelUncertainty1PtNClus->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(5));
1141 fPtRelUncertainty1PtNClusIter1->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(18));
1142 fPtRelUncertainty1PtChi2->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(10));
1143 if(fVariables->At(18)>0.)
1144 fPtRelUncertainty1PtChi2Iter1->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(19)/fVariables->At(18));
1145 fPtRelUncertainty1PtPhi->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(1));
1146 fPtRelUncertainty1PtTrkLength->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(9));
1147
1148 fPtUncertainty1Pt->Fill(fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
1149 fPtSigmaY2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(13)));
1150 fPtSigmaZ2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(14)));
1151 fPtSigmaSnp2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(15)));
1152 fPtSigmaTgl2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(16)));
1153 fPtSigma1Pt2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
1154
1155 fProfPtSigmaY2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(13)));
1156 fProfPtSigmaZ2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(14)));
1157 fProfPtSigmaSnp2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(15)));
1158 fProfPtSigmaTgl2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(16)));
1159 fProfPtSigma1Pt2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
1160 fProfPtSigma1Pt->Fill(fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
1161 fProfPtPtSigma1Pt->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)));
1162
d756027f 1163 fPtChi2PerClusterTPC->Fill(fVariables->At(0),fVariables->At(10));
1164 fPtNCrossedRows->Fill(fVariables->At(0),fVariables->At(11));
1165 fPtNCrossedRowsNClusF->Fill(fVariables->At(0),fVariables->At(12));
1166 fPtNCrRNCrRNClusF->Fill(fVariables->At(0),fVariables->At(11),fVariables->At(12));
1167}
1168
1169//________________________________________________________________________
1170Bool_t AliPWG4HighPtTrackQA::PythiaInfoFromFile(const char* currFile,Float_t &fXsec,Float_t &fTrials){
1171 //
1172 // get the cross section and the trails either from pyxsec.root or from pysec_hists.root
1173 // This is to called in Notify and should provide the path to the AOD/ESD file
1174 // Copied from AliAnalysisTaskJetSpectrum2
1175 //
1176
1177 TString file(currFile);
1178 fXsec = 0;
1179 fTrials = 1;
1180
1181 if(file.Contains("root_archive.zip#")){
1182 Ssiz_t pos1 = file.Index("root_archive",12,TString::kExact);
1183 Ssiz_t pos = file.Index("#",1,pos1,TString::kExact);
1184 file.Replace(pos+1,20,"");
1185 }
1186 else {
1187 // not an archive take the basename....
1188 file.ReplaceAll(gSystem->BaseName(file.Data()),"");
1189 }
1190 // Printf("%s",file.Data());
1191
1192
1193 TFile *fxsec = TFile::Open(Form("%s%s",file.Data(),"pyxsec.root")); // problem that we cannot really test the existance of a file in a archive so we have to lvie with open error message from root
1194 if(!fxsec){
1195 // next trial fetch the histgram file
1196 fxsec = TFile::Open(Form("%s%s",file.Data(),"pyxsec_hists.root"));
1197 if(!fxsec){
1198 // not a severe condition but inciate that we have no information
1199 return kFALSE;
1200 }
1201 else{
1202 // find the tlist we want to be independtent of the name so use the Tkey
1203 TKey* key = (TKey*)fxsec->GetListOfKeys()->At(0);
1204 if(!key){
1205 fxsec->Close();
1206 return kFALSE;
1207 }
1208 TList *list = dynamic_cast<TList*>(key->ReadObj());
1209 if(!list){
1210 fxsec->Close();
1211 return kFALSE;
1212 }
1213 fXsec = ((TProfile*)list->FindObject("h1Xsec"))->GetBinContent(1);
1214 fTrials = ((TH1F*)list->FindObject("h1Trials"))->GetBinContent(1);
1215 fxsec->Close();
1216 }
1217 } // no tree pyxsec.root
1218 else {
1219 TTree *xtree = (TTree*)fxsec->Get("Xsection");
1220 if(!xtree){
1221 fxsec->Close();
1222 return kFALSE;
1223 }
1224 UInt_t ntrials = 0;
1225 Double_t xsection = 0;
1226 xtree->SetBranchAddress("xsection",&xsection);
1227 xtree->SetBranchAddress("ntrials",&ntrials);
1228 xtree->GetEntry(0);
1229 fTrials = ntrials;
1230 fXsec = xsection;
1231 fxsec->Close();
1232 }
1233 return kTRUE;
1234}
1235//________________________________________________________________________
1236Bool_t AliPWG4HighPtTrackQA::Notify()
1237{
1238 //
1239 // Implemented Notify() to read the cross sections
1240 // and number of trials from pyxsec.root
1241 // Copied from AliAnalysisTaskJetSpectrum2
1242 //
1243
1244 TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
1245 Float_t xsection = 0;
1246 Float_t ftrials = 1;
1247
1248 fAvgTrials = 1;
1249 if(tree){
1250 TFile *curfile = tree->GetCurrentFile();
1251 if (!curfile) {
1252 Error("Notify","No current file");
1253 return kFALSE;
1254 }
1255 if(!fh1Xsec||!fh1Trials){
1256 // Printf("%s%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__);
1257 return kFALSE;
1258 }
1259 PythiaInfoFromFile(curfile->GetName(),xsection,ftrials);
1260 fh1Xsec->Fill("<#sigma>",xsection);
1261 // construct a poor man average trials
1262 Float_t nEntries = (Float_t)tree->GetTree()->GetEntries();
1263 if(ftrials>=nEntries && nEntries>0.)fAvgTrials = ftrials/nEntries;
1264 }
1265 return kTRUE;
1266}
1267
1268//________________________________________________________________________
1269AliGenPythiaEventHeader* AliPWG4HighPtTrackQA::GetPythiaEventHeader(AliMCEvent *mcEvent){
1270
1271 if(!mcEvent)return 0;
1272 AliGenEventHeader* genHeader = mcEvent->GenEventHeader();
1273 AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
1274 if(!pythiaGenHeader){
1275 // cocktail ??
1276 AliGenCocktailEventHeader* genCocktailHeader = dynamic_cast<AliGenCocktailEventHeader*>(genHeader);
1277
1278 if (!genCocktailHeader) {
1279 // AliWarningGeneral(Form(" %s:%d",(char*)__FILE__,__LINE__),"Unknown header type (not Pythia or Cocktail)");
1280 // AliWarning(Form("%s %d: Unknown header type (not Pythia or Cocktail)",(char*)__FILE__,__LINE__));
1281 return 0;
1282 }
1283 TList* headerList = genCocktailHeader->GetHeaders();
1284 for (Int_t i=0; i<headerList->GetEntries(); i++) {
1285 pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(headerList->At(i));
1286 if (pythiaGenHeader)
1287 break;
1288 }
1289 if(!pythiaGenHeader){
1290 AliWarningGeneral(Form(" %s:%d",(char*)__FILE__,__LINE__),"Pythia event header not found");
1291 return 0;
1292 }
1293 }
1294 return pythiaGenHeader;
1295
1296}
1297
1298//_______________________________________________________________________
1299Float_t AliPWG4HighPtTrackQA::GetTPCClusterInfo(AliAODTrack *tr,Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1) const
1300{
1301 //MV: copied from AliESDtrack since method is not available in AliAODTrack
1302
1303 //
1304 // TPC cluster information
1305 // type 0: get fraction of found/findable clusters with neighbourhood definition
1306 // 1: findable clusters with neighbourhood definition
1307 // 2: found clusters
1308 //
1309 // definition of findable clusters:
1310 // a cluster is defined as findable if there is another cluster
1311 // within +- nNeighbours pad rows. The idea is to overcome threshold
1312 // effects with a very simple algorithm.
1313 //
1314
1315 TBits fTPCClusterMap = tr->GetTPCClusterMap();
1316 if (type==2) return fTPCClusterMap.CountBits();
1317
1318 Int_t found=0;
1319 Int_t findable=0;
1320 Int_t last=-nNeighbours;
1321
1322 for (Int_t i=row0; i<row1; ++i){
1323 //look to current row
1324 if (fTPCClusterMap[i]) {
1325 last=i;
1326 ++found;
1327 ++findable;
1328 continue;
1329 }
1330 //look to nNeighbours before
1331 if ((i-last)<=nNeighbours) {
1332 ++findable;
1333 continue;
1334 }
1335 //look to nNeighbours after
1336 for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
1337 if (fTPCClusterMap[j]){
1338 ++findable;
1339 break;
1340 }
1341 }
1342 }
1343 if (type==1) return findable;
1344
1345 if (type==0){
1346 Float_t fraction=0;
1347 if (findable>0)
1348 fraction=(Float_t)found/(Float_t)findable;
1349 else
1350 fraction=0;
1351 return fraction;
1352 }
1353 return 0; // undefined type - default value
1354}
1355
05cb235d 1356//_______________________________________________________________________
1357Int_t AliPWG4HighPtTrackQA::GetTrackLengthTPC(AliESDtrack *track) {
1358 //
c3ff0a6e 1359 // returns distance between 1st and last hit in TPC
1360 // distance given in number of padrows
1361 //
1362
1363 TBits fTPCClusterMap = track->GetTPCClusterMap();
1364 int firstHit = 0;
1365 int lastHit = 0;
1366
1367 for(int i=0; i<=159; i++) {
1368 if(fTPCClusterMap[i]>0) firstHit = i;
1369 }
1370 for(int i=159; i>=0; i--) {
1371 if(fTPCClusterMap[i]>0) lastHit = i;
1372 }
1373
1374 Int_t trackLength = lastHit - firstHit;
1375
1376 return trackLength;
1377}
1378
1379//_______________________________________________________________________
1380Int_t AliPWG4HighPtTrackQA::GetTrackLengthTPC(AliAODTrack *track) {
1381 //
1382 // returns distance between 1st and last hit in TPC
05cb235d 1383 // distance given in number of padrows
1384 //
1385
1386 TBits fTPCClusterMap = track->GetTPCClusterMap();
1387 int firstHit = 0;
1388 int lastHit = 0;
1389
c3ff0a6e 1390 for(int i=0; i<=159; i++) {
1391 if(fTPCClusterMap[i]>0) firstHit = i;
05cb235d 1392 }
1393 for(int i=159; i>=0; i--) {
c3ff0a6e 1394 if(fTPCClusterMap[i]>0) lastHit = i;
05cb235d 1395 }
1396
c3ff0a6e 1397 Int_t trackLength = lastHit - firstHit;
1398
1399 return trackLength;
05cb235d 1400}
1401
1402//_______________________________________________________________________
aa3ba8d2 1403void AliPWG4HighPtTrackQA::FillSystematicCutHist(AliESDtrack *track) {
1404
1405 fSystTrackCuts->Fill("noCut",1);
1406 if(TMath::Abs(track->Eta())>0.9)
1407 fSystTrackCuts->Fill("eta",1);
1408 if(track->Pt()<0.15 || track->Pt()>1e10)
1409 fSystTrackCuts->Fill("0.15<pT<1e10",1);
1410 if(track->GetKinkIndex(0)>0)
1411 fSystTrackCuts->Fill("kink",1);
1412 if(track->GetTPCclusters(0)<70)
1413 fSystTrackCuts->Fill("NClusterTPC",1);
1414 if(track->GetTPCclusters(0)>0.) {
1415 if(track->GetTPCchi2()/Float_t(track->GetTPCclusters(0))>4.)
1416 fSystTrackCuts->Fill("Chi2PerNClusTPC",1);
1417 }
1418
1419 Float_t dcaToVertexXY = 0.;
1420 Float_t dcaToVertexZ = 0.;
1421 track->GetImpactParameters(dcaToVertexXY,dcaToVertexZ);
1422 Float_t fCutMaxDCAToVertexXY = 2.4;
1423 Float_t fCutMaxDCAToVertexZ = 3.2;
1424 Float_t dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY/fCutMaxDCAToVertexXY/fCutMaxDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMaxDCAToVertexZ/fCutMaxDCAToVertexZ);
1425 if(dcaToVertex>1.)
1426 fSystTrackCuts->Fill("DCA2D",1);
1427
1428}
d756027f 1429
1430//________________________________________________________________________
1431void AliPWG4HighPtTrackQA::Terminate(Option_t *)
1432{
1433 // The Terminate() function is the last function to be called during
1434 // a query. It always runs on the client, it can be used to present
1435 // the results graphically or save the results to file.
1436
1437}
1438
1439#endif