1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
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 : M. Verweij - UU
22 //-----------------------------------------------------------------------
24 #ifndef ALIPWG4HIGHPTTRACKQA_CXX
25 #define ALIPWG4HIGHPTTRACKQA_CXX
27 #include "AliPWG4HighPtTrackQA.h"
41 #include "AliAnalysisManager.h"
42 #include "AliESDInputHandler.h"
43 #include "AliMCEvent.h"
44 #include "AliMCEventHandler.h"
46 #include "AliESDtrack.h"
47 #include "AliESDtrackCuts.h"
48 #include "AliExternalTrackParam.h"
50 #include "AliGenPythiaEventHeader.h"
51 #include "AliGenCocktailEventHeader.h"
52 #include "AliCentrality.h"
53 #include "AliAODVertex.h"
54 #include "AliAODEvent.h"
56 using namespace std; //required for resolving the 'cout' symbol
58 ClassImp(AliPWG4HighPtTrackQA)
60 AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA()
61 : AliAnalysisTaskSE(),
67 fTrackCutsITSLoose(0x0),
68 fTrackCutsTPConly(0x0),
71 fIncludeNoITS(kFALSE),
72 fSigmaConstrainedMax(-1.),
89 fh1NTracksReject(0x0),
99 fPtNClustersTPCIter1(0x0),
100 fPtNClustersTPCIter1Phi(0x0),
101 fPtNClustersTPCShared(0x0),
102 fPtNClustersTPCSharedFrac(0x0),
104 fPtNPointITSPhi(0x0),
106 fPtNSigmaToVertex(0x0),
107 fPtRelUncertainty1Pt(0x0),
108 fPtRelUncertainty1PtNClus(0x0),
109 fPtRelUncertainty1PtNClusIter1(0x0),
110 fPtRelUncertainty1PtNPointITS(0x0),
111 fPtRelUncertainty1PtITSClusterMap(0x0),
112 fPtRelUncertainty1PtChi2(0x0),
113 fPtRelUncertainty1PtChi2Iter1(0x0),
114 fPtRelUncertainty1PtPhi(0x0),
115 fPtChi2PerClusterTPC(0x0),
116 fPtChi2PerClusterTPCIter1(0x0),
117 fPtNCrossedRows(0x0),
118 fPtNCrossedRowsPhi(0x0),
119 fPtNCrossedRowsNClusFPhi(0x0),
120 fPtNCrRNCrRNClusF(0x0),
121 fPtNCrossedRowsFit(0x0),
122 fPtNCrossedRowsFitPhi(0x0),
123 fPtNCrossedRowsNClusFFitPhi(0x0),
124 fNCrossedRowsNCrossedRowsFit(0x0),
125 fNClustersNCrossedRows(0x0),
126 fNClustersNCrossedRowsFit(0x0),
127 fPtNClustersNClustersFitMap(0x0),
128 fPtRelUncertainty1PtNCrossedRows(0x0),
129 fPtRelUncertainty1PtNCrossedRowsFit(0x0),
134 fChi2GoldChi2GGC(0x0),
143 fProfPtSigmaSnp2(0x0),
144 fProfPtSigmaTgl2(0x0),
145 fProfPtSigma1Pt2(0x0),
146 fProfPtSigma1Pt(0x0),
147 fProfPtPtSigma1Pt(0x0),
155 fPtBinEdges[0][0] = 10.;
156 fPtBinEdges[0][1] = 1.;
157 fPtBinEdges[1][0] = 20.;
158 fPtBinEdges[1][1] = 2.;
159 fPtBinEdges[2][0] = 100.;
160 fPtBinEdges[2][1] = 5.;
163 //________________________________________________________________________
164 AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA(const char *name):
165 AliAnalysisTaskSE(name),
171 fTrackCutsITSLoose(0x0),
172 fTrackCutsTPConly(0x0),
175 fIncludeNoITS(kFALSE),
176 fSigmaConstrainedMax(-1.),
193 fh1NTracksReject(0x0),
202 fPtNClustersTPC(0x0),
203 fPtNClustersTPCIter1(0x0),
204 fPtNClustersTPCIter1Phi(0x0),
205 fPtNClustersTPCShared(0x0),
206 fPtNClustersTPCSharedFrac(0x0),
208 fPtNPointITSPhi(0x0),
210 fPtNSigmaToVertex(0x0),
211 fPtRelUncertainty1Pt(0x0),
212 fPtRelUncertainty1PtNClus(0x0),
213 fPtRelUncertainty1PtNClusIter1(0x0),
214 fPtRelUncertainty1PtNPointITS(0x0),
215 fPtRelUncertainty1PtITSClusterMap(0x0),
216 fPtRelUncertainty1PtChi2(0x0),
217 fPtRelUncertainty1PtChi2Iter1(0x0),
218 fPtRelUncertainty1PtPhi(0x0),
219 fPtChi2PerClusterTPC(0x0),
220 fPtChi2PerClusterTPCIter1(0x0),
221 fPtNCrossedRows(0x0),
222 fPtNCrossedRowsPhi(0x0),
223 fPtNCrossedRowsNClusFPhi(0x0),
224 fPtNCrRNCrRNClusF(0x0),
225 fPtNCrossedRowsFit(0x0),
226 fPtNCrossedRowsFitPhi(0x0),
227 fPtNCrossedRowsNClusFFitPhi(0x0),
228 fNCrossedRowsNCrossedRowsFit(0x0),
229 fNClustersNCrossedRows(0x0),
230 fNClustersNCrossedRowsFit(0x0),
231 fPtNClustersNClustersFitMap(0x0),
232 fPtRelUncertainty1PtNCrossedRows(0x0),
233 fPtRelUncertainty1PtNCrossedRowsFit(0x0),
238 fChi2GoldChi2GGC(0x0),
247 fProfPtSigmaSnp2(0x0),
248 fProfPtSigmaTgl2(0x0),
249 fProfPtSigma1Pt2(0x0),
250 fProfPtSigma1Pt(0x0),
251 fProfPtPtSigma1Pt(0x0),
255 // Constructor. Initialization of Inputs and Outputs
257 AliDebug(2,Form("AliPWG4HighPtTrackQA Calling Constructor"));
261 fPtBinEdges[0][0] = 10.;
262 fPtBinEdges[0][1] = 1.;
263 fPtBinEdges[1][0] = 20.;
264 fPtBinEdges[1][1] = 2.;
265 fPtBinEdges[2][0] = 100.;
266 fPtBinEdges[2][1] = 5.;
268 // Input slot #0 works with a TChain ESD
269 DefineInput(0, TChain::Class());
270 // Output slot #1 write into a TList
271 DefineOutput(1, TList::Class());
274 //________________________________________________________________________
275 void AliPWG4HighPtTrackQA::SetPtBinEdges(Int_t region, Double_t ptmax, Double_t ptBinWidth) {
277 // Set variable bin sizes for pT axis in histos
281 fPtBinEdges[region][0] = ptmax;
282 fPtBinEdges[region][1] = ptBinWidth;
285 AliError("Only 3 regions alowed. Use region 0/1/2\n");
291 //________________________________________________________________________
292 void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
293 //Create output objects
294 AliDebug(2,Form(">> AliPWG4HighPtTrackQA::UserCreateOutputObjects \n"));
296 Bool_t oldStatus = TH1::AddDirectoryStatus();
297 TH1::AddDirectory(kFALSE);
300 fHistList = new TList();
301 fHistList->SetOwner(kTRUE);
303 Float_t fgkPtMin = 0.;
304 // Float_t fgkPtMax = fPtMax;
306 //fPtBinEdges[region][0] = ptmax of region ; fPtBinEdges[region][1] = binWidth of region
307 const Float_t ptmin1 = fgkPtMin;
308 const Float_t ptmax1 = fPtBinEdges[0][0];
309 const Float_t ptmin2 = ptmax1 ;
310 const Float_t ptmax2 = fPtBinEdges[1][0];
311 const Float_t ptmin3 = ptmax2 ;
312 const Float_t ptmax3 = fPtBinEdges[2][0];//fgkPtMax;
313 const Int_t nbin11 = (int)((ptmax1-ptmin1)/fPtBinEdges[0][1]);
314 const Int_t nbin12 = (int)((ptmax2-ptmin2)/fPtBinEdges[1][1])+nbin11;
315 const Int_t nbin13 = (int)((ptmax3-ptmin3)/fPtBinEdges[2][1])+nbin12;
316 Int_t fgkNPtBins=nbin13;
317 //Create array with low edges of each bin
318 Double_t *binsPt=new Double_t[fgkNPtBins+1];
319 for(Int_t i=0; i<=fgkNPtBins; i++) {
320 if(i<=nbin11) binsPt[i]=(Double_t)ptmin1 + (ptmax1-ptmin1)/nbin11*(Double_t)i ;
321 if(i<=nbin12 && i>nbin11) binsPt[i]=(Double_t)ptmin2 + (ptmax2-ptmin2)/(nbin12-nbin11)*((Double_t)i-(Double_t)nbin11) ;
322 if(i<=nbin13 && i>nbin12) binsPt[i]=(Double_t)ptmin3 + (ptmax3-ptmin3)/(nbin13-nbin12)*((Double_t)i-(Double_t)nbin12) ;
325 Int_t fgkNPhiBins = 18*6;
326 Float_t kMinPhi = 0.;
327 Float_t kMaxPhi = 2.*TMath::Pi();
328 Double_t *binsPhi = new Double_t[fgkNPhiBins+1];
329 for(Int_t i=0; i<=fgkNPhiBins; i++) binsPhi[i]=(Double_t)kMinPhi + (kMaxPhi-kMinPhi)/fgkNPhiBins*(Double_t)i ;
331 Int_t fgkNEtaBins=20;
332 Float_t fgkEtaMin = -1.;
333 Float_t fgkEtaMax = 1.;
334 Double_t *binsEta=new Double_t[fgkNEtaBins+1];
335 for(Int_t i=0; i<=fgkNEtaBins; i++) binsEta[i]=(Double_t)fgkEtaMin + (fgkEtaMax-fgkEtaMin)/fgkNEtaBins*(Double_t)i ;
337 Int_t fgkNNClustersTPCBins=80;
338 Float_t fgkNClustersTPCMin = 0.5;
339 Float_t fgkNClustersTPCMax = 160.5;
340 Double_t *binsNClustersTPC=new Double_t[fgkNNClustersTPCBins+1];
341 for(Int_t i=0; i<=fgkNNClustersTPCBins; i++) binsNClustersTPC[i]=(Double_t)fgkNClustersTPCMin + (fgkNClustersTPCMax-fgkNClustersTPCMin)/fgkNNClustersTPCBins*(Double_t)i ;
343 Int_t fgkNDCA2DBins=80;
344 Float_t fgkDCA2DMin = -0.2;
345 Float_t fgkDCA2DMax = 0.2;
346 if(fTrackType==1 || fTrackType==2 || fTrackType==4 || fTrackType==7) {
350 Double_t *binsDCA2D=new Double_t[fgkNDCA2DBins+1];
351 for(Int_t i=0; i<=fgkNDCA2DBins; i++) binsDCA2D[i]=(Double_t)fgkDCA2DMin + (fgkDCA2DMax-fgkDCA2DMin)/fgkNDCA2DBins*(Double_t)i ;
353 Int_t fgkNDCAZBins=80;
354 Float_t fgkDCAZMin = -2.;
355 Float_t fgkDCAZMax = 2.;
356 if(fTrackType==1 || fTrackType==2 || fTrackType==4) {
360 Double_t *binsDCAZ=new Double_t[fgkNDCAZBins+1];
361 for(Int_t i=0; i<=fgkNDCAZBins; i++) binsDCAZ[i]=(Double_t)fgkDCAZMin + (fgkDCAZMax-fgkDCAZMin)/fgkNDCAZBins*(Double_t)i ;
363 Int_t fgkNNPointITSBins=9;
364 Float_t fgkNPointITSMin = -0.5;
365 Float_t fgkNPointITSMax = 8.5;
366 Double_t *binsNPointITS=new Double_t[fgkNNPointITSBins+1];
367 for(Int_t i=0; i<=fgkNNPointITSBins; i++) binsNPointITS[i]=(Double_t)fgkNPointITSMin + (fgkNPointITSMax-fgkNPointITSMin)/fgkNNPointITSBins*(Double_t)i ;
369 Int_t fgkNITSClusterMapBins=65;
370 Float_t fgkITSClusterMapMin = -0.5;
371 Float_t fgkITSClusterMapMax = 64.5;
372 Double_t *binsITSClusterMap=new Double_t[fgkNITSClusterMapBins+1];
373 for(Int_t i=0; i<=fgkNITSClusterMapBins; i++) binsITSClusterMap[i]=(Double_t)fgkITSClusterMapMin + (fgkITSClusterMapMax-fgkITSClusterMapMin)/fgkNITSClusterMapBins*(Double_t)i ;
376 Int_t fgkNNSigmaToVertexBins=9;
377 Float_t fgkNSigmaToVertexMin = 0.;
378 Float_t fgkNSigmaToVertexMax = 9.;
379 Double_t *binsNSigmaToVertex=new Double_t[fgkNNSigmaToVertexBins+1];
380 for(Int_t i=0; i<=fgkNNSigmaToVertexBins; i++) binsNSigmaToVertex[i]=(Double_t)fgkNSigmaToVertexMin + (fgkNSigmaToVertexMax-fgkNSigmaToVertexMin)/fgkNNSigmaToVertexBins*(Double_t)i ;
382 Int_t fgkNChi2CBins=10;
383 // Float_t fgkChi2CMin = 0.;
384 // Float_t fgkChi2CMax = 100.; //10 sigma
385 Double_t *binsChi2C=new Double_t[fgkNChi2CBins+1];
386 for(Int_t i=0; i<=fgkNChi2CBins; i++) binsChi2C[i] = (Double_t)i * (Double_t)i;
388 Float_t fgkRel1PtUncertaintyMin = 0.;
389 Float_t fgkRel1PtUncertaintyMax = 1.;
390 Float_t binEdgeRel1PtUncertainty1= 0.3;
391 Int_t fgkNRel1PtUncertaintyBins1 = 45;
392 Float_t binWidthRel1PtUncertainty1 = (binEdgeRel1PtUncertainty1-fgkRel1PtUncertaintyMin)/((Float_t)fgkNRel1PtUncertaintyBins1);
393 Int_t fgkNRel1PtUncertaintyBins2 = 35;
394 Float_t binWidthRel1PtUncertainty2 = (fgkRel1PtUncertaintyMax-binEdgeRel1PtUncertainty1)/((Float_t)fgkNRel1PtUncertaintyBins2);
395 Int_t fgkNRel1PtUncertaintyBins = fgkNRel1PtUncertaintyBins1 + fgkNRel1PtUncertaintyBins2;
397 Double_t *binsRel1PtUncertainty=new Double_t[fgkNRel1PtUncertaintyBins+1];
398 for(Int_t i=0; i<=fgkNRel1PtUncertaintyBins; i++) {
399 if(i<=fgkNRel1PtUncertaintyBins1)
400 binsRel1PtUncertainty[i]=(Double_t)fgkRel1PtUncertaintyMin + (Double_t)binWidthRel1PtUncertainty1*(Double_t)i ;
401 if(i<=fgkNRel1PtUncertaintyBins && i>fgkNRel1PtUncertaintyBins1)
402 binsRel1PtUncertainty[i]=(Double_t)binEdgeRel1PtUncertainty1 + (Double_t)binWidthRel1PtUncertainty2*(Double_t)(i-fgkNRel1PtUncertaintyBins1);
405 Int_t fgkNUncertainty1PtBins = 30;
406 Float_t fgkUncertainty1PtMin = 0.;
407 Float_t fgkUncertainty1PtMax = 0.1;
408 if(fTrackType==1 || fTrackType==2 || fTrackType==4)
409 fgkUncertainty1PtMax = 0.2;
410 Double_t *binsUncertainty1Pt=new Double_t[fgkNUncertainty1PtBins+1];
411 for(Int_t i=0; i<=fgkNUncertainty1PtBins; i++) binsUncertainty1Pt[i]=(Double_t)fgkUncertainty1PtMin + (fgkUncertainty1PtMax-fgkUncertainty1PtMin)/fgkNUncertainty1PtBins*(Double_t)i ;
413 Float_t fgkChi2PerClusMin = 0.;
414 Float_t fgkChi2PerClusMax = 4.;
415 Int_t fgkNChi2PerClusBins = (int)(fgkChi2PerClusMax*10.);
416 Double_t *binsChi2PerClus=new Double_t[fgkNChi2PerClusBins+1];
417 for(Int_t i=0; i<=fgkNChi2PerClusBins; i++) binsChi2PerClus[i]=(Double_t)fgkChi2PerClusMin + (fgkChi2PerClusMax-fgkChi2PerClusMin)/fgkNChi2PerClusBins*(Double_t)i ;
419 Int_t fgkNCrossedRowsNClusFBins = 45;
420 Float_t fgkNCrossedRowsNClusFMin = 0.;
421 Float_t fgkNCrossedRowsNClusFMax = 1.5;
422 Double_t *binsNCrossedRowsNClusF=new Double_t[fgkNCrossedRowsNClusFBins+1];
423 for(Int_t i=0; i<=fgkNCrossedRowsNClusFBins; i++) binsNCrossedRowsNClusF[i]=(Double_t)fgkNCrossedRowsNClusFMin + (fgkNCrossedRowsNClusFMax-fgkNCrossedRowsNClusFMin)/fgkNCrossedRowsNClusFBins*(Double_t)i ;
425 Float_t fgk1PtMin = 0.;
426 Float_t fgk1PtMax = 6.;
427 Float_t binEdge1Pt1 = 1.;
428 Float_t binWidth1Pt1 = 0.05;
429 Int_t fgkN1PtBins1 = (int)((binEdge1Pt1-fgk1PtMin)/binWidth1Pt1);
430 Float_t binWidth1Pt2 = 0.1;
431 Int_t fgkN1PtBins2 = (int)((fgk1PtMax-binEdge1Pt1)/binWidth1Pt2);
432 Int_t fgkN1PtBins = fgkN1PtBins1+fgkN1PtBins2;
433 Double_t *bins1Pt=new Double_t[fgkN1PtBins+1];
435 for(Int_t i=0; i<=fgkN1PtBins; i++) {
437 bins1Pt[i]=(Double_t)fgk1PtMin + (Double_t)(binEdge1Pt1-fgk1PtMin)/(Double_t)fgkN1PtBins1*(Double_t)i;
438 if(i<=fgkN1PtBins && i>fgkN1PtBins1)
439 bins1Pt[i]=(Double_t)binEdge1Pt1 + (Double_t)(fgk1PtMax-binEdge1Pt1)/(Double_t)fgkN1PtBins2*(Double_t)(i-fgkN1PtBins1);
442 Int_t fgkNSigmaY2Bins = 50;
443 Float_t fgkSigmaY2Min = 0.;
444 Float_t fgkSigmaY2Max = 1.;
445 if(fTrackType==1) fgkSigmaY2Max = 4.;
446 if(fTrackType==2 || fTrackType==4) fgkSigmaY2Max = 0.1;
447 Double_t *binsSigmaY2=new Double_t[fgkNSigmaY2Bins+1];
448 for(Int_t i=0; i<=fgkNSigmaY2Bins; i++) binsSigmaY2[i]=(Double_t)fgkSigmaY2Min + (fgkSigmaY2Max-fgkSigmaY2Min)/fgkNSigmaY2Bins*(Double_t)i ;
450 Int_t fgkNSigmaZ2Bins = 50;
451 Float_t fgkSigmaZ2Min = 0.;
452 Float_t fgkSigmaZ2Max = 0.4;
453 Double_t *binsSigmaZ2=new Double_t[fgkNSigmaZ2Bins+1];
454 for(Int_t i=0; i<=fgkNSigmaZ2Bins; i++) binsSigmaZ2[i]=(Double_t)fgkSigmaZ2Min + (fgkSigmaZ2Max-fgkSigmaZ2Min)/fgkNSigmaZ2Bins*(Double_t)i ;
456 Int_t fgkNSigmaSnp2Bins = 50;
457 Float_t fgkSigmaSnp2Min = 0.;
458 Float_t fgkSigmaSnp2Max = 0.05;
459 if(fTrackType==1) fgkSigmaSnp2Max = 0.2;
460 if(fTrackType==2 || fTrackType==4) fgkSigmaSnp2Max = 0.1;
461 Double_t *binsSigmaSnp2=new Double_t[fgkNSigmaSnp2Bins+1];
462 for(Int_t i=0; i<=fgkNSigmaSnp2Bins; i++) binsSigmaSnp2[i]=(Double_t)fgkSigmaSnp2Min + (fgkSigmaSnp2Max-fgkSigmaSnp2Min)/fgkNSigmaSnp2Bins*(Double_t)i ;
464 Int_t fgkNSigmaTgl2Bins = 50;
465 Float_t fgkSigmaTgl2Min = 0.;
466 Float_t fgkSigmaTgl2Max = 0.1;
467 if(fTrackType==1) fgkSigmaTgl2Max = 0.2;
468 if(fTrackType==2 || fTrackType==4) fgkSigmaTgl2Max = 0.1;
469 Double_t *binsSigmaTgl2=new Double_t[fgkNSigmaTgl2Bins+1];
470 for(Int_t i=0; i<=fgkNSigmaTgl2Bins; i++) binsSigmaTgl2[i]=(Double_t)fgkSigmaTgl2Min + (fgkSigmaTgl2Max-fgkSigmaTgl2Min)/fgkNSigmaTgl2Bins*(Double_t)i ;
472 Int_t fgkNSigma1Pt2Bins = 50;
473 Float_t fgkSigma1Pt2Min = 0.;
474 Float_t fgkSigma1Pt2Max = 1.;
475 Double_t *binsSigma1Pt2=new Double_t[fgkNSigma1Pt2Bins+1];
476 for(Int_t i=0; i<=fgkNSigma1Pt2Bins; i++) binsSigma1Pt2[i]=(Double_t)fgkSigma1Pt2Min + (fgkSigma1Pt2Max-fgkSigma1Pt2Min)/fgkNSigma1Pt2Bins*(Double_t)i ;
479 fNEventAll = new TH1F("fNEventAll","NEventAll",1,-0.5,0.5);
480 fHistList->Add(fNEventAll);
481 fNEventSel = new TH1F("fNEventSel","NEvent Selected for analysis",1,-0.5,0.5);
482 fHistList->Add(fNEventSel);
483 fNEventReject = new TH1F("fNEventReject","Reason events are rejectected for analysis",20,0,20);
485 fNEventReject->Fill("noESD",0);
486 fNEventReject->Fill("Trigger",0);
487 fNEventReject->Fill("NTracks<2",0);
488 fNEventReject->Fill("noVTX",0);
489 fNEventReject->Fill("VtxStatus",0);
490 fNEventReject->Fill("NCont<2",0);
491 fNEventReject->Fill("ZVTX>10",0);
492 fNEventReject->Fill("cent",0);
493 fNEventReject->Fill("cent>90",0);
494 fHistList->Add(fNEventReject);
496 fh1Centrality = new TH1F("fh1Centrality","fh1Centrality; Centrality %",100,0,100);
497 fHistList->Add(fh1Centrality);
499 fh1Xsec = new TProfile("fh1Xsec","xsec from pyxsec.root",1,0,1);
500 fh1Xsec->GetXaxis()->SetBinLabel(1,"<#sigma>");
501 fHistList->Add(fh1Xsec);
503 fh1Trials = new TH1F("fh1Trials","trials root file",1,0,1);
504 fh1Trials->GetXaxis()->SetBinLabel(1,"#sum{ntrials}");
505 fHistList->Add(fh1Trials);
507 fh1PtHard = new TH1F("fh1PtHard","PYTHIA Pt hard;p_{T,hard}",350,-.5,349.5);
508 fHistList->Add(fh1PtHard);
509 fh1PtHardTrials = new TH1F("fh1PtHardTrials","PYTHIA Pt hard weight with trials;p_{T,hard}",350,-.5,349.5);
510 fHistList->Add(fh1PtHardTrials);
512 fh1NTracksAll = new TH1F("fh1NTracksAll","fh1NTracksAll",1,-0.5,0.5);
513 fHistList->Add(fh1NTracksAll);
515 fh1NTracksReject = new TH1F("fh1NTracksReject","fh1NTracksReject",1,-0.5,0.5);
516 fh1NTracksReject->Fill("noHybridTrack",0);
517 fh1NTracksReject->Fill("noITSrefit",0);
518 fh1NTracksReject->Fill("noESDtrack",0);
519 fh1NTracksReject->Fill("noTPCInner",0);
520 fh1NTracksReject->Fill("FillTPC",0);
521 fh1NTracksReject->Fill("noTPConly",0);
522 fh1NTracksReject->Fill("relate",0);
523 fh1NTracksReject->Fill("trackCuts",0);
524 fh1NTracksReject->Fill("laser",0);
525 fh1NTracksReject->Fill("chi2",0);
526 fHistList->Add(fh1NTracksReject);
528 fh1NTracksSel = new TH1F("fh1NTracksSel","fh1NTracksSel",1,-0.5,0.5);
529 fHistList->Add(fh1NTracksSel);
531 fPtAll = new TH1F("fPtAll","PtAll",fgkNPtBins, binsPt);
532 fHistList->Add(fPtAll);
533 fPtSel = new TH1F("fPtSel","PtSel",fgkNPtBins, binsPt);
534 fHistList->Add(fPtSel);
536 fPtPhi = new TH2F("fPtPhi","fPtPhi",fgkNPtBins,binsPt,fgkNPhiBins,binsPhi);
537 fHistList->Add(fPtPhi);
539 fPtEta = new TH2F("fPtEta","fPtEta",fgkNPtBins,binsPt,fgkNEtaBins,binsEta);
540 fHistList->Add(fPtEta);
542 fPtEtaPhi = new TH3F("fPtEtaPhi","fPtEtaPhi",fgkNPtBins,binsPt,fgkNEtaBins,binsEta,fgkNPhiBins,binsPhi);
543 fHistList->Add(fPtEtaPhi);
545 fPtDCA2D = new TH2F("fPtDCA2D","fPtDCA2D",fgkNPtBins,binsPt,fgkNDCA2DBins,binsDCA2D);
546 fHistList->Add(fPtDCA2D);
548 fPtDCAZ = new TH2F("fPtDCAZ","fPtDCAZ",fgkNPtBins,binsPt,fgkNDCAZBins,binsDCAZ);
549 fHistList->Add(fPtDCAZ);
551 fPtNClustersTPC = new TH2F("fPtNClustersTPC","fPtNClustersTPC",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
552 fHistList->Add(fPtNClustersTPC);
554 fPtNClustersTPCIter1 = new TH2F("fPtNClustersTPCIter1","fPtNClustersTPCIter1",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
555 fHistList->Add(fPtNClustersTPCIter1);
557 fPtNClustersTPCIter1Phi = new TH3F("fPtNClustersTPCIter1Phi","fPtNClustersTPCIter1Phi",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC,fgkNPhiBins,binsPhi);
558 fHistList->Add(fPtNClustersTPCIter1Phi);
560 fPtNClustersTPCShared = new TH2F("fPtNClustersTPCShared","fPtNClustersTPCShared",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
561 fHistList->Add(fPtNClustersTPCShared);
563 fPtNClustersTPCSharedFrac = new TH2F("fPtNClustersTPCSharedFrac","fPtNClustersTPCSharedFrac",fgkNPtBins,binsPt,fgkNSigma1Pt2Bins,binsSigma1Pt2);
564 fHistList->Add(fPtNClustersTPCSharedFrac);
566 fPtNPointITS = new TH2F("fPtNPointITS","fPtNPointITS",fgkNPtBins,binsPt,fgkNNPointITSBins,binsNPointITS);
567 fHistList->Add(fPtNPointITS);
569 fPtNPointITSPhi = new TH3F("fPtNPointITSPhi","fPtNPointITSPhi",fgkNPtBins,binsPt,fgkNNPointITSBins,binsNPointITS,fgkNPhiBins,binsPhi);
570 fHistList->Add(fPtNPointITSPhi);
572 fPtChi2C = new TH2F("fPtChi2C","fPtChi2C",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C);
573 fHistList->Add(fPtChi2C);
575 fPtNSigmaToVertex = new TH2F("fPtNSigmaToVertex","fPtNSigmaToVertex",fgkNPtBins,binsPt,fgkNNSigmaToVertexBins,binsNSigmaToVertex);
576 fHistList->Add(fPtNSigmaToVertex);
578 fPtRelUncertainty1Pt = new TH2F("fPtRelUncertainty1Pt","fPtRelUncertainty1Pt",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty);
579 fHistList->Add(fPtRelUncertainty1Pt);
581 fPtRelUncertainty1PtNClus = new TH3F("fPtRelUncertainty1PtNClus","fPtRelUncertainty1PtNClus",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
582 fHistList->Add(fPtRelUncertainty1PtNClus);
584 fPtRelUncertainty1PtNClusIter1 = new TH3F("fPtRelUncertainty1PtNClusIter1","fPtRelUncertainty1PtNClusIter1",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
585 fHistList->Add(fPtRelUncertainty1PtNClusIter1);
587 fPtRelUncertainty1PtNPointITS = new TH3F("fPtRelUncertainty1PtNPointITS","fPtRelUncertainty1PtNPointITS",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNPointITSBins,binsNPointITS);
588 fHistList->Add(fPtRelUncertainty1PtNPointITS);
590 fPtRelUncertainty1PtITSClusterMap = new TH3F("fPtRelUncertainty1PtITSClusterMap","fPtRelUncertainty1PtITSClusterMap",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNITSClusterMapBins,binsITSClusterMap);
591 fHistList->Add(fPtRelUncertainty1PtITSClusterMap);
593 fPtRelUncertainty1PtChi2 = new TH3F("fPtRelUncertainty1PtChi2","fPtRelUncertainty1PtChi2",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNChi2PerClusBins,binsChi2PerClus);
594 fHistList->Add(fPtRelUncertainty1PtChi2);
596 fPtRelUncertainty1PtChi2Iter1 = new TH3F("fPtRelUncertainty1PtChi2Iter1","fPtRelUncertainty1PtChi2Iter1",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNChi2PerClusBins,binsChi2PerClus);
597 fHistList->Add(fPtRelUncertainty1PtChi2Iter1);
599 fPtRelUncertainty1PtPhi = new TH3F("fPtRelUncertainty1PtPhi","fPtRelUncertainty1PtPhi",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNPhiBins,binsPhi);
600 fHistList->Add(fPtRelUncertainty1PtPhi);
602 fPtChi2PerClusterTPC = new TH2F("fPtChi2PerClusterTPC","fPtChi2PerClusterTPC",fgkNPtBins,binsPt,fgkNChi2PerClusBins,binsChi2PerClus);
603 fHistList->Add(fPtChi2PerClusterTPC);
605 fPtChi2PerClusterTPCIter1 = new TH2F("fPtChi2PerClusterTPCIter1","fPtChi2PerClusterTPCIter1",fgkNPtBins,binsPt,fgkNChi2PerClusBins,binsChi2PerClus);
606 fHistList->Add(fPtChi2PerClusterTPCIter1);
608 fPtNCrossedRows = new TH2F("fPtNCrossedRows","fPtNCrossedRows",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
609 fHistList->Add(fPtNCrossedRows);
611 fPtNCrossedRowsPhi = new TH3F("fPtNCrossedRowsPhi","fPtNCrossedRowsPhi",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC,fgkNPhiBins,binsPhi);
612 fHistList->Add(fPtNCrossedRowsPhi);
614 fPtNCrossedRowsNClusFPhi = new TH3F("fPtNCrossedRowsNClusFPhi","fPtNCrossedRowsNClusFPhi",fgkNPtBins,binsPt,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF,fgkNPhiBins,binsPhi);
615 fHistList->Add(fPtNCrossedRowsNClusFPhi);
617 fPtNCrRNCrRNClusF = new TH3F("fPtNCrRNCrRNClusF","fPtNCrRNCrRNClusF",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF);
618 fHistList->Add(fPtNCrRNCrRNClusF);
620 fPtNCrossedRowsFit = new TH2F("fPtNCrossedRowsFit","fPtNCrossedRowsFit",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
621 fHistList->Add(fPtNCrossedRowsFit);
623 fPtNCrossedRowsFitPhi = new TH3F("fPtNCrossedRowsFitPhi","fPtNCrossedRowsFitPhi",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC,fgkNPhiBins,binsPhi);
624 fHistList->Add(fPtNCrossedRowsFitPhi);
626 fPtNCrossedRowsNClusFFitPhi = new TH3F("fPtNCrossedRowsNClusFFitPhi","fPtNCrossedRowsNClusFFitPhi",fgkNPtBins,binsPt,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF,fgkNPhiBins,binsPhi);
627 fHistList->Add(fPtNCrossedRowsNClusFFitPhi);
629 fNCrossedRowsNCrossedRowsFit = new TH2F("fNCrossedRowsNCrossedRowsFit","fNCrossedRowsNCrossedRowsFit",fgkNNClustersTPCBins,binsNClustersTPC,fgkNNClustersTPCBins,binsNClustersTPC);
630 fHistList->Add(fNCrossedRowsNCrossedRowsFit);
632 fNClustersNCrossedRows = new TH2F("fNClustersNCrossedRows","fNClustersNCrossedRows",fgkNNClustersTPCBins,binsNClustersTPC,fgkNNClustersTPCBins,binsNClustersTPC);
633 fHistList->Add(fNClustersNCrossedRows);
635 fNClustersNCrossedRowsFit = new TH2F("fNClustersNCrossedRowsFit","fNClustersNCrossedRowsFit",fgkNNClustersTPCBins,binsNClustersTPC,fgkNNClustersTPCBins,binsNClustersTPC);
636 fHistList->Add(fNClustersNCrossedRowsFit);
638 fPtNClustersNClustersFitMap = new TH3F("fPtNClustersNClustersFitMap","fPtNClustersNClustersFitMap;p_{T};N_{cls};N_{cls}^{fit map}",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC,fgkNNClustersTPCBins,binsNClustersTPC);
639 fHistList->Add(fPtNClustersNClustersFitMap);
641 fPtRelUncertainty1PtNCrossedRows = new TH3F("fPtRelUncertainty1PtNCrossedRows","fPtRelUncertainty1PtNCrossedRows",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
642 fHistList->Add(fPtRelUncertainty1PtNCrossedRows);
644 fPtRelUncertainty1PtNCrossedRowsFit = new TH3F("fPtRelUncertainty1PtNCrossedRowsFit","fPtRelUncertainty1PtNCrossedRowsFit",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
645 fHistList->Add(fPtRelUncertainty1PtNCrossedRowsFit);
647 fPtChi2Gold = new TH2F("fPtChi2Gold","fPtChi2Gold",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C);
648 fHistList->Add(fPtChi2Gold);
650 fPtChi2GGC = new TH2F("fPtChi2GGC","fPtChi2GGC",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C);
651 fHistList->Add(fPtChi2GGC);
653 fPtChi2GoldPhi = new TH3F("fPtChi2GoldPhi","fPtChi2GoldPhi",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C,fgkNPhiBins,binsPhi);
654 fHistList->Add(fPtChi2GoldPhi);
656 fPtChi2GGCPhi = new TH3F("fPtChi2GGCPhi","fPtChi2GGCPhi",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C,fgkNPhiBins,binsPhi);
657 fHistList->Add(fPtChi2GGCPhi);
659 fChi2GoldChi2GGC = new TH2F("fChi2GoldChi2GGC","fChi2GoldChi2GGC;#chi^{2}_{gold};#chi^{2}_{ggc}",fgkNChi2CBins,binsChi2C,fgkNChi2CBins,binsChi2C);
660 fHistList->Add(fChi2GoldChi2GGC);
662 fPtChi2ITSPhi = new TH3F("fPtChi2ITSPhi","fPtChi2ITSPhi;p_{T};#chi^{2}_{ITS};#varphi",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C,fgkNPhiBins,binsPhi);
663 fHistList->Add(fPtChi2ITSPhi);
665 fPtSigmaY2 = new TH2F("fPtSigmaY2","fPtSigmaY2",fgkN1PtBins,bins1Pt,fgkNSigmaY2Bins,binsSigmaY2);
666 fHistList->Add(fPtSigmaY2);
668 fPtSigmaZ2 = new TH2F("fPtSigmaZ2","fPtSigmaZ2",fgkN1PtBins,bins1Pt,fgkNSigmaZ2Bins,binsSigmaZ2);
669 fHistList->Add(fPtSigmaZ2);
671 fPtSigmaSnp2 = new TH2F("fPtSigmaSnp2","fPtSigmaSnp2",fgkN1PtBins,bins1Pt,fgkNSigmaSnp2Bins,binsSigmaSnp2);
672 fHistList->Add(fPtSigmaSnp2);
674 fPtSigmaTgl2 = new TH2F("fPtSigmaTgl2","fPtSigmaTgl2",fgkN1PtBins,bins1Pt,fgkNSigmaTgl2Bins,binsSigmaTgl2);
675 fHistList->Add(fPtSigmaTgl2);
677 fPtSigma1Pt2 = new TH2F("fPtSigma1Pt2","fPtSigma1Pt2",fgkN1PtBins,bins1Pt,fgkNSigma1Pt2Bins,binsSigma1Pt2);
678 fHistList->Add(fPtSigma1Pt2);
680 fProfPtSigmaY2 = new TProfile("fProfPtSigmaY2","fProfPtSigmaY2",fgkN1PtBins,bins1Pt);
681 fHistList->Add(fProfPtSigmaY2);
683 fProfPtSigmaZ2 = new TProfile("fProfPtSigmaZ2","fProfPtSigmaZ2",fgkN1PtBins,bins1Pt);
684 fHistList->Add(fProfPtSigmaZ2);
686 fProfPtSigmaSnp2 = new TProfile("fProfPtSigmaSnp2","fProfPtSigmaSnp2",fgkN1PtBins,bins1Pt);
687 fHistList->Add(fProfPtSigmaSnp2);
689 fProfPtSigmaTgl2 = new TProfile("fProfPtSigmaTgl2","fProfPtSigmaTgl2",fgkN1PtBins,bins1Pt);
690 fHistList->Add(fProfPtSigmaTgl2);
692 fProfPtSigma1Pt2 = new TProfile("fProfPtSigma1Pt2","fProfPtSigma1Pt2",fgkN1PtBins,bins1Pt);
693 fHistList->Add(fProfPtSigma1Pt2);
695 fProfPtSigma1Pt = new TProfile("fProfPtSigma1Pt","fProfPtSigma1Pt;p_{T};#sigma(1/p_{T})",fgkNPtBins,binsPt);
696 fHistList->Add(fProfPtSigma1Pt);
698 fProfPtPtSigma1Pt = new TProfile("fProfPtPtSigma1Pt","fProfPtPtSigma1Pt;p_{T};p_{T}#sigma(1/p_{T})",fgkNPtBins,binsPt);
699 fHistList->Add(fProfPtPtSigma1Pt);
701 TH1::AddDirectory(oldStatus);
703 PostData(1, fHistList);
705 if(binsPhi) delete [] binsPhi;
706 if(binsPt) delete [] binsPt;
707 if(binsNClustersTPC) delete [] binsNClustersTPC;
708 if(binsDCA2D) delete [] binsDCA2D;
709 if(binsDCAZ) delete [] binsDCAZ;
710 if(binsNPointITS) delete [] binsNPointITS;
711 if(binsITSClusterMap) delete [] binsITSClusterMap;
712 if(binsNSigmaToVertex) delete [] binsNSigmaToVertex;
713 if(binsChi2C) delete [] binsChi2C;
714 if(binsEta) delete [] binsEta;
715 if(binsRel1PtUncertainty) delete [] binsRel1PtUncertainty;
716 if(binsUncertainty1Pt) delete [] binsUncertainty1Pt;
717 if(binsChi2PerClus) delete [] binsChi2PerClus;
718 if(binsChi2PerClus) delete [] binsNCrossedRowsNClusF;
719 if(bins1Pt) delete [] bins1Pt;
720 if(binsSigmaY2) delete [] binsSigmaY2;
721 if(binsSigmaZ2) delete [] binsSigmaZ2;
722 if(binsSigmaSnp2) delete [] binsSigmaSnp2;
723 if(binsSigmaTgl2) delete [] binsSigmaTgl2;
724 if(binsSigma1Pt2) delete [] binsSigma1Pt2;
727 //________________________________________________________________________
728 Bool_t AliPWG4HighPtTrackQA::SelectEvent() {
730 // Decide if event should be selected for analysis
733 // Checks following requirements:
734 // - fEvent available
735 // - trigger info from AliPhysicsSelection
736 // - MCevent available
737 // - number of reconstructed tracks > 1
738 // - primary vertex reconstructed
739 // - z-vertex < 10 cm
740 // - centrality in case of PbPb
742 Bool_t selectEvent = kTRUE;
744 //fEvent object available?
746 AliDebug(2,Form("ERROR: fInputEvent not available\n"));
747 fNEventReject->Fill("noAliVEvent",1);
748 selectEvent = kFALSE;
752 //Check if number of reconstructed tracks is larger than 1
753 if(!fEvent->GetNumberOfTracks() || fEvent->GetNumberOfTracks()<2) {
754 fNEventReject->Fill("NTracks<2",1);
755 selectEvent = kFALSE;
759 //Check if vertex is reconstructed
760 if(fDataType==kESD&&dynamic_cast<AliESDEvent*>(fEvent)) {
761 fVtx = ((AliESDEvent*)fEvent)->GetPrimaryVertexTracks();
763 if (!fVtx || !fVtx->GetStatus())
764 fVtx = ((AliESDEvent*)fEvent)->GetPrimaryVertexSPD();
767 fNEventReject->Fill("noVTX",1);
768 selectEvent = kFALSE;
772 if(!fVtx->GetStatus()) {
773 fNEventReject->Fill("VtxStatus",1);
774 selectEvent = kFALSE;
779 if(fVtx->GetNContributors()<2) {
780 fNEventReject->Fill("NCont<2",1);
781 selectEvent = kFALSE;
785 //Check if z-vertex < 10 cm
787 fVtx->GetXYZ(primVtx);
788 if(TMath::Sqrt(primVtx[0]*primVtx[0] + primVtx[1]*primVtx[1])>1. || TMath::Abs(primVtx[2]>10.)){
789 fNEventReject->Fill("ZVTX>10",1);
790 selectEvent = kFALSE;
794 else if(fDataType==kAOD&&dynamic_cast<AliAODEvent*>(fEvent)) {
795 const AliAODVertex *vtx = ((AliAODEvent*)fEvent)->GetPrimaryVertexSPD();
797 fNEventReject->Fill("noVTX",1);
798 selectEvent = kFALSE;
803 if(vtx->GetNContributors()<2) {
804 fNEventReject->Fill("NCont<2",1);
805 selectEvent = kFALSE;
809 //Check if z-vertex < 10 cm
811 vtx->GetXYZ(primVtx);
812 if(TMath::Sqrt(primVtx[0]*primVtx[0] + primVtx[1]*primVtx[1])>1. || TMath::Abs(primVtx[2]>10.)){
813 fNEventReject->Fill("ZVTX>10",1);
814 selectEvent = kFALSE;
820 //Centrality selection should only be done in case of PbPb
823 if(fCentClass!=CalculateCentrality(fEvent) && fCentClass!=10) {
824 fNEventReject->Fill("cent",1);
825 selectEvent = kFALSE;
829 if(fDataType==kESD) {
830 if(dynamic_cast<AliESDEvent*>(fEvent)->GetCentrality()) {
831 cent = dynamic_cast<AliESDEvent*>(fEvent)->GetCentrality()->GetCentralityPercentile("V0M");
834 else if(fDataType==kAOD) {
835 if(dynamic_cast<AliAODEvent*>(fEvent)->GetHeader()->GetCentrality())
836 cent = dynamic_cast<AliAODEvent*>(fEvent)->GetHeader()->GetCentrality();
839 fNEventReject->Fill("cent>90",1);
840 selectEvent = kFALSE;
843 fh1Centrality->Fill(cent);
851 //________________________________________________________________________
852 Int_t AliPWG4HighPtTrackQA::CalculateCentrality(AliVEvent *ev){
854 // Get centrality from ESD or AOD
858 return CalculateCentrality(dynamic_cast<AliESDEvent*>(ev));
859 else if(fDataType==kAOD)
860 return CalculateCentrality(dynamic_cast<AliAODEvent*>(ev));
865 //________________________________________________________________________
866 Int_t AliPWG4HighPtTrackQA::CalculateCentrality(AliESDEvent *esd){
868 // Get centrality from ESD
874 if(esd->GetCentrality()){
875 cent = esd->GetCentrality()->GetCentralityPercentile("V0M");
876 if(fDebug>3) printf("centrality: %f\n",cent);
880 return GetCentralityClass(cent);
884 //________________________________________________________________________
885 Int_t AliPWG4HighPtTrackQA::CalculateCentrality(const AliAODEvent *aod){
887 // Get centrality from AOD
891 Float_t cent = aod->GetHeader()->GetCentrality();
892 if(fDebug>3) printf("centrality: %f\n",cent);
894 return GetCentralityClass(cent);
898 //________________________________________________________________________
899 Int_t AliPWG4HighPtTrackQA::GetCentralityClass(Float_t cent) const {
901 // Get centrality class
904 if(cent<0) return 5; // OB - cent sometimes negative
905 if(cent>80) return 4;
906 if(cent>50) return 3;
907 if(cent>30) return 2;
908 if(cent>10) return 1;
913 //________________________________________________________________________
914 void AliPWG4HighPtTrackQA::UserExec(Option_t *) {
916 // Called for each event
917 AliDebug(2,Form(">> AliPWG4HighPtTrackQA::UserExec \n"));
919 fEvent = InputEvent();
920 fESD = dynamic_cast<AliESDEvent*>(InputEvent());
922 // All events without selection
923 fNEventAll->Fill(0.);
927 PostData(1, fHistList);
932 //Need to keep track of selected events
933 fNEventSel->Fill(0.);
935 fVariables = new TArrayF(fNVariables);
937 if(fDataType==kESD) DoAnalysisESD();
938 if(fDataType==kAOD) DoAnalysisAOD();
940 //Delete old fVariables
941 if(fVariables) delete fVariables;
944 PostData(1, fHistList);
948 //________________________________________________________________________
949 void AliPWG4HighPtTrackQA::DoAnalysisESD() {
951 // Run analysis on ESD
955 PostData(1, fHistList);
959 // ---- Get MC Header information (for MC productions in pThard bins) ----
960 Double_t ptHard = 0.;
961 Double_t nTrials = 1; // trials for MC trigger weight for real data
963 AliMCEventHandler *eventHandlerMC = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
964 if (eventHandlerMC) {
966 if(eventHandlerMC->MCEvent()){
967 AliGenPythiaEventHeader* pythiaGenHeader = GetPythiaEventHeader(eventHandlerMC->MCEvent());
969 nTrials = pythiaGenHeader->Trials();
970 ptHard = pythiaGenHeader->GetPtHard();
972 fh1PtHard->Fill(ptHard);
973 fh1PtHardTrials->Fill(ptHard,nTrials);
975 fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
980 Int_t nTracks = fESD->GetNumberOfTracks();
981 AliDebug(2,Form("nTracks ESD%d", nTracks));
984 Variables to be put in fVariables
995 10: chi2PerClusterTPC
997 12: (#crossed rows)/(#findable clusters)
1003 18: NClustersTPCIter1
1005 20: nClustersTPCShared
1006 21: Golden Chi2 - global vs TPC constrained
1007 22: Chi2 between global and global constrained
1008 23: #crossed rows from fit map
1009 24: (#crossed rows)/(#findable clusters) from fit map
1013 for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
1014 fh1NTracksAll->Fill(0.);
1016 //Get track for analysis
1017 AliESDtrack *track = 0x0;
1018 AliESDtrack *esdtrack = fESD->GetTrack(iTrack);
1020 fh1NTracksReject->Fill("noESDtrack",1);
1023 AliESDtrack *origtrack = new AliESDtrack(*esdtrack);
1028 if (!(fTrackCuts->AcceptTrack(esdtrack))) {
1029 fh1NTracksReject->Fill("trackCuts",1);
1030 if(origtrack) delete origtrack;
1036 track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
1037 else if(fTrackType==2 || fTrackType==4) {
1038 track = AliESDtrackCuts::GetTPCOnlyTrack(const_cast<AliESDEvent*>(fESD),esdtrack->GetID());
1040 fh1NTracksReject->Fill("noTPConly",1);
1041 if(origtrack) delete origtrack;
1044 AliExternalTrackParam exParam;
1045 Bool_t relate = track->RelateToVertexTPC(fVtx,fESD->GetMagneticField(),kVeryBig,&exParam);
1047 fh1NTracksReject->Fill("relate",1);
1048 if(track) delete track;
1049 if(origtrack) delete origtrack;
1052 track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
1054 else if(fTrackType==5 || fTrackType==6) {
1055 if(fTrackCuts->AcceptTrack(esdtrack)) {
1056 if(origtrack) delete origtrack;
1060 if( !(fTrackCutsITSLoose->AcceptTrack(esdtrack)) && fTrackCutsTPConly->AcceptTrack(esdtrack) ) {
1063 //use TPConly constrained track
1064 track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
1066 fh1NTracksReject->Fill("noTPConly",1);
1067 if(origtrack) delete origtrack;
1070 AliExternalTrackParam exParam;
1071 Bool_t relate = track->RelateToVertexTPC(fVtx,fESD->GetMagneticField(),kVeryBig,&exParam);
1073 fh1NTracksReject->Fill("relate",1);
1074 if(track) delete track;
1075 if(origtrack) delete origtrack;
1078 track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
1080 else if(fTrackType==6) {
1081 //use global constrained track
1082 track = new AliESDtrack(*esdtrack);
1083 track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
1089 else if(fTrackType==7) {
1090 //use global constrained track
1091 track = new AliESDtrack(*esdtrack);
1097 if(origtrack) delete origtrack;
1101 if(fTrackType==2 || fTrackType==4 || fTrackType==5) {
1102 //Cut on chi2 of constrained fit
1103 if(track->GetConstrainedChi2TPC() > fSigmaConstrainedMax*fSigmaConstrainedMax && fSigmaConstrainedMax>0.) {
1104 fh1NTracksReject->Fill("chi2",1);
1105 if(track) delete track;
1106 if(origtrack) delete origtrack;
1111 fPtAll->Fill(track->Pt());
1113 if (!(fTrackCuts->AcceptTrack(track)) && fTrackType!=4 && fTrackType!=5 && fTrackType!=6) {
1114 fh1NTracksReject->Fill("trackCuts",1);
1115 if(fTrackType==1 || fTrackType==2 || fTrackType==7) {
1116 if(track) delete track;
1118 if(origtrack) delete origtrack;
1123 if(fTrackCutsITSLoose ) {
1124 if(fTrackCutsITSLoose->AcceptTrack(track) ) {
1125 if(track) delete track;
1126 if(origtrack) delete origtrack;
1131 if(esdtrack->GetConstrainedParam())
1132 track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
1136 if(fTrackType==1 || fTrackType==2 || fTrackType==4 || fTrackType==5 || fTrackType==6 || fTrackType==7) {
1137 if(track) delete track;
1139 if(origtrack) delete origtrack;
1143 fh1NTracksSel->Fill(0.);
1145 fVariables->Reset(0.);
1147 fVariables->SetAt(track->Pt(),0);
1148 fVariables->SetAt(track->Phi(),1);
1149 fVariables->SetAt(track->Eta(),2);
1154 if(fTrackType==1 || fTrackType==2 || fTrackType==4) {
1155 track->GetImpactParametersTPC(dca2D,dcaz); //TPConly
1158 track->GetImpactParameters(dca2D,dcaz); //Global
1160 fVariables->SetAt(dca2D,3);
1161 fVariables->SetAt(dcaz,4);
1163 fVariables->SetAt((float)track->GetTPCNcls(),5);
1165 Int_t nPointITS = 0;
1166 fITSClusterMap = track->GetITSClusterMap();
1167 UChar_t itsMap = track->GetITSClusterMap();
1168 for (Int_t i=0; i < 6; i++) {
1169 if (itsMap & (1 << i))
1172 fVariables->SetAt((float)nPointITS,6);
1173 Float_t chi2C = (float)track->GetConstrainedChi2();
1174 if(fTrackType==1 || fTrackType==2 || fTrackType==4)
1175 chi2C = (float)track->GetConstrainedChi2TPC();
1176 fVariables->SetAt(chi2C,7);
1177 fVariables->SetAt(fTrackCuts->GetSigmaToVertex(track),8);// Calculates the number of sigma to the vertex for a track.
1179 fVariables->SetAt(GetTrackLengthTPC(track),9);
1181 if(fVariables->At(5)>0.) fVariables->SetAt(track->GetTPCchi2()/fVariables->At(5),10);
1183 //fVariables->SetAt(track->GetTPCClusterInfo(2,1),11); //#crossed rows
1184 fVariables->SetAt(track->GetTPCCrossedRows(),11); //#crossed rows
1186 Float_t crossedRowsTPCNClsF = 1.;//track->GetTPCClusterInfo(2,0);
1187 if(track->GetTPCNclsF()>0.) crossedRowsTPCNClsF = fVariables->At(11)/track->GetTPCNclsF();
1188 fVariables->SetAt(crossedRowsTPCNClsF,12);//(#crossed rows)/(#findable clusters)
1189 fVariables->SetAt(track->GetSigmaY2(),13);
1190 fVariables->SetAt(track->GetSigmaZ2(),14);
1191 fVariables->SetAt(track->GetSigmaSnp2(),15);
1192 fVariables->SetAt(track->GetSigmaTgl2(),16);
1193 fVariables->SetAt(track->GetSigma1Pt2(),17);
1195 fVariables->SetAt(track->GetTPCNclsIter1(),18);
1196 fVariables->SetAt(track->GetTPCchi2Iter1(),19);
1198 fVariables->SetAt(track->GetTPCnclsS(),20);
1200 Float_t chi2Gold = origtrack->GetChi2TPCConstrainedVsGlobal(fVtx);//GetGoldenChi2(origtrack);
1201 Float_t chi2GGC = GetGGCChi2(origtrack);
1203 fVariables->SetAt(chi2Gold,21);
1204 fVariables->SetAt(chi2GGC,22);
1206 fVariables->SetAt(GetTPCClusterInfoFitMap(track,2,1),23);
1207 Float_t crossedRowsTPCNClsFFit = 1.;
1208 if(track->GetTPCNclsF()>0.) crossedRowsTPCNClsFFit = fVariables->At(23)/track->GetTPCNclsF();
1209 fVariables->SetAt(crossedRowsTPCNClsFFit,24);
1211 fVariables->SetAt(track->GetITSchi2(),25);
1213 TBits fitmap = track->GetTPCFitMap();
1214 fPtNClustersNClustersFitMap->Fill(track->Pt(),track->GetTPCNcls(),(float)fitmap.CountBits());
1218 // int mult = fTrackCuts->CountAcceptedTracks(fESD);
1220 if(fTrackType==1 || fTrackType==2 || fTrackType==4 || fTrackType==5 || fTrackType==6 || fTrackType==7) {
1221 if(track) delete track;
1223 if(origtrack) delete origtrack;
1229 //________________________________________________________________________
1230 void AliPWG4HighPtTrackQA::DoAnalysisAOD() {
1232 // Do QA on AOD input
1234 AliAODEvent *aod = dynamic_cast<AliAODEvent*>(fEvent);
1236 AliExternalTrackParam exParam;
1237 for (Int_t iTrack = 0; iTrack < fEvent->GetNumberOfTracks(); iTrack++) {
1239 AliAODTrack *aodtrack = aod->GetTrack(iTrack);
1240 // if(aodtrack->GetFilterMap()>128 && aodtrack->GetFilterMap()<1333)
1241 // Printf("filterMask = %d",aodtrack->GetFilterMap());
1242 // if(aodtrack->IsHybridGlobalConstrainedGlobal()) {
1243 // Printf("hybrid filterMask = %d",aodtrack->GetFilterMap());
1244 // if(aodtrack->IsGlobalConstrained())
1245 // Printf("global constrained filterMask = %d",aodtrack->GetFilterMap());
1247 if( !aodtrack->TestFilterMask(fFilterMask) ) {
1248 fh1NTracksReject->Fill("noHybridTrack",1);
1252 if(!fIncludeNoITS) {
1253 if ((aodtrack->GetStatus()&AliESDtrack::kITSrefit)==0) {
1254 fh1NTracksReject->Fill("noITSrefit",1);
1259 fVariables->Reset(0.);
1261 fVariables->SetAt(aodtrack->Pt(),0);
1262 fVariables->SetAt(aodtrack->Phi(),1);
1263 fVariables->SetAt(aodtrack->Eta(),2);
1265 Double_t dca[2] = {1e6,1e6};
1266 Double_t covar[3] = {1e6,1e6,1e6};
1267 if(aodtrack->PropagateToDCA(fEvent->GetPrimaryVertex(),fEvent->GetMagneticField(),100.,dca,covar)) {
1268 fVariables->SetAt(dca[0],3);
1269 fVariables->SetAt(dca[1],4);
1272 fVariables->SetAt((float)aodtrack->GetTPCNcls(),5);
1273 fVariables->SetAt((float)aodtrack->GetITSNcls(),6);
1274 fVariables->SetAt(aodtrack->Chi2perNDF(),7);
1275 fVariables->SetAt(0.,8);
1276 fVariables->SetAt(GetTrackLengthTPC(aodtrack),9);
1277 fVariables->SetAt(aodtrack->Chi2perNDF(),10);
1278 fVariables->SetAt(GetTPCClusterInfo(aodtrack,2,1,0,159,kFALSE),11);
1279 Float_t crossedRowsTPCNClsF = 0.;
1280 if(aodtrack->GetTPCNclsF()>0.) crossedRowsTPCNClsF = fVariables->At(11)/aodtrack->GetTPCNclsF();
1281 fVariables->SetAt(crossedRowsTPCNClsF,12);
1283 //get covariance matrix
1284 Double_t cov[21] = {0,};
1285 aodtrack->GetCovMatrix(cov);
1286 Double_t pxpypz[3] = {0,};
1287 aodtrack->PxPyPz(pxpypz);
1288 Double_t xyz[3] = {0,};
1289 aodtrack->GetXYZ(xyz);
1290 Short_t sign = aodtrack->Charge();
1291 exParam.Set(xyz,pxpypz,cov,sign);
1293 fVariables->SetAt(exParam.GetSigmaY2(),13);
1294 fVariables->SetAt(exParam.GetSigmaZ2(),14);
1295 fVariables->SetAt(exParam.GetSigmaSnp2(),15);
1296 fVariables->SetAt(exParam.GetSigmaTgl2(),16);
1297 fVariables->SetAt(exParam.GetSigma1Pt2(),17);
1299 fVariables->SetAt(0.,18); //NClustersTPCIter1
1300 fVariables->SetAt(0.,19); //Chi2TPCIter1
1302 TBits sharedClusterMap = aodtrack->GetTPCSharedMap();
1303 fVariables->SetAt(sharedClusterMap.CountBits(),20);
1305 fVariables->SetAt(0.,21); //not available in AOD golden chi2
1306 fVariables->SetAt(0.,22); //not available in AOD Chi2 between global and global constrained
1308 fVariables->SetAt(GetTPCClusterInfo(aodtrack,2,1,0,159,kTRUE),23); //not available in AOD #crossed rows from fit map
1309 Float_t crossedRowsTPCNClsFFit = 0.;
1310 if(aodtrack->GetTPCNclsF()>0.) crossedRowsTPCNClsFFit = fVariables->At(23)/aodtrack->GetTPCNclsF();
1311 fVariables->SetAt(crossedRowsTPCNClsFFit,24); //(#crossed rows)/(#findable clusters) from fit map
1313 fVariables->SetAt(0.,25);
1315 fPtAll->Fill(fVariables->At(0));
1323 //________________________________________________________________________
1324 void AliPWG4HighPtTrackQA::FillHistograms() {
1326 // Fill all QA histograms
1329 fPtSel->Fill(fVariables->At(0));
1330 fPtPhi->Fill(fVariables->At(0),fVariables->At(1));
1331 fPtEta->Fill(fVariables->At(0),fVariables->At(2));
1332 fPtEtaPhi->Fill(fVariables->At(0),fVariables->At(2),fVariables->At(1));
1333 fPtDCA2D->Fill(fVariables->At(0),fVariables->At(3));
1334 fPtDCAZ->Fill(fVariables->At(0),fVariables->At(4));
1335 fPtNClustersTPC->Fill(fVariables->At(0),fVariables->At(5));
1336 fPtNPointITS->Fill(fVariables->At(0),fVariables->At(6));
1337 fPtNPointITSPhi->Fill(fVariables->At(0),fVariables->At(6),fVariables->At(1));
1339 fPtNClustersTPCIter1->Fill(fVariables->At(0),fVariables->At(18));
1340 fPtNClustersTPCIter1Phi->Fill(fVariables->At(0),fVariables->At(18),fVariables->At(1));
1341 fPtNClustersTPCShared->Fill(fVariables->At(0),fVariables->At(20));
1342 if(fVariables->At(5)>0.)
1343 fPtNClustersTPCSharedFrac->Fill(fVariables->At(0),fVariables->At(20)/fVariables->At(5));
1345 if(fVariables->At(18)>0.)
1346 fPtChi2PerClusterTPCIter1->Fill(fVariables->At(0),fVariables->At(19)/fVariables->At(18));
1348 fPtChi2C->Fill(fVariables->At(0),fVariables->At(7));
1349 fPtNSigmaToVertex->Fill(fVariables->At(0),fVariables->At(8));
1350 fPtRelUncertainty1Pt->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)));
1351 fPtRelUncertainty1PtNClus->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(5));
1352 fPtRelUncertainty1PtNClusIter1->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(18));
1353 fPtRelUncertainty1PtNPointITS->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(6));
1355 fPtRelUncertainty1PtITSClusterMap->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),(int)fITSClusterMap);
1357 fPtRelUncertainty1PtChi2->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(10));
1358 if(fVariables->At(18)>0.)
1359 fPtRelUncertainty1PtChi2Iter1->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(19)/fVariables->At(18));
1360 fPtRelUncertainty1PtPhi->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(1));
1362 fPtSigmaY2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(13)));
1363 fPtSigmaZ2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(14)));
1364 fPtSigmaSnp2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(15)));
1365 fPtSigmaTgl2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(16)));
1366 fPtSigma1Pt2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
1368 fProfPtSigmaY2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(13)));
1369 fProfPtSigmaZ2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(14)));
1370 fProfPtSigmaSnp2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(15)));
1371 fProfPtSigmaTgl2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(16)));
1372 fProfPtSigma1Pt2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
1373 fProfPtSigma1Pt->Fill(fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
1374 fProfPtPtSigma1Pt->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)));
1376 fPtChi2PerClusterTPC->Fill(fVariables->At(0),fVariables->At(10));
1377 fPtNCrossedRows->Fill(fVariables->At(0),fVariables->At(11));
1378 fPtNCrossedRowsPhi->Fill(fVariables->At(0),fVariables->At(11),fVariables->At(1));
1379 fPtNCrossedRowsNClusFPhi->Fill(fVariables->At(0),fVariables->At(12),fVariables->At(1));
1380 fPtNCrRNCrRNClusF->Fill(fVariables->At(0),fVariables->At(11),fVariables->At(12));
1382 fPtChi2Gold->Fill(fVariables->At(0),fVariables->At(21));
1383 fPtChi2GGC->Fill(fVariables->At(0),fVariables->At(22));
1385 fPtChi2GoldPhi->Fill(fVariables->At(0),fVariables->At(21),fVariables->At(1));
1386 fPtChi2GGCPhi->Fill(fVariables->At(0),fVariables->At(22),fVariables->At(1));
1388 fChi2GoldChi2GGC->Fill(fVariables->At(21),fVariables->At(22));
1390 fPtNCrossedRowsFit->Fill(fVariables->At(0),fVariables->At(23));
1391 fPtNCrossedRowsFitPhi->Fill(fVariables->At(0),fVariables->At(23),fVariables->At(1));
1392 fPtNCrossedRowsNClusFFitPhi->Fill(fVariables->At(0),fVariables->At(24),fVariables->At(1));
1393 fNCrossedRowsNCrossedRowsFit->Fill(fVariables->At(11),fVariables->At(23));
1395 fNClustersNCrossedRows->Fill(fVariables->At(5),fVariables->At(11));
1396 fNClustersNCrossedRowsFit->Fill(fVariables->At(5),fVariables->At(23));
1398 fPtRelUncertainty1PtNCrossedRows->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(11));
1399 fPtRelUncertainty1PtNCrossedRowsFit->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(23));
1401 if(fVariables->At(6)>0.)
1402 fPtChi2ITSPhi->Fill(fVariables->At(0),fVariables->At(25)/fVariables->At(6),fVariables->At(1));
1406 //________________________________________________________________________
1407 Bool_t AliPWG4HighPtTrackQA::PythiaInfoFromFile(const char* currFile,Float_t &fXsec,Float_t &fTrials){
1409 // get the cross section and the trails either from pyxsec.root or from pysec_hists.root
1410 // This is to called in Notify and should provide the path to the AOD/ESD file
1411 // Copied from AliAnalysisTaskJetSpectrum2
1414 TString file(currFile);
1418 if(file.Contains("root_archive.zip#")){
1419 Ssiz_t pos1 = file.Index("root_archive",12,TString::kExact);
1420 Ssiz_t pos = file.Index("#",1,pos1,TString::kExact);
1421 file.Replace(pos+1,20,"");
1424 // not an archive take the basename....
1425 file.ReplaceAll(gSystem->BaseName(file.Data()),"");
1428 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
1430 // next trial fetch the histgram file
1431 fxsec = TFile::Open(Form("%s%s",file.Data(),"pyxsec_hists.root"));
1433 // not a severe condition but inciate that we have no information
1437 // find the tlist we want to be independtent of the name so use the Tkey
1438 TKey* key = (TKey*)fxsec->GetListOfKeys()->At(0);
1443 TList *list = dynamic_cast<TList*>(key->ReadObj());
1448 fXsec = ((TProfile*)list->FindObject("h1Xsec"))->GetBinContent(1);
1449 fTrials = ((TH1F*)list->FindObject("h1Trials"))->GetBinContent(1);
1452 } // no tree pyxsec.root
1454 TTree *xtree = (TTree*)fxsec->Get("Xsection");
1460 Double_t xsection = 0;
1461 xtree->SetBranchAddress("xsection",&xsection);
1462 xtree->SetBranchAddress("ntrials",&ntrials);
1470 //________________________________________________________________________
1471 Bool_t AliPWG4HighPtTrackQA::Notify()
1474 // Implemented Notify() to read the cross sections
1475 // and number of trials from pyxsec.root
1476 // Copied from AliAnalysisTaskJetSpectrum2
1479 TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
1480 Float_t xsection = 0;
1481 Float_t ftrials = 1;
1485 TFile *curfile = tree->GetCurrentFile();
1487 Error("Notify","No current file");
1490 if(!fh1Xsec||!fh1Trials){
1491 // Printf("%s%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__);
1494 PythiaInfoFromFile(curfile->GetName(),xsection,ftrials);
1495 fh1Xsec->Fill("<#sigma>",xsection);
1496 // construct a poor man average trials
1497 Float_t nEntries = (Float_t)tree->GetTree()->GetEntries();
1498 if(ftrials>=nEntries && nEntries>0.)fAvgTrials = ftrials/nEntries;
1503 //________________________________________________________________________
1504 AliGenPythiaEventHeader* AliPWG4HighPtTrackQA::GetPythiaEventHeader(const AliMCEvent *mcEvent){
1506 if(!mcEvent)return 0;
1507 AliGenEventHeader* genHeader = mcEvent->GenEventHeader();
1508 AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
1509 if(!pythiaGenHeader){
1511 AliGenCocktailEventHeader* genCocktailHeader = dynamic_cast<AliGenCocktailEventHeader*>(genHeader);
1513 if (!genCocktailHeader) {
1514 // AliWarningGeneral(Form(" %s:%d",(char*)__FILE__,__LINE__),"Unknown header type (not Pythia or Cocktail)");
1515 // AliWarning(Form("%s %d: Unknown header type (not Pythia or Cocktail)",(char*)__FILE__,__LINE__));
1518 TList* headerList = genCocktailHeader->GetHeaders();
1519 for (Int_t i=0; i<headerList->GetEntries(); i++) {
1520 pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(headerList->At(i));
1521 if (pythiaGenHeader)
1524 if(!pythiaGenHeader){
1525 AliWarningGeneral(Form(" %s:%d",(char*)__FILE__,__LINE__),"Pythia event header not found");
1529 return pythiaGenHeader;
1533 //_______________________________________________________________________
1534 Float_t AliPWG4HighPtTrackQA::GetTPCClusterInfo(const AliAODTrack *tr,Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Bool_t useFitMap) const
1536 //MV: copied from AliESDtrack since method is not available in AliAODTrack
1539 // TPC cluster information
1540 // type 0: get fraction of found/findable clusters with neighbourhood definition
1541 // 1: findable clusters with neighbourhood definition
1542 // 2: found clusters
1544 // definition of findable clusters:
1545 // a cluster is defined as findable if there is another cluster
1546 // within +- nNeighbours pad rows. The idea is to overcome threshold
1547 // effects with a very simple algorithm.
1550 TBits fTPCClusterMap = 0;
1552 fTPCClusterMap = tr->GetTPCFitMap();
1554 fTPCClusterMap = tr->GetTPCClusterMap();
1556 if (type==2) return fTPCClusterMap.CountBits();
1560 Int_t last=-nNeighbours;
1562 for (Int_t i=row0; i<row1; ++i){
1563 //look to current row
1564 if (fTPCClusterMap[i]) {
1570 //look to nNeighbours before
1571 if ((i-last)<=nNeighbours) {
1575 //look to nNeighbours after
1576 for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
1577 if (fTPCClusterMap[j]){
1583 if (type==1) return findable;
1588 fraction=(Float_t)found/(Float_t)findable;
1593 return 0; // undefined type - default value
1596 //_______________________________________________________________________
1597 Float_t AliPWG4HighPtTrackQA::GetTPCClusterInfoFitMap(const AliESDtrack *tr,Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1) const
1600 // TPC cluster information from fit map
1601 // type 0: get fraction of found/findable clusters with neighbourhood definition
1602 // 1: findable clusters with neighbourhood definition
1603 // 2: found clusters
1605 // definition of findable clusters:
1606 // a cluster is defined as findable if there is another cluster
1607 // within +- nNeighbours pad rows. The idea is to overcome threshold
1608 // effects with a very simple algorithm.
1611 TBits fTPCFitMap = tr->GetTPCFitMap();
1612 if (type==2) return fTPCFitMap.CountBits();
1616 Int_t last=-nNeighbours;
1618 for (Int_t i=row0; i<row1; ++i){
1619 //look to current row
1620 if (fTPCFitMap[i]) {
1626 //look to nNeighbours before
1627 if ((i-last)<=nNeighbours) {
1631 //look to nNeighbours after
1632 for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
1639 if (type==1) return findable;
1644 fraction=(Float_t)found/(Float_t)findable;
1649 return 0; // undefined type - default value
1652 //_______________________________________________________________________
1653 Int_t AliPWG4HighPtTrackQA::GetTrackLengthTPC(const AliESDtrack *track) const {
1655 // returns distance between 1st and last hit in TPC
1656 // distance given in number of padrows
1659 TBits fTPCClusterMap = track->GetTPCClusterMap();
1663 for(int i=0; i<=159; i++) {
1664 if(fTPCClusterMap[i]>0) firstHit = i;
1666 for(int i=159; i>=0; i--) {
1667 if(fTPCClusterMap[i]>0) lastHit = i;
1670 Int_t trackLength = lastHit - firstHit;
1675 //_______________________________________________________________________
1676 Int_t AliPWG4HighPtTrackQA::GetTrackLengthTPC(const AliAODTrack *track) const {
1678 // returns distance between 1st and last hit in TPC
1679 // distance given in number of padrows
1682 TBits fTPCClusterMap = track->GetTPCClusterMap();
1686 for(int i=0; i<=159; i++) {
1687 if(fTPCClusterMap[i]>0) firstHit = i;
1689 for(int i=159; i>=0; i--) {
1690 if(fTPCClusterMap[i]>0) lastHit = i;
1693 Int_t trackLength = lastHit - firstHit;
1698 //_______________________________________________________________________
1699 Float_t AliPWG4HighPtTrackQA::GetGoldenChi2(AliESDtrack *origtrack) {
1701 // Return chi2 between global and TPC constrained track
1702 // track should be the global unconstrained track
1705 Float_t chi2Gold = 0.;
1707 AliESDtrack *tpcTrack = 0x0;
1708 tpcTrack = AliESDtrackCuts::GetTPCOnlyTrack(fESD,origtrack->GetID());
1710 AliExternalTrackParam exParam;
1711 Bool_t relate = tpcTrack->RelateToVertexTPC(fVtx,fESD->GetMagneticField(),kVeryBig,&exParam);
1713 tpcTrack->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
1714 // Double_t pTPC[2],covTPC[3]; tpcTrack->PropagateToDCA(fVtx, fESD->GetMagneticField(), 10000, pTPC, covTPC);
1717 tpcTrack->Propagate(origtrack->GetAlpha(), origtrack->GetX(), fESD->GetMagneticField());
1718 chi2Gold = (Float_t)origtrack->GetPredictedChi2(tpcTrack);
1721 if(tpcTrack) delete tpcTrack;
1727 //_______________________________________________________________________
1728 Float_t AliPWG4HighPtTrackQA::GetGGCChi2(AliESDtrack *origtrack) {
1730 // Return chi2 between global and global constrained track
1731 // track should be the global unconstrained track
1734 Float_t chi2GGC = 0.;
1736 AliESDtrack *esdtrackC = new AliESDtrack(*origtrack);
1738 if(origtrack->GetConstrainedParam()) {
1739 esdtrackC->Set(origtrack->GetConstrainedParam()->GetX(),origtrack->GetConstrainedParam()->GetAlpha(),origtrack->GetConstrainedParam()->GetParameter(),origtrack->GetConstrainedParam()->GetCovariance());
1740 chi2GGC = (Float_t)origtrack->GetPredictedChi2(esdtrackC);
1749 //________________________________________________________________________
1750 void AliPWG4HighPtTrackQA::Terminate(Option_t *)
1752 // The Terminate() function is the last function to be called during
1753 // a query. It always runs on the client, it can be used to present
1754 // the results graphically or save the results to file.