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