]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - CORRFW/AliCFTrackQualityCuts.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Additional cuts on TPC and TRD quantities.
[u/mrichter/AliRoot.git] / CORRFW / AliCFTrackQualityCuts.cxx
... / ...
CommitLineData
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// The class AliCFTrackQualityCuts is designed to select reconstructed tracks
17// of high quality and to provide corresponding QA histograms.
18// This class inherits from the Analysis' Framework abstract base class
19// AliAnalysisCuts and is a part of the Correction Framework.
20// This class acts on single, reconstructed tracks, it is applicable on
21// ESD and AOD data.
22// It mainly consists of a IsSelected function that returns a boolean.
23// This function checks whether the considered track passes a set of cuts:
24// - number of clusters in the ITS
25// - number of clusters in the TPC
26// - number of clusters in the TRD
27// - ratio of found / finable number of clusters in the TPC
28// - number of tracklets in the TRD
29// - number TRD tracklets used for pid
30// - chi2 / cluster in the ITS
31// - chi2 / cluster in the TPC
32// - chi2 / tracklet in the TRD
33// - successful TPC refit
34// - successful ITS refit
35// - covariance matrix diagonal elements
36//
37// The cut values for these cuts are set with the corresponding set functions.
38// All cut classes provided by the correction framework are supposed to be
39// added in the Analysis Framwork's class AliAnalysisFilter and applied by
40// the filter via a loop.
41//
42// author: I. Kraus (Ingrid.Kraus@cern.ch)
43// idea taken form
44// AliESDtrackCuts writte by Jan Fiete Grosse-Oetringhaus and
45// AliRsnDaughterCut class written by A. Pulvirenti.
46
47
48#include <TCanvas.h>
49#include <TDirectory.h>
50#include <TH2.h>
51#include <TBits.h>
52
53#include <AliESDtrack.h>
54#include <AliLog.h>
55#include "AliCFTrackQualityCuts.h"
56#include "AliAODTrack.h"
57
58ClassImp(AliCFTrackQualityCuts)
59
60//__________________________________________________________________________________
61AliCFTrackQualityCuts::AliCFTrackQualityCuts() :
62 AliCFCutBase(),
63 fMinNClusterTPC(0),
64 fMinNClusterITS(0),
65 fMinNClusterTRD(0),
66 fMinFoundClusterTPC(0),
67 fMinNTrackletTRD(0),
68 fMinNTrackletTRDpid(0),
69 fMaxChi2PerClusterTPC(0),
70 fMaxChi2PerClusterITS(0),
71 fMaxChi2PerTrackletTRD(0),
72 fCovariance11Max(0),
73 fCovariance22Max(0),
74 fCovariance33Max(0),
75 fCovariance44Max(0),
76 fCovariance55Max(0),
77 fStatus(0),
78 fhCutStatistics(0),
79 fhCutCorrelation(0),
80 fBitmap(0x0),
81 fhNBinsClusterTPC(0),
82 fhNBinsClusterITS(0),
83 fhNBinsClusterTRD(0),
84 fhNBinsFoundClusterTPC(0),
85 fhNBinsTrackletTRD(0),
86 fhNBinsTrackletTRDpid(0),
87 fhNBinsChi2TPC(0),
88 fhNBinsChi2ITS(0),
89 fhNBinsChi2TRD(0),
90 fhNBinsCovariance11(0),
91 fhNBinsCovariance22(0),
92 fhNBinsCovariance33(0),
93 fhNBinsCovariance44(0),
94 fhNBinsCovariance55(0),
95 fhBinLimClusterTPC(0x0),
96 fhBinLimClusterITS(0x0),
97 fhBinLimClusterTRD(0x0),
98 fhBinLimFoundClusterTPC(0x0),
99 fhBinLimTrackletTRD(0x0),
100 fhBinLimTrackletTRDpid(0x0),
101 fhBinLimChi2TPC(0x0),
102 fhBinLimChi2ITS(0x0),
103 fhBinLimChi2TRD(0x0),
104 fhBinLimCovariance11(0x0),
105 fhBinLimCovariance22(0x0),
106 fhBinLimCovariance33(0x0),
107 fhBinLimCovariance44(0x0),
108 fhBinLimCovariance55(0x0)
109{
110 //
111 // Default constructor
112 //
113 Initialise();
114}
115//__________________________________________________________________________________
116AliCFTrackQualityCuts::AliCFTrackQualityCuts(Char_t* name, Char_t* title) :
117 AliCFCutBase(name,title),
118 fMinNClusterTPC(0),
119 fMinNClusterITS(0),
120 fMinNClusterTRD(0),
121 fMinFoundClusterTPC(0),
122 fMinNTrackletTRD(0),
123 fMinNTrackletTRDpid(0),
124 fMaxChi2PerClusterTPC(0),
125 fMaxChi2PerClusterITS(0),
126 fMaxChi2PerTrackletTRD(0),
127 fCovariance11Max(0),
128 fCovariance22Max(0),
129 fCovariance33Max(0),
130 fCovariance44Max(0),
131 fCovariance55Max(0),
132 fStatus(0),
133 fhCutStatistics(0),
134 fhCutCorrelation(0),
135 fBitmap(0x0),
136 fhNBinsClusterTPC(0),
137 fhNBinsClusterITS(0),
138 fhNBinsClusterTRD(0),
139 fhNBinsFoundClusterTPC(0),
140 fhNBinsTrackletTRD(0),
141 fhNBinsTrackletTRDpid(0),
142 fhNBinsChi2TPC(0),
143 fhNBinsChi2ITS(0),
144 fhNBinsChi2TRD(0),
145 fhNBinsCovariance11(0),
146 fhNBinsCovariance22(0),
147 fhNBinsCovariance33(0),
148 fhNBinsCovariance44(0),
149 fhNBinsCovariance55(0),
150 fhBinLimClusterTPC(0x0),
151 fhBinLimClusterITS(0x0),
152 fhBinLimClusterTRD(0x0),
153 fhBinLimFoundClusterTPC(0x0),
154 fhBinLimTrackletTRD(0x0),
155 fhBinLimTrackletTRDpid(0x0),
156 fhBinLimChi2TPC(0x0),
157 fhBinLimChi2ITS(0x0),
158 fhBinLimChi2TRD(0x0),
159 fhBinLimCovariance11(0x0),
160 fhBinLimCovariance22(0x0),
161 fhBinLimCovariance33(0x0),
162 fhBinLimCovariance44(0x0),
163 fhBinLimCovariance55(0x0)
164{
165 //
166 // Constructor
167 //
168 Initialise();
169}
170//__________________________________________________________________________________
171AliCFTrackQualityCuts::AliCFTrackQualityCuts(const AliCFTrackQualityCuts& c) :
172 AliCFCutBase(c),
173 fMinNClusterTPC(c.fMinNClusterTPC),
174 fMinNClusterITS(c.fMinNClusterITS),
175 fMinNClusterTRD(c.fMinNClusterTRD),
176 fMinFoundClusterTPC(c.fMinFoundClusterTPC),
177 fMinNTrackletTRD(c.fMinNTrackletTRD),
178 fMinNTrackletTRDpid(c.fMinNTrackletTRDpid),
179 fMaxChi2PerClusterTPC(c.fMaxChi2PerClusterTPC),
180 fMaxChi2PerClusterITS(c.fMaxChi2PerClusterITS),
181 fMaxChi2PerTrackletTRD(c.fMaxChi2PerTrackletTRD),
182 fCovariance11Max(c.fCovariance11Max),
183 fCovariance22Max(c.fCovariance22Max),
184 fCovariance33Max(c.fCovariance33Max),
185 fCovariance44Max(c.fCovariance44Max),
186 fCovariance55Max(c.fCovariance55Max),
187 fStatus(c.fStatus),
188 fhCutStatistics(c.fhCutStatistics),
189 fhCutCorrelation(c.fhCutCorrelation),
190 fBitmap(c.fBitmap),
191 fhNBinsClusterTPC(c.fhNBinsClusterTPC),
192 fhNBinsClusterITS(c.fhNBinsClusterITS),
193 fhNBinsClusterTRD(c.fhNBinsClusterTRD),
194 fhNBinsFoundClusterTPC(c.fhNBinsFoundClusterTPC),
195 fhNBinsTrackletTRD(c.fhNBinsTrackletTRD),
196 fhNBinsTrackletTRDpid(c.fhNBinsTrackletTRDpid),
197 fhNBinsChi2TPC(c.fhNBinsChi2TPC),
198 fhNBinsChi2ITS(c.fhNBinsChi2ITS),
199 fhNBinsChi2TRD(c.fhNBinsChi2TRD),
200 fhNBinsCovariance11(c.fhNBinsCovariance11),
201 fhNBinsCovariance22(c.fhNBinsCovariance22),
202 fhNBinsCovariance33(c.fhNBinsCovariance33),
203 fhNBinsCovariance44(c.fhNBinsCovariance44),
204 fhNBinsCovariance55(c.fhNBinsCovariance55),
205 fhBinLimClusterTPC(c.fhBinLimClusterTPC),
206 fhBinLimClusterITS(c.fhBinLimClusterITS),
207 fhBinLimClusterTRD(c.fhBinLimClusterTRD),
208 fhBinLimFoundClusterTPC(c.fhBinLimFoundClusterTPC),
209 fhBinLimTrackletTRD(c.fhBinLimTrackletTRD),
210 fhBinLimTrackletTRDpid(c.fhBinLimTrackletTRDpid),
211 fhBinLimChi2TPC(c.fhBinLimChi2TPC),
212 fhBinLimChi2ITS(c.fhBinLimChi2ITS),
213 fhBinLimChi2TRD(c.fhBinLimChi2TRD),
214 fhBinLimCovariance11(c.fhBinLimCovariance11),
215 fhBinLimCovariance22(c.fhBinLimCovariance22),
216 fhBinLimCovariance33(c.fhBinLimCovariance33),
217 fhBinLimCovariance44(c.fhBinLimCovariance44),
218 fhBinLimCovariance55(c.fhBinLimCovariance55)
219{
220 //
221 // copy constructor
222 //
223 ((AliCFTrackQualityCuts &) c).Copy(*this);
224}
225//__________________________________________________________________________________
226AliCFTrackQualityCuts& AliCFTrackQualityCuts::operator=(const AliCFTrackQualityCuts& c)
227{
228 //
229 // Assignment operator
230 //
231 if (this != &c) {
232 AliCFCutBase::operator=(c) ;
233 fMinNClusterTPC = c.fMinNClusterTPC ;
234 fMinNClusterITS = c.fMinNClusterITS ;
235 fMinNClusterTRD = c.fMinNClusterTRD ;
236 fMinFoundClusterTPC = c.fMinFoundClusterTPC ;
237 fMinNTrackletTRD = c.fMinNTrackletTRD ;
238 fMinNTrackletTRDpid = c.fMinNTrackletTRDpid ;
239 fMaxChi2PerClusterTPC = c.fMaxChi2PerClusterTPC ;
240 fMaxChi2PerClusterITS = c.fMaxChi2PerClusterITS ;
241 fMaxChi2PerTrackletTRD = c.fMaxChi2PerTrackletTRD ;
242 fCovariance11Max = c.fCovariance11Max ;
243 fCovariance22Max = c.fCovariance22Max ;
244 fCovariance33Max = c.fCovariance33Max ;
245 fCovariance44Max = c.fCovariance44Max ;
246 fCovariance55Max = c.fCovariance55Max ;
247 fStatus = c.fStatus ;
248 fhCutStatistics = c.fhCutStatistics ;
249 fhCutCorrelation = c.fhCutCorrelation ;
250 fBitmap = c.fBitmap ;
251 fhNBinsClusterTPC = c.fhNBinsClusterTPC ;
252 fhNBinsClusterITS = c.fhNBinsClusterITS ;
253 fhNBinsClusterTRD = c.fhNBinsClusterTRD ;
254 fhNBinsFoundClusterTPC = c.fhNBinsFoundClusterTPC ;
255 fhNBinsTrackletTRD = c.fhNBinsTrackletTRD ;
256 fhNBinsTrackletTRDpid = c.fhNBinsTrackletTRDpid ;
257 fhNBinsChi2TPC = c.fhNBinsChi2TPC ;
258 fhNBinsChi2ITS = c.fhNBinsChi2ITS ;
259 fhNBinsChi2TRD = c.fhNBinsChi2TRD ;
260 fhNBinsCovariance11 = c.fhNBinsCovariance11 ;
261 fhNBinsCovariance22 = c.fhNBinsCovariance22 ;
262 fhNBinsCovariance33 = c.fhNBinsCovariance33 ;
263 fhNBinsCovariance44 = c.fhNBinsCovariance44 ;
264 fhNBinsCovariance55 = c.fhNBinsCovariance55 ;
265 fhBinLimClusterTPC = c.fhBinLimClusterTPC ;
266 fhBinLimClusterITS = c.fhBinLimClusterITS ;
267 fhBinLimClusterTRD = c.fhBinLimClusterTRD ;
268 fhBinLimFoundClusterTPC = c.fhBinLimFoundClusterTPC ;
269 fhBinLimTrackletTRD = c.fhBinLimTrackletTRD ;
270 fhBinLimTrackletTRDpid = c.fhBinLimTrackletTRDpid ;
271 fhBinLimChi2TPC = c.fhBinLimChi2TPC ;
272 fhBinLimChi2ITS = c.fhBinLimChi2ITS ;
273 fhBinLimChi2TRD = c.fhBinLimChi2TRD ;
274 fhBinLimCovariance11 = c.fhBinLimCovariance11 ;
275 fhBinLimCovariance22 = c.fhBinLimCovariance22 ;
276 fhBinLimCovariance33 = c.fhBinLimCovariance33 ;
277 fhBinLimCovariance44 = c.fhBinLimCovariance44 ;
278 fhBinLimCovariance55 = c.fhBinLimCovariance55 ;
279
280 for (Int_t i=0; i<c.kNHist; i++){
281 for (Int_t j=0; j<c.kNStepQA; j++){
282 if(c.fhQA[i][j]) fhQA[i][j] = (TH1F*)c.fhQA[i][j]->Clone();
283 }
284 }
285 ((AliCFTrackQualityCuts &) c).Copy(*this);
286 }
287 return *this;
288}
289//__________________________________________________________________________________
290AliCFTrackQualityCuts::~AliCFTrackQualityCuts()
291{
292 //
293 // destructor
294 //
295 if (fhCutStatistics) delete fhCutStatistics;
296 if (fhCutCorrelation) delete fhCutCorrelation;
297
298 for (Int_t i=0; i<kNHist; i++){
299 for (Int_t j=0; j<kNStepQA; j++){
300 if(fhQA[i][j]) delete fhQA[i][j];
301 }
302 }
303 if(fBitmap) delete fBitmap;
304 if(fhBinLimClusterTPC) delete fhBinLimClusterTPC;
305 if(fhBinLimClusterITS) delete fhBinLimClusterITS;
306 if(fhBinLimClusterTRD) delete fhBinLimClusterTRD;
307 if(fhBinLimFoundClusterTPC) delete fhBinLimFoundClusterTPC;
308 if(fhBinLimTrackletTRD) delete fhBinLimTrackletTRD;
309 if(fhBinLimTrackletTRDpid) delete fhBinLimTrackletTRDpid;
310 if(fhBinLimChi2TPC) delete fhBinLimChi2TPC;
311 if(fhBinLimChi2ITS) delete fhBinLimChi2ITS;
312 if(fhBinLimChi2TRD) delete fhBinLimChi2TRD;
313 if(fhBinLimCovariance11) delete fhBinLimCovariance11;
314 if(fhBinLimCovariance22) delete fhBinLimCovariance22;
315 if(fhBinLimCovariance33) delete fhBinLimCovariance33;
316 if(fhBinLimCovariance44) delete fhBinLimCovariance44;
317 if(fhBinLimCovariance55) delete fhBinLimCovariance55;
318}
319//__________________________________________________________________________________
320void AliCFTrackQualityCuts::Initialise()
321{
322 //
323 // sets everything to zero
324 //
325 fMinNClusterTPC = 0;
326 fMinNClusterITS = 0;
327 fMinNClusterTRD = 0;
328 fMinFoundClusterTPC = 0;
329 fMinNTrackletTRD = 0;
330 fMinNTrackletTRDpid = 0;
331 fMaxChi2PerClusterTPC = 0;
332 fMaxChi2PerClusterITS = 0;
333 fMaxChi2PerTrackletTRD = 0;
334 fCovariance11Max = 0;
335 fCovariance22Max = 0;
336 fCovariance33Max = 0;
337 fCovariance44Max = 0;
338 fCovariance55Max = 0;
339 fStatus = 0;
340
341 SetMinNClusterTPC();
342 SetMinNClusterITS();
343 SetMinNClusterTRD();
344 SetMinFoundClusterTPC();
345 SetMinNTrackletTRD();
346 SetMinNTrackletTRDpid();
347 SetMaxChi2PerClusterTPC();
348 SetMaxChi2PerClusterITS();
349 SetMaxChi2PerTrackletTRD();
350 SetMaxCovDiagonalElements();
351 SetStatus();
352
353 for (Int_t i=0; i<kNHist; i++){
354 for (Int_t j=0; j<kNStepQA; j++)
355 fhQA[i][j] = 0x0;
356 }
357 fhCutStatistics = 0;
358 fhCutCorrelation = 0;
359 fBitmap=new TBits(0);
360
361 //set default bining for QA histograms
362 SetHistogramBins(kCutClusterTPC,165,-0.5,164.5);
363 SetHistogramBins(kCutClusterITS,8,-0.5,7.5);
364 SetHistogramBins(kCutClusterTRD,120,-0.5,119.5);
365 SetHistogramBins(kCutMinFoundClusterTPC,110,-0.05,1.05);
366 SetHistogramBins(kCutTrackletTRD,7,-0.5,6.5);
367 SetHistogramBins(kCutTrackletTRDpid,7,-0.5,6.5);
368 SetHistogramBins(kCutChi2TPC,500,0.,10.);
369 SetHistogramBins(kCutChi2ITS,500,0.,10.);
370 SetHistogramBins(kCutChi2TRD,500,0.,10.);
371 SetHistogramBins(kCutCovElement11,200,0.,20.);
372 SetHistogramBins(kCutCovElement22,200,0.,20.);
373 SetHistogramBins(kCutCovElement33,100,0.,1.);
374 SetHistogramBins(kCutCovElement44,100,0.,5.);
375 SetHistogramBins(kCutCovElement55,100,0.,5.);
376}
377//__________________________________________________________________________________
378void AliCFTrackQualityCuts::Copy(TObject &c) const
379{
380 //
381 // Copy function
382 //
383 AliCFTrackQualityCuts& target = (AliCFTrackQualityCuts &) c;
384
385 target.Initialise();
386
387 if (fhCutStatistics) target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
388 if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
389
390 for (Int_t i=0; i<kNHist; i++){
391 for (Int_t j=0; j<kNStepQA; j++){
392 if(fhQA[i][j]) target.fhQA[i][j] = (TH1F*)fhQA[i][j]->Clone();
393 }
394 }
395 TNamed::Copy(c);
396}
397//__________________________________________________________________________________
398void AliCFTrackQualityCuts::SelectionBitMap(TObject* obj)
399{
400 //
401 // test if the track passes the single cuts
402 // and store the information in a bitmap
403 //
404
405 // bitmap stores the decision of each single cut
406 for(Int_t i=0; i<kNCuts; i++)fBitmap->SetBitNumber(i,kFALSE);
407
408 if (!obj) return;
409 if (!obj->InheritsFrom("AliVParticle")) {
410 AliError("object must derived from AliVParticle !");
411 return;
412 }
413
414 Bool_t isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
415 Bool_t isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
416
417 AliESDtrack * esdTrack = 0x0 ;
418 AliAODTrack * aodTrack = 0x0 ;
419 if (isESDTrack) esdTrack = dynamic_cast<AliESDtrack*>(obj);
420 if (isAODTrack) aodTrack = dynamic_cast<AliAODTrack*>(obj);
421
422 // get cut quantities
423 Int_t nClustersTPC = 0;
424 Int_t nClustersITS = 0 ;
425 Int_t nClustersTRD = 0 ;
426 Int_t nTrackletsTRD = 0 ;
427 Float_t chi2PerClusterTPC = 0 ;
428 Float_t chi2PerClusterITS = 0 ;
429 Float_t chi2PerTrackletTRD = 0 ;
430 Double_t extCov[15]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
431 Float_t fractionFoundClustersTPC = 0;
432
433 if (isESDTrack) {
434 nClustersTPC = esdTrack->GetTPCclusters(0x0);
435 nClustersITS = esdTrack->GetITSclusters(0x0);
436 nClustersTRD = esdTrack->GetTRDncls();
437 nTrackletsTRD = esdTrack->GetTRDntracklets();
438 if (nClustersTPC != 0) chi2PerClusterTPC = esdTrack->GetTPCchi2() / Float_t(nClustersTPC);
439 if (nClustersITS != 0) chi2PerClusterITS = esdTrack->GetITSchi2() / Float_t(nClustersITS);
440 if (nTrackletsTRD != 0) chi2PerTrackletTRD = esdTrack->GetTRDchi2() / Float_t(nTrackletsTRD);
441 esdTrack->GetExternalCovariance(extCov);
442 if (esdTrack->GetTPCNclsF() != 0) fractionFoundClustersTPC = float(nClustersTPC) / float(esdTrack->GetTPCNclsF());
443 }
444
445 // fill the bitmap
446 Int_t iCutBit = 0;
447
448 if (nClustersTPC >= fMinNClusterTPC)
449 fBitmap->SetBitNumber(iCutBit,kTRUE);
450 iCutBit++;
451 if (nClustersITS >= fMinNClusterITS)
452 fBitmap->SetBitNumber(iCutBit,kTRUE);
453 iCutBit++;
454 if (nClustersTRD >= fMinNClusterTRD)
455 fBitmap->SetBitNumber(iCutBit,kTRUE);
456 iCutBit++;
457 if ((fMinFoundClusterTPC <= 0) || (nClustersTPC > 0 && (fractionFoundClustersTPC >= fMinFoundClusterTPC)))
458 fBitmap->SetBitNumber(iCutBit,kTRUE);
459 iCutBit++;
460 if (nTrackletsTRD >= fMinNTrackletTRD)
461 fBitmap->SetBitNumber(iCutBit,kTRUE);
462 iCutBit++;
463 if (esdTrack->GetTRDntrackletsPID() >= fMinNTrackletTRDpid)
464 fBitmap->SetBitNumber(iCutBit,kTRUE);
465 iCutBit++;
466 if (chi2PerClusterTPC <= fMaxChi2PerClusterTPC)
467 fBitmap->SetBitNumber(iCutBit,kTRUE);
468 iCutBit++;
469 if (chi2PerClusterITS <= fMaxChi2PerClusterITS)
470 fBitmap->SetBitNumber(iCutBit,kTRUE);
471 iCutBit++;
472 if (chi2PerTrackletTRD <= fMaxChi2PerTrackletTRD)
473 fBitmap->SetBitNumber(iCutBit,kTRUE);
474 iCutBit++;
475 if (extCov[0] <= fCovariance11Max)
476 fBitmap->SetBitNumber(iCutBit,kTRUE);
477 iCutBit++;
478 if (extCov[2] <= fCovariance22Max)
479 fBitmap->SetBitNumber(iCutBit,kTRUE);
480 iCutBit++;
481 if (extCov[5] <= fCovariance33Max)
482 fBitmap->SetBitNumber(iCutBit,kTRUE);
483 iCutBit++;
484 if (extCov[9] <= fCovariance44Max)
485 fBitmap->SetBitNumber(iCutBit,kTRUE);
486 iCutBit++;
487 if (extCov[14] <= fCovariance55Max)
488 fBitmap->SetBitNumber(iCutBit,kTRUE);
489 iCutBit++;
490
491 if (isESDTrack) {
492 if ( (esdTrack->GetStatus() & fStatus) == fStatus ) fBitmap->SetBitNumber(iCutBit,kTRUE);
493 }
494 else {
495 if ( (aodTrack->GetStatus() & fStatus) == fStatus ) fBitmap->SetBitNumber(iCutBit,kTRUE);
496 }
497
498 return;
499}
500//__________________________________________________________________________________
501Bool_t AliCFTrackQualityCuts::IsSelected(TObject* obj) {
502 //
503 // loops over decisions of single cuts and returns if the track is accepted
504 //
505 SelectionBitMap(obj);
506
507 if (fIsQAOn) FillHistograms(obj,0);
508 Bool_t isSelected = kTRUE;
509
510 for (UInt_t icut=0; icut<fBitmap->GetNbits();icut++) {
511 if(!fBitmap->TestBitNumber(icut)) {
512 isSelected = kFALSE;
513 break;
514 }
515 }
516 if (!isSelected) return kFALSE ;
517 if (fIsQAOn) FillHistograms(obj,1);
518 return kTRUE;
519}
520//__________________________________________________________________________________
521void AliCFTrackQualityCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t *bins)
522{
523 //
524 // variable bin size
525 //
526 if(!fIsQAOn) return;
527
528 if (index<0 || index>=kNHist) {
529 Error("SetHistogramBins","could not determine histogram from index %d",index);
530 return;
531 }
532
533 switch(index){
534 case kCutClusterTPC:
535 fhNBinsClusterTPC=nbins+1;
536 fhBinLimClusterTPC=new Double_t[nbins+1];
537 for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterTPC[i]=bins[i];
538 break;
539
540 case kCutClusterITS:
541 fhNBinsClusterITS=nbins+1;
542 fhBinLimClusterITS=new Double_t[nbins+1];
543 for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterITS[i]=bins[i];
544 break;
545
546 case kCutClusterTRD:
547 fhNBinsClusterTRD=nbins+1;
548 fhBinLimClusterTRD=new Double_t[nbins+1];
549 for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterTRD[i]=bins[i];
550 break;
551
552 case kCutMinFoundClusterTPC:
553 fhNBinsFoundClusterTPC=nbins+1;
554 fhBinLimFoundClusterTPC=new Double_t[nbins+1];
555 for(Int_t i=0;i<nbins+1;i++)fhBinLimFoundClusterTPC[i]=bins[i];
556 break;
557
558 case kCutTrackletTRD:
559 fhNBinsTrackletTRD=nbins+1;
560 fhBinLimTrackletTRD=new Double_t[nbins+1];
561 for(Int_t i=0;i<nbins+1;i++)fhBinLimTrackletTRD[i]=bins[i];
562 break;
563
564 case kCutTrackletTRDpid:
565 fhNBinsTrackletTRDpid=nbins+1;
566 fhBinLimTrackletTRDpid=new Double_t[nbins+1];
567 for(Int_t i=0;i<nbins+1;i++)fhBinLimTrackletTRDpid[i]=bins[i];
568 break;
569
570 case kCutChi2TPC:
571 fhNBinsChi2TPC=nbins+1;
572 fhBinLimChi2TPC=new Double_t[nbins+1];
573 for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2TPC[i]=bins[i];
574 break;
575
576 case kCutChi2ITS:
577 fhNBinsChi2ITS=nbins+1;
578 fhBinLimChi2ITS=new Double_t[nbins+1];
579 for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2ITS[i]=bins[i];
580 break;
581
582 case kCutChi2TRD:
583 fhNBinsChi2TRD=nbins+1;
584 fhBinLimChi2TRD=new Double_t[nbins+1];
585 for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2TRD[i]=bins[i];
586 break;
587
588 case kCutCovElement11:
589 fhNBinsCovariance11=nbins+1;
590 fhBinLimCovariance11=new Double_t[nbins+1];
591 for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance11[i]=bins[i];
592 break;
593
594 case kCutCovElement22:
595 fhNBinsCovariance22=nbins+1;
596 fhBinLimCovariance22=new Double_t[nbins+1];
597 for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance22[i]=bins[i];
598 break;
599
600 case kCutCovElement33:
601 fhNBinsCovariance33=nbins+1;
602 fhBinLimCovariance33=new Double_t[nbins+1];
603 for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance33[i]=bins[i];
604 break;
605
606 case kCutCovElement44:
607 fhNBinsCovariance44=nbins+1;
608 fhBinLimCovariance44=new Double_t[nbins+1];
609 for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance44[i]=bins[i];
610 break;
611
612 case kCutCovElement55:
613 fhNBinsCovariance55=nbins+1;
614 fhBinLimCovariance55=new Double_t[nbins+1];
615 for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance55[i]=bins[i];
616 break;
617 }
618}
619//__________________________________________________________________________________
620void AliCFTrackQualityCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t xmin, Double_t xmax)
621{
622 //
623 // fixed bin size
624 //
625 if (index<0 || index>=kNHist) {
626 Error("SetHistogramBins","could not determine histogram from index %d",index);
627 return;
628 }
629
630 switch(index){
631 case kCutClusterTPC:
632 fhNBinsClusterTPC=nbins+1;
633 fhBinLimClusterTPC=new Double_t[nbins+1];
634 for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterTPC[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
635 break;
636
637 case kCutClusterITS:
638 fhNBinsClusterITS=nbins+1;
639 fhBinLimClusterITS=new Double_t[nbins+1];
640 for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterITS[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
641 break;
642
643 case kCutClusterTRD:
644 fhNBinsClusterTRD=nbins+1;
645 fhBinLimClusterTRD=new Double_t[nbins+1];
646 for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterTRD[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
647 break;
648
649 case kCutMinFoundClusterTPC:
650 fhNBinsFoundClusterTPC=nbins+1;
651 fhBinLimFoundClusterTPC=new Double_t[nbins+1];
652 for(Int_t i=0;i<nbins+1;i++)fhBinLimFoundClusterTPC[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
653 break;
654
655 case kCutTrackletTRD:
656 fhNBinsTrackletTRD=nbins+1;
657 fhBinLimTrackletTRD=new Double_t[nbins+1];
658 for(Int_t i=0;i<nbins+1;i++)fhBinLimTrackletTRD[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
659 break;
660
661 case kCutTrackletTRDpid:
662 fhNBinsTrackletTRDpid=nbins+1;
663 fhBinLimTrackletTRDpid=new Double_t[nbins+1];
664 for(Int_t i=0;i<nbins+1;i++)fhBinLimTrackletTRDpid[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
665 break;
666
667 case kCutChi2TPC:
668 fhNBinsChi2TPC=nbins+1;
669 fhBinLimChi2TPC=new Double_t[nbins+1];
670 for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2TPC[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
671 break;
672
673 case kCutChi2ITS:
674 fhNBinsChi2ITS=nbins+1;
675 fhBinLimChi2ITS=new Double_t[nbins+1];
676 for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2ITS[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
677 break;
678
679 case kCutChi2TRD:
680 fhNBinsChi2TRD=nbins+1;
681 fhBinLimChi2TRD=new Double_t[nbins+1];
682 for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2TRD[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
683 break;
684
685 case kCutCovElement11:
686 fhNBinsCovariance11=nbins+1;
687 fhBinLimCovariance11=new Double_t[nbins+1];
688 for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance11[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
689 break;
690
691 case kCutCovElement22:
692 fhNBinsCovariance22=nbins+1;
693 fhBinLimCovariance22=new Double_t[nbins+1];
694 for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance22[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
695 break;
696
697 case kCutCovElement33:
698 fhNBinsCovariance33=nbins+1;
699 fhBinLimCovariance33=new Double_t[nbins+1];
700 for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance33[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
701 break;
702
703 case kCutCovElement44:
704 fhNBinsCovariance44=nbins+1;
705 fhBinLimCovariance44=new Double_t[nbins+1];
706 for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance44[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
707 break;
708
709 case kCutCovElement55:
710 fhNBinsCovariance55=nbins+1;
711 fhBinLimCovariance55=new Double_t[nbins+1];
712 for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance55[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
713 break;
714 }
715}
716//__________________________________________________________________________________
717 void AliCFTrackQualityCuts::DefineHistograms() {
718 //
719 // histograms for cut variables, cut statistics and cut correlations
720 //
721 Int_t color = 2;
722
723 // book cut statistics and cut correlation histograms
724 fhCutStatistics = new TH1F(Form("%s_cut_statistics",GetName()), Form("%s cut statistics",GetName()), kNCuts,0.5,kNCuts+0.5);
725 fhCutStatistics->SetLineWidth(2);
726 fhCutStatistics->GetXaxis()->SetBinLabel(1, "nClustersTPC");
727 fhCutStatistics->GetXaxis()->SetBinLabel(2, "nClustersITS");
728 fhCutStatistics->GetXaxis()->SetBinLabel(3, "nClustersTRD");
729 fhCutStatistics->GetXaxis()->SetBinLabel(4, "fractionClustersTPC");
730 fhCutStatistics->GetXaxis()->SetBinLabel(5, "ntrackletsTRD");
731 fhCutStatistics->GetXaxis()->SetBinLabel(6, "ntrackletsTRDpid");
732 fhCutStatistics->GetXaxis()->SetBinLabel(7, "chi2PerClusterTPC");
733 fhCutStatistics->GetXaxis()->SetBinLabel(8, "chi2PerClusterITS");
734 fhCutStatistics->GetXaxis()->SetBinLabel(9, "chi2PerTrackletTRD");
735 fhCutStatistics->GetXaxis()->SetBinLabel(10, "covElement11");
736 fhCutStatistics->GetXaxis()->SetBinLabel(11, "covElement22");
737 fhCutStatistics->GetXaxis()->SetBinLabel(12, "covElement33");
738 fhCutStatistics->GetXaxis()->SetBinLabel(13, "covElement44");
739 fhCutStatistics->GetXaxis()->SetBinLabel(14, "covElement55");
740 fhCutStatistics->GetXaxis()->SetBinLabel(15, "status");
741
742 fhCutCorrelation = new TH2F(Form("%s_cut_correlation",GetName()), Form("%s cut correlation",GetName()), kNCuts,0.5,kNCuts+0.5,kNCuts,0.5,kNCuts+0.5);
743 fhCutCorrelation->SetLineWidth(2);
744 fhCutCorrelation->GetXaxis()->SetBinLabel(1, "nClustersTPC");
745 fhCutCorrelation->GetXaxis()->SetBinLabel(2, "nClustersITS");
746 fhCutCorrelation->GetXaxis()->SetBinLabel(3, "nClustersTRD");
747 fhCutCorrelation->GetXaxis()->SetBinLabel(4, "fractionClustersTPC");
748 fhCutCorrelation->GetXaxis()->SetBinLabel(5, "ntrackletsTRD");
749 fhCutCorrelation->GetXaxis()->SetBinLabel(6, "ntrackletsTRDpid");
750 fhCutCorrelation->GetXaxis()->SetBinLabel(7, "chi2PerClusterTPC");
751 fhCutCorrelation->GetXaxis()->SetBinLabel(8, "chi2PerClusterITS");
752 fhCutCorrelation->GetXaxis()->SetBinLabel(9, "chi2PerTrackletTRD");
753 fhCutCorrelation->GetXaxis()->SetBinLabel(10, "covElement11");
754 fhCutCorrelation->GetXaxis()->SetBinLabel(11, "covElement22");
755 fhCutCorrelation->GetXaxis()->SetBinLabel(12, "covElement33");
756 fhCutCorrelation->GetXaxis()->SetBinLabel(13, "covElement44");
757 fhCutCorrelation->GetXaxis()->SetBinLabel(14, "covElement55");
758 fhCutStatistics->GetXaxis()->SetBinLabel(15, "status");
759
760 fhCutCorrelation->GetYaxis()->SetBinLabel(1, "nClustersTPC");
761 fhCutCorrelation->GetYaxis()->SetBinLabel(2, "nClustersITS");
762 fhCutCorrelation->GetYaxis()->SetBinLabel(3, "nClustersTRD");
763 fhCutCorrelation->GetYaxis()->SetBinLabel(4, "fractionClustersTPC");
764 fhCutCorrelation->GetYaxis()->SetBinLabel(5, "ntrackletsTRD");
765 fhCutCorrelation->GetYaxis()->SetBinLabel(6, "ntrackletsTRDpid");
766 fhCutCorrelation->GetYaxis()->SetBinLabel(7, "chi2PerClusterTPC");
767 fhCutCorrelation->GetYaxis()->SetBinLabel(8, "chi2PerClusterITS");
768 fhCutCorrelation->GetYaxis()->SetBinLabel(9, "chi2PerTrackletTRD");
769 fhCutCorrelation->GetYaxis()->SetBinLabel(10, "covElement11");
770 fhCutCorrelation->GetYaxis()->SetBinLabel(11, "covElement22");
771 fhCutCorrelation->GetYaxis()->SetBinLabel(12, "covElement33");
772 fhCutCorrelation->GetYaxis()->SetBinLabel(13, "covElement44");
773 fhCutCorrelation->GetYaxis()->SetBinLabel(14, "covElement55");
774 fhCutCorrelation->GetYaxis()->SetBinLabel(15, "status");
775
776
777 // book QA histograms
778 Char_t str[256];
779 for (Int_t i=0; i<kNStepQA; i++) {
780 if (i==0) sprintf(str," ");
781 else sprintf(str,"_cut");
782
783 fhQA[kCutClusterTPC][i] = new TH1F(Form("%s_nClustersTPC%s",GetName(),str) ,"",fhNBinsClusterTPC-1,fhBinLimClusterTPC);
784 fhQA[kCutClusterITS][i] = new TH1F(Form("%s_nClustersITS%s",GetName(),str) ,"",fhNBinsClusterITS-1,fhBinLimClusterITS);
785 fhQA[kCutClusterTRD][i] = new TH1F(Form("%s_nClustersTRD%s",GetName(),str) ,"",fhNBinsClusterTRD-1,fhBinLimClusterTRD);
786 fhQA[kCutMinFoundClusterTPC][i] = new TH1F(Form("%s_fractionClustersTPC%s",GetName(),str) ,"",fhNBinsFoundClusterTPC-1,fhBinLimFoundClusterTPC);
787 fhQA[kCutTrackletTRD][i] = new TH1F(Form("%s_ntrackletsTRD%s",GetName(),str) ,"",fhNBinsTrackletTRD-1,fhBinLimTrackletTRD);
788 fhQA[kCutTrackletTRDpid][i] = new TH1F(Form("%s_ntrackletsTRDpid%s",GetName(),str) ,"",fhNBinsTrackletTRDpid-1,fhBinLimTrackletTRDpid);
789 fhQA[kCutChi2TPC][i] = new TH1F(Form("%s_chi2PerClusterTPC%s",GetName(),str),"",fhNBinsChi2TPC-1,fhBinLimChi2TPC);
790 fhQA[kCutChi2ITS][i] = new TH1F(Form("%s_chi2PerClusterITS%s",GetName(),str),"",fhNBinsChi2ITS-1,fhBinLimChi2ITS);
791 fhQA[kCutChi2TRD][i] = new TH1F(Form("%s_chi2PerTrackletTRD%s",GetName(),str),"",fhNBinsChi2TRD-1,fhBinLimChi2TRD);
792 fhQA[kCutCovElement11][i] = new TH1F(Form("%s_covMatrixDiagonal11%s",GetName(),str),"",fhNBinsCovariance11-1,fhBinLimCovariance11);
793 fhQA[kCutCovElement22][i] = new TH1F(Form("%s_covMatrixDiagonal22%s",GetName(),str),"",fhNBinsCovariance22-1,fhBinLimCovariance22);
794 fhQA[kCutCovElement33][i] = new TH1F(Form("%s_covMatrixDiagonal33%s",GetName(),str),"",fhNBinsCovariance33-1,fhBinLimCovariance33);
795 fhQA[kCutCovElement44][i] = new TH1F(Form("%s_covMatrixDiagonal44%s",GetName(),str),"",fhNBinsCovariance44-1,fhBinLimCovariance44);
796 fhQA[kCutCovElement55][i] = new TH1F(Form("%s_covMatrixDiagonal55%s",GetName(),str),"",fhNBinsCovariance55-1,fhBinLimCovariance55);
797
798 fhQA[kCutClusterTPC][i] ->SetXTitle("n TPC clusters");
799 fhQA[kCutClusterITS][i] ->SetXTitle("n ITS clusters");
800 fhQA[kCutClusterTRD][i] ->SetXTitle("n TRD clusters");
801 fhQA[kCutMinFoundClusterTPC][i]->SetXTitle("fraction TPC clusters");
802 fhQA[kCutTrackletTRD][i] ->SetXTitle("n tracklets TRD");
803 fhQA[kCutTrackletTRDpid][i]->SetXTitle("n tracklets TRD pid");
804 fhQA[kCutChi2TPC][i] ->SetXTitle("#chi^{2} per TPC cluster");
805 fhQA[kCutChi2ITS][i] ->SetXTitle("#chi^{2} per ITS cluster");
806 fhQA[kCutChi2TRD][i] ->SetXTitle("#chi^{2} per TRD tracklet");
807 fhQA[kCutCovElement11][i] ->SetXTitle("cov 11 : #sigma_{y}^{2} (cm^{2})");
808 fhQA[kCutCovElement22][i] ->SetXTitle("cov 22 : #sigma_{z}^{2} (cm^{2})");
809 fhQA[kCutCovElement33][i] ->SetXTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
810 fhQA[kCutCovElement44][i] ->SetXTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
811 fhQA[kCutCovElement55][i] ->SetXTitle("cov 55 : #sigma_{1/p_{T}}^{2} ((c/GeV)^{2})");
812 }
813
814 for(Int_t i=0; i<kNHist; i++) fhQA[i][1]->SetLineColor(color);
815}
816//__________________________________________________________________________________
817void AliCFTrackQualityCuts::FillHistograms(TObject* obj, Bool_t b)
818{
819 //
820 // fill the QA histograms
821 //
822
823 if (!obj) return;
824 if (!obj->InheritsFrom("AliVParticle")) {
825 AliError("object must derived from AliVParticle !");
826 return;
827 }
828
829 Bool_t isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
830 Bool_t isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
831
832 AliESDtrack * esdTrack = 0x0 ;
833 AliAODTrack * aodTrack = 0x0 ;
834 if (isESDTrack) esdTrack = dynamic_cast<AliESDtrack*>(obj);
835 if (isAODTrack) aodTrack = dynamic_cast<AliAODTrack*>(obj);
836
837 // b = 0: fill histograms before cuts
838 // b = 1: fill histograms after cuts
839
840 Int_t nClustersTPC = 0;
841 Int_t nClustersITS = 0 ;
842 Int_t nClustersTRD = 0 ;
843 Int_t nTrackletsTRD = 0 ;
844 Float_t chi2PerClusterTPC = 0 ;
845 Float_t chi2PerClusterITS = 0 ;
846 Float_t chi2PerTrackletTRD = 0 ;
847 Double_t extCov[15]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
848 Float_t fractionFoundClustersTPC = 0;
849
850 if (isESDTrack) {
851 nClustersTPC = esdTrack->GetTPCclusters(0x0);
852 nClustersITS = esdTrack->GetITSclusters(0x0);
853 nClustersTRD = esdTrack->GetTRDncls();
854 nTrackletsTRD = esdTrack->GetTRDntracklets();
855 if (nClustersTPC != 0) chi2PerClusterTPC = esdTrack->GetTPCchi2() / Float_t(nClustersTPC);
856 if (nClustersITS != 0) chi2PerClusterITS = esdTrack->GetITSchi2() / Float_t(nClustersITS);
857 if (nTrackletsTRD != 0) chi2PerTrackletTRD = esdTrack->GetTRDchi2() / Float_t(nTrackletsTRD);
858 esdTrack->GetExternalCovariance(extCov);
859 if (esdTrack->GetTPCNclsF() != 0) fractionFoundClustersTPC = float(nClustersTPC) / float(esdTrack->GetTPCNclsF());
860 }
861 fhQA[kCutClusterTPC][b]->Fill((float)nClustersTPC);
862 fhQA[kCutChi2TPC][b]->Fill(chi2PerClusterTPC);
863 fhQA[kCutClusterITS][b]->Fill((float)nClustersITS);
864 fhQA[kCutChi2ITS][b]->Fill(chi2PerClusterITS);
865 fhQA[kCutClusterTRD][b]->Fill((float)nClustersTRD);
866 fhQA[kCutChi2TRD][b]->Fill(chi2PerTrackletTRD);
867 if (b==0 || (b==1 && nClustersTPC>0)) fhQA[kCutMinFoundClusterTPC][b]->Fill((float)fractionFoundClustersTPC);
868 fhQA[kCutTrackletTRD][b]->Fill((float)nTrackletsTRD);
869 fhQA[kCutTrackletTRDpid][b]->Fill((float)esdTrack->GetTRDntrackletsPID());
870 fhQA[kCutCovElement11][b]->Fill(extCov[0]);
871 fhQA[kCutCovElement22][b]->Fill(extCov[2]);
872 fhQA[kCutCovElement33][b]->Fill(extCov[5]);
873 fhQA[kCutCovElement44][b]->Fill(extCov[9]);
874 fhQA[kCutCovElement55][b]->Fill(extCov[14]);
875
876 // fill cut statistics and cut correlation histograms with information from the bitmap
877 if (b) return;
878
879 // Get the bitmap of the single cuts
880 if ( !obj ) return;
881 SelectionBitMap(obj);
882
883 // Number of single cuts in this class
884 UInt_t ncuts = fBitmap->GetNbits();
885 for(UInt_t bit=0; bit<ncuts;bit++) {
886 if (!fBitmap->TestBitNumber(bit)) {
887 fhCutStatistics->Fill(bit+1);
888 for (UInt_t bit2=bit; bit2<ncuts;bit2++) {
889 if (!fBitmap->TestBitNumber(bit2))
890 fhCutCorrelation->Fill(bit+1,bit2+1);
891 }
892 }
893 }
894}
895//__________________________________________________________________________________
896void AliCFTrackQualityCuts::SaveHistograms(const Char_t* dir) {
897 //
898 // saves the histograms in a directory (dir)
899 //
900 if(!fIsQAOn) return;
901
902 if (!dir)
903 dir = GetName();
904
905 gDirectory->mkdir(dir);
906 gDirectory->cd(dir);
907
908 gDirectory->mkdir("before_cuts");
909 gDirectory->mkdir("after_cuts");
910
911 fhCutStatistics->Write();
912 fhCutCorrelation->Write();
913
914 for (Int_t j=0; j<kNStepQA; j++) {
915 if (j==0)
916 gDirectory->cd("before_cuts");
917 else
918 gDirectory->cd("after_cuts");
919
920 for(Int_t i=0; i<kNHist; i++) fhQA[i][j]->Write();
921
922 gDirectory->cd("../");
923 }
924 gDirectory->cd("../");
925}
926//__________________________________________________________________________________
927void AliCFTrackQualityCuts::DrawHistograms(Bool_t drawLogScale)
928{
929 //
930 // draws some histograms
931 //
932 if(!fIsQAOn) return;
933
934 // pad margins
935 Float_t right = 0.03;
936 Float_t left = 0.175;
937 Float_t top = 0.03;
938 Float_t bottom = 0.175;
939
940 TCanvas* canvas1 = new TCanvas("Track_QA_Quality_1", "Track QA Quality 1", 800, 500);
941 canvas1->Divide(2, 1);
942
943 canvas1->cd(1);
944 fhCutStatistics->SetStats(kFALSE);
945 fhCutStatistics->LabelsOption("v");
946 gPad->SetLeftMargin(left);
947 gPad->SetBottomMargin(0.25);
948 gPad->SetRightMargin(right);
949 gPad->SetTopMargin(0.1);
950 fhCutStatistics->Draw();
951
952 canvas1->cd(2);
953 fhCutCorrelation->SetStats(kFALSE);
954 fhCutCorrelation->LabelsOption("v");
955 gPad->SetLeftMargin(0.30);
956 gPad->SetRightMargin(bottom);
957 gPad->SetTopMargin(0.1);
958 gPad->SetBottomMargin(0.25);
959 fhCutCorrelation->Draw("COLZ");
960
961 canvas1->SaveAs(Form("%s.eps", canvas1->GetName()));
962 canvas1->SaveAs(Form("%s.ps", canvas1->GetName()));
963
964 // -----
965
966 TCanvas* canvas2 = new TCanvas("Track_QA_Quality_2", "Track QA Quality 2", 1200, 800);
967 canvas2->Divide(2, 2);
968
969 canvas2->cd(1);
970 gPad->SetRightMargin(right);
971 gPad->SetLeftMargin(left);
972 gPad->SetTopMargin(top);
973 gPad->SetBottomMargin(bottom);
974 fhQA[kCutClusterTPC][0]->SetStats(kFALSE);
975 fhQA[kCutClusterTPC][0]->Draw();
976 fhQA[kCutClusterTPC][1]->Draw("same");
977
978 canvas2->cd(2);
979 gPad->SetRightMargin(right);
980 gPad->SetLeftMargin(left);
981 gPad->SetTopMargin(top);
982 gPad->SetBottomMargin(bottom);
983 fhQA[kCutChi2TPC][0]->SetStats(kFALSE);
984 fhQA[kCutChi2TPC][0]->Draw();
985 fhQA[kCutChi2TPC][1]->Draw("same");
986
987 canvas2->cd(3);
988 gPad->SetRightMargin(right);
989 gPad->SetLeftMargin(left);
990 gPad->SetTopMargin(top);
991 gPad->SetBottomMargin(bottom);
992 fhQA[kCutClusterITS][0]->SetStats(kFALSE);
993 fhQA[kCutClusterITS][0]->Draw();
994 fhQA[kCutClusterITS][1]->Draw("same");
995
996 canvas2->cd(4);
997 gPad->SetRightMargin(right);
998 gPad->SetLeftMargin(left);
999 gPad->SetTopMargin(top);
1000 gPad->SetBottomMargin(bottom);
1001 fhQA[kCutChi2ITS][0]->SetStats(kFALSE);
1002 fhQA[kCutChi2ITS][0]->Draw();
1003 fhQA[kCutChi2ITS][1]->Draw("same");
1004
1005 canvas2->SaveAs(Form("%s.eps", canvas2->GetName()));
1006 canvas2->SaveAs(Form("%s.ps", canvas2->GetName()));
1007
1008 // -----
1009
1010 TCanvas* canvas3 = new TCanvas("Track_QA_Quality_3", "Track QA Quality 3", 1200, 800);
1011 canvas3->Divide(3, 2);
1012
1013 canvas3->cd(1);
1014 if(drawLogScale) gPad->SetLogy();
1015 gPad->SetRightMargin(right);
1016 gPad->SetLeftMargin(left);
1017 gPad->SetTopMargin(top);
1018 gPad->SetBottomMargin(bottom);
1019 fhQA[kCutCovElement11][0]->SetStats(kFALSE);
1020 fhQA[kCutCovElement11][0]->Draw();
1021 fhQA[kCutCovElement11][1]->Draw("same");
1022
1023 canvas3->cd(2);
1024 if(drawLogScale) gPad->SetLogy();
1025 gPad->SetRightMargin(right);
1026 gPad->SetLeftMargin(left);
1027 gPad->SetTopMargin(top);
1028 gPad->SetBottomMargin(bottom);
1029 fhQA[kCutCovElement22][0]->SetStats(kFALSE);
1030 fhQA[kCutCovElement22][0]->Draw();
1031 fhQA[kCutCovElement22][1]->Draw("same");
1032
1033 canvas3->cd(3);
1034 if(drawLogScale) gPad->SetLogy();
1035 gPad->SetRightMargin(right);
1036 gPad->SetLeftMargin(left);
1037 gPad->SetTopMargin(top);
1038 gPad->SetBottomMargin(bottom);
1039 fhQA[kCutCovElement33][0]->SetStats(kFALSE);
1040 fhQA[kCutCovElement33][0]->Draw();
1041 fhQA[kCutCovElement33][1]->Draw("same");
1042
1043 canvas3->cd(4);
1044 if(drawLogScale) gPad->SetLogy();
1045 gPad->SetRightMargin(right);
1046 gPad->SetLeftMargin(left);
1047 gPad->SetTopMargin(top);
1048 gPad->SetBottomMargin(bottom);
1049 fhQA[kCutCovElement44][0]->SetStats(kFALSE);
1050 fhQA[kCutCovElement44][0]->Draw();
1051 fhQA[kCutCovElement44][1]->Draw("same");
1052
1053 canvas3->cd(5);
1054 if(drawLogScale) gPad->SetLogy();
1055 gPad->SetRightMargin(right);
1056 gPad->SetLeftMargin(left);
1057 gPad->SetTopMargin(top);
1058 gPad->SetBottomMargin(bottom);
1059 fhQA[kCutCovElement55][0]->SetStats(kFALSE);
1060 fhQA[kCutCovElement55][0]->Draw();
1061 fhQA[kCutCovElement55][1]->Draw("same");
1062
1063 canvas3->SaveAs(Form("%s.eps", canvas3->GetName()));
1064 canvas3->SaveAs(Form("%s.ps", canvas3->GetName()));
1065}
1066//__________________________________________________________________________________
1067void AliCFTrackQualityCuts::AddQAHistograms(TList *qaList) {
1068 //
1069 // saves the histograms in a TList
1070 //
1071 DefineHistograms();
1072
1073 qaList->Add(fhCutStatistics);
1074 qaList->Add(fhCutCorrelation);
1075
1076 for (Int_t j=0; j<kNStepQA; j++) {
1077 for(Int_t i=0; i<kNHist; i++)
1078 qaList->Add(fhQA[i][j]);
1079 }
1080}