]> git.uio.no Git - u/mrichter/AliRoot.git/blame - CORRFW/AliCFTrackIsPrimaryCuts.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fixing ompilation warnings
[u/mrichter/AliRoot.git] / CORRFW / AliCFTrackIsPrimaryCuts.cxx
CommitLineData
563113d0 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 AliCFTrackIsPrimaryCut is designed to select reconstructed tracks
17// with a small impact parameter and tracks which are (not) daughters of kink
18// decays and to provide corresponding QA histograms.
19// This class inherits from the Analysis' Framework abstract base class
20// AliAnalysisCuts and is a part of the Correction Framework.
21// This class acts on single, reconstructed tracks, it is applicable on
22// ESD and AOD data.
23// It mainly consists of a IsSelected function that returns a boolean.
24// This function checks whether the considered track passes a set of cuts:
89d7d478 25// - min. and max. distance to main vertex in transverse plane (xy)
26// - min. and max. longitudinal distance to main vertex (z)
27// - min. and max. distance to main vertex as ellpise in xy - z plane
28// - all above cuts on absolute values or in units of sigma (resolution)
29// - min. and max. distance to main vertex in units of sigma (resolution)
30// - max. transverse (xy) and longitudinal (z) impact parameter resolution
563113d0 31// - require that the dca calculation doesn't fail
32// - accept or not accept daughter tracks of kink decays
33//
34// The cut values for these cuts are set with the corresponding set functions.
35// All cut classes provided by the correction framework are supposed to be
36// added in the Analysis Framwork's class AliAnalysisFilter and applied by
37// the filter via a loop.
38//
39// author: I. Kraus (Ingrid.Kraus@cern.ch)
40// idea taken form
41// AliESDtrackCuts writte by Jan Fiete Grosse-Oetringhaus and
42// AliRsnDaughterCut class written by A. Pulvirenti.
43
44#include <TCanvas.h>
45#include <TDirectory.h>
563113d0 46#include <TH2.h>
62037e79 47#include <TBits.h>
48
563113d0 49#include <AliESDtrack.h>
50#include <AliLog.h>
51#include "AliCFTrackIsPrimaryCuts.h"
52
53ClassImp(AliCFTrackIsPrimaryCuts)
54
55//__________________________________________________________________________________
56AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts() :
57 AliCFCutBase(),
89d7d478 58 fMinDCAToVertexXY(0),
59 fMinDCAToVertexZ(0),
60 fMaxDCAToVertexXY(0),
61 fMaxDCAToVertexZ(0),
62 fDCAToVertex2D(0),
63 fAbsDCAToVertex(0),
64 fNSigmaToVertexMin(0),
563113d0 65 fNSigmaToVertexMax(0),
89d7d478 66 fSigmaDCAxy(0),
67 fSigmaDCAz(0),
563113d0 68 fRequireSigmaToVertex(0),
8edd0c2c 69 fAODType(AliAODTrack::kUndef),
563113d0 70 fAcceptKinkDaughters(0),
71 fhCutStatistics(0),
72 fhCutCorrelation(0),
73 fBitmap(0x0),
74 fhNBinsNSigma(0),
75 fhNBinsRequireSigma(0),
76 fhNBinsAcceptKink(0),
77 fhNBinsDcaXY(0),
78 fhNBinsDcaZ(0),
79 fhNBinsDcaXYnorm(0),
80 fhNBinsDcaZnorm(0),
89d7d478 81 fhNBinsSigmaDcaXY(0),
82 fhNBinsSigmaDcaZ(0),
563113d0 83 fhBinLimNSigma(0x0),
84 fhBinLimRequireSigma(0x0),
85 fhBinLimAcceptKink(0x0),
86 fhBinLimDcaXY(0x0),
87 fhBinLimDcaZ(0x0),
88 fhBinLimDcaXYnorm(0x0),
89d7d478 89 fhBinLimDcaZnorm(0x0),
90 fhBinLimSigmaDcaXY(0x0),
91 fhBinLimSigmaDcaZ(0x0)
563113d0 92{
93 //
94 // Default constructor
95 //
563113d0 96 Initialise();
97}
98//__________________________________________________________________________________
99AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts(Char_t* name, Char_t* title) :
100 AliCFCutBase(name,title),
89d7d478 101 fMinDCAToVertexXY(0),
102 fMinDCAToVertexZ(0),
103 fMaxDCAToVertexXY(0),
104 fMaxDCAToVertexZ(0),
105 fDCAToVertex2D(0),
106 fAbsDCAToVertex(0),
107 fNSigmaToVertexMin(0),
563113d0 108 fNSigmaToVertexMax(0),
89d7d478 109 fSigmaDCAxy(0),
110 fSigmaDCAz(0),
563113d0 111 fRequireSigmaToVertex(0),
8edd0c2c 112 fAODType(AliAODTrack::kUndef),
563113d0 113 fAcceptKinkDaughters(0),
114 fhCutStatistics(0),
115 fhCutCorrelation(0),
116 fBitmap(0x0),
117 fhNBinsNSigma(0),
118 fhNBinsRequireSigma(0),
119 fhNBinsAcceptKink(0),
120 fhNBinsDcaXY(0),
121 fhNBinsDcaZ(0),
122 fhNBinsDcaXYnorm(0),
123 fhNBinsDcaZnorm(0),
89d7d478 124 fhNBinsSigmaDcaXY(0),
125 fhNBinsSigmaDcaZ(0),
563113d0 126 fhBinLimNSigma(0x0),
127 fhBinLimRequireSigma(0x0),
128 fhBinLimAcceptKink(0x0),
129 fhBinLimDcaXY(0x0),
130 fhBinLimDcaZ(0x0),
131 fhBinLimDcaXYnorm(0x0),
89d7d478 132 fhBinLimDcaZnorm(0x0),
133 fhBinLimSigmaDcaXY(0x0),
134 fhBinLimSigmaDcaZ(0x0)
563113d0 135{
136 //
137 // Constructor
138 //
563113d0 139 Initialise();
140}
141//__________________________________________________________________________________
142AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts(const AliCFTrackIsPrimaryCuts& c) :
143 AliCFCutBase(c),
89d7d478 144 fMinDCAToVertexXY(c.fMinDCAToVertexXY),
145 fMinDCAToVertexZ(c.fMinDCAToVertexZ),
146 fMaxDCAToVertexXY(c.fMaxDCAToVertexXY),
147 fMaxDCAToVertexZ(c.fMaxDCAToVertexZ),
148 fDCAToVertex2D(c.fDCAToVertex2D),
149 fAbsDCAToVertex(c.fAbsDCAToVertex),
150 fNSigmaToVertexMin(c.fNSigmaToVertexMin),
563113d0 151 fNSigmaToVertexMax(c.fNSigmaToVertexMax),
89d7d478 152 fSigmaDCAxy(c.fSigmaDCAxy),
153 fSigmaDCAz(c.fSigmaDCAz),
563113d0 154 fRequireSigmaToVertex(c.fRequireSigmaToVertex),
8edd0c2c 155 fAODType(c.fAODType),
563113d0 156 fAcceptKinkDaughters(c.fAcceptKinkDaughters),
157 fhCutStatistics(c.fhCutStatistics),
158 fhCutCorrelation(c.fhCutCorrelation),
159 fBitmap(c.fBitmap),
160 fhNBinsNSigma(c.fhNBinsNSigma),
161 fhNBinsRequireSigma(c.fhNBinsRequireSigma),
162 fhNBinsAcceptKink(c.fhNBinsAcceptKink),
163 fhNBinsDcaXY(c.fhNBinsDcaXY),
164 fhNBinsDcaZ(c.fhNBinsDcaZ),
165 fhNBinsDcaXYnorm(c.fhNBinsDcaXYnorm),
166 fhNBinsDcaZnorm(c.fhNBinsDcaZnorm),
89d7d478 167 fhNBinsSigmaDcaXY(c.fhNBinsSigmaDcaXY),
168 fhNBinsSigmaDcaZ(c.fhNBinsSigmaDcaZ),
563113d0 169 fhBinLimNSigma(c.fhBinLimNSigma),
170 fhBinLimRequireSigma(c.fhBinLimRequireSigma),
171 fhBinLimAcceptKink(c.fhBinLimAcceptKink),
172 fhBinLimDcaXY(c.fhBinLimDcaXY),
173 fhBinLimDcaZ(c.fhBinLimDcaZ),
174 fhBinLimDcaXYnorm(c.fhBinLimDcaXYnorm),
89d7d478 175 fhBinLimDcaZnorm(c.fhBinLimDcaZnorm),
176 fhBinLimSigmaDcaXY(c.fhBinLimSigmaDcaXY),
177 fhBinLimSigmaDcaZ(c.fhBinLimSigmaDcaZ)
563113d0 178{
179 //
180 // copy constructor
181 //
182 ((AliCFTrackIsPrimaryCuts &) c).Copy(*this);
183}
184//__________________________________________________________________________________
185AliCFTrackIsPrimaryCuts& AliCFTrackIsPrimaryCuts::operator=(const AliCFTrackIsPrimaryCuts& c)
186{
187 //
188 // Assignment operator
189 //
190 if (this != &c) {
191 AliCFCutBase::operator=(c) ;
89d7d478 192 fMinDCAToVertexXY = c.fMinDCAToVertexXY;
193 fMinDCAToVertexZ = c.fMinDCAToVertexZ;
194 fMaxDCAToVertexXY = c.fMaxDCAToVertexXY;
195 fMaxDCAToVertexZ = c.fMaxDCAToVertexZ;
196 fDCAToVertex2D = c.fDCAToVertex2D;
197 fAbsDCAToVertex = c.fAbsDCAToVertex;
198 fNSigmaToVertexMin = c.fNSigmaToVertexMin ;
563113d0 199 fNSigmaToVertexMax = c.fNSigmaToVertexMax ;
89d7d478 200 fSigmaDCAxy = c.fSigmaDCAxy ;
201 fSigmaDCAz = c.fSigmaDCAz ;
563113d0 202 fRequireSigmaToVertex = c.fRequireSigmaToVertex ;
8edd0c2c 203 fAODType = c.fAODType ;
563113d0 204 fAcceptKinkDaughters = c.fAcceptKinkDaughters ;
205 fhCutStatistics = c.fhCutStatistics ;
206 fhCutCorrelation = c.fhCutCorrelation ;
207 fBitmap = c.fBitmap;
208 fhNBinsNSigma = c.fhNBinsNSigma;
209 fhNBinsRequireSigma = c.fhNBinsRequireSigma;
210 fhNBinsAcceptKink = c.fhNBinsAcceptKink;
211 fhNBinsDcaXY = c.fhNBinsDcaXY;
212 fhNBinsDcaZ = c.fhNBinsDcaZ;
213 fhNBinsDcaXYnorm = c.fhNBinsDcaXYnorm;
214 fhNBinsDcaZnorm = c.fhNBinsDcaZnorm;
89d7d478 215 fhNBinsSigmaDcaXY = c.fhNBinsSigmaDcaXY;
216 fhNBinsSigmaDcaZ = c.fhNBinsSigmaDcaZ;
563113d0 217 fhBinLimNSigma = c.fhBinLimNSigma;
218 fhBinLimRequireSigma = c.fhBinLimRequireSigma;
219 fhBinLimAcceptKink = c.fhBinLimAcceptKink;
220 fhBinLimDcaXY = c.fhBinLimDcaXY;
221 fhBinLimDcaZ = c.fhBinLimDcaZ;
222 fhBinLimDcaXYnorm = c.fhBinLimDcaXYnorm;
223 fhBinLimDcaZnorm = c.fhBinLimDcaZnorm;
89d7d478 224 fhBinLimSigmaDcaXY = c.fhBinLimSigmaDcaXY;
225 fhBinLimSigmaDcaZ = c.fhBinLimSigmaDcaZ;
62037e79 226
8edd0c2c 227 for (Int_t j=0; j<c.kNStepQA; j++){
228 if(c.fhDcaXYvsDcaZ[j]) fhDcaXYvsDcaZ[j] = (TH2F*)c.fhDcaXYvsDcaZ[j]->Clone();
229 if(c.fhDcaXYvsDcaZnorm[j]) fhDcaXYvsDcaZnorm[j] = (TH2F*)c.fhDcaXYvsDcaZnorm[j]->Clone();
230 for (Int_t i=0; i<c.kNHist; i++){
563113d0 231 if(c.fhQA[i][j]) fhQA[i][j] = (TH1F*)c.fhQA[i][j]->Clone();
563113d0 232 }
233 }
563113d0 234 ((AliCFTrackIsPrimaryCuts &) c).Copy(*this);
235 }
236 return *this;
237}
238//__________________________________________________________________________________
239AliCFTrackIsPrimaryCuts::~AliCFTrackIsPrimaryCuts()
240{
241 //
242 // destructor
243 //
244 if (fhCutStatistics) delete fhCutStatistics;
245 if (fhCutCorrelation) delete fhCutCorrelation;
246
247 for (Int_t j=0; j<kNStepQA; j++){
62037e79 248 if(fhDcaXYvsDcaZ[j]) delete fhDcaXYvsDcaZ[j];
249 if(fhDcaXYvsDcaZnorm[j]) delete fhDcaXYvsDcaZnorm[j];
250 for (Int_t i=0; i<kNHist; i++)
251 if(fhQA[i][j]) delete fhQA[i][j];
563113d0 252 }
62037e79 253 if(fBitmap) delete fBitmap;
254 if(fhBinLimNSigma) delete fhBinLimNSigma;
255 if(fhBinLimRequireSigma) delete fhBinLimRequireSigma;
256 if(fhBinLimAcceptKink) delete fhBinLimAcceptKink;
257 if(fhBinLimDcaXY) delete fhBinLimDcaXY;
258 if(fhBinLimDcaZ) delete fhBinLimDcaZ;
259 if(fhBinLimDcaXYnorm) delete fhBinLimDcaXYnorm;
260 if(fhBinLimDcaZnorm) delete fhBinLimDcaZnorm;
89d7d478 261 if(fhBinLimSigmaDcaXY) delete fhBinLimSigmaDcaXY;
262 if(fhBinLimSigmaDcaZ) delete fhBinLimSigmaDcaZ;
563113d0 263}
264//__________________________________________________________________________________
265void AliCFTrackIsPrimaryCuts::Initialise()
266{
267 //
268 // sets everything to zero
269 //
89d7d478 270 fMinDCAToVertexXY = 0;
271 fMinDCAToVertexZ = 0;
272 fMaxDCAToVertexXY = 0;
273 fMaxDCAToVertexZ = 0;
274 fDCAToVertex2D = 0;
275 fAbsDCAToVertex = 0;
276 fNSigmaToVertexMin = 0;
563113d0 277 fNSigmaToVertexMax = 0;
89d7d478 278 fSigmaDCAxy = 0;
279 fSigmaDCAz = 0;
563113d0 280 fRequireSigmaToVertex = 0;
281 fAcceptKinkDaughters = 0;
8edd0c2c 282 fAODType = AliAODTrack::kUndef;
563113d0 283
89d7d478 284 SetMinDCAToVertexXY();
285 SetMinDCAToVertexZ();
286 SetMaxDCAToVertexXY();
287 SetMaxDCAToVertexZ();
288 SetDCAToVertex2D();
289 SetAbsDCAToVertex();
290 SetMinNSigmaToVertex();
563113d0 291 SetMaxNSigmaToVertex();
89d7d478 292 SetMaxSigmaDCAxy();
293 SetMaxSigmaDCAz();
563113d0 294 SetRequireSigmaToVertex();
cced7196 295 SetAcceptKinkDaughters();
8edd0c2c 296 SetAODType();
563113d0 297
298 for (Int_t j=0; j<kNStepQA; j++) {
563113d0 299 fhDcaXYvsDcaZ[j] = 0x0;
300 fhDcaXYvsDcaZnorm[j] = 0x0;
62037e79 301 for (Int_t i=0; i<kNHist; i++)
302 fhQA[i][j] = 0x0;
563113d0 303 }
304 fhCutStatistics = 0;
305 fhCutCorrelation = 0;
62037e79 306 fBitmap=new TBits(0);
307
563113d0 308 //set default bining for QA histograms
62037e79 309 SetHistogramBins(kCutNSigmaToVertex,500,0.,50.);
310 SetHistogramBins(kCutRequireSigmaToVertex,5,-0.75,1.75);
311 SetHistogramBins(kCutAcceptKinkDaughters,5,-0.75,1.75);
312 SetHistogramBins(kDcaXY,500,-10.,10.);
313 SetHistogramBins(kDcaZ,500,-10.,10.);
314 SetHistogramBins(kDcaXYnorm,500,-10.,10.);
315 SetHistogramBins(kDcaZnorm,500,-10.,10.);
89d7d478 316 SetHistogramBins(kSigmaDcaXY,500,-0.1,0.9);
317 SetHistogramBins(kSigmaDcaZ,500,-0.1,0.9);
563113d0 318}
319//__________________________________________________________________________________
320void AliCFTrackIsPrimaryCuts::Copy(TObject &c) const
321{
322 //
323 // Copy function
324 //
325 AliCFTrackIsPrimaryCuts& target = (AliCFTrackIsPrimaryCuts &) c;
326
327 target.Initialise();
328
329 if (fhCutStatistics) target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
330 if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
331
332 for (Int_t j=0; j<kNStepQA; j++){
563113d0 333 if(fhDcaXYvsDcaZ[j]) target.fhDcaXYvsDcaZ[j] = (TH2F*)fhDcaXYvsDcaZ[j]->Clone();
334 if(fhDcaXYvsDcaZnorm[j]) target.fhDcaXYvsDcaZnorm[j] = (TH2F*)fhDcaXYvsDcaZnorm[j]->Clone();
62037e79 335 for (Int_t i=0; i<kNHist; i++)
336 if(fhQA[i][j]) target.fhQA[i][j] = (TH1F*)fhQA[i][j]->Clone();
563113d0 337 }
563113d0 338 TNamed::Copy(c);
339}
563113d0 340//__________________________________________________________________________________
107a3100 341void AliCFTrackIsPrimaryCuts::SelectionBitMap(TObject* obj)
563113d0 342{
343 //
344 // test if the track passes the single cuts
345 // and store the information in a bitmap
346 //
347
348 // bitmap stores the decision of each single cut
349 for(Int_t i=0; i<kNCuts; i++)fBitmap->SetBitNumber(i,kFALSE);
350
107a3100 351 // check TObject and cast into ESDtrack
352 if (!obj) return;
8edd0c2c 353 if (!obj->InheritsFrom("AliVParticle")) {
354 AliError("object must derived from AliVParticle !");
355 return;
356 }
357
358 Bool_t isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
359 Bool_t isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
360
361 AliESDtrack * esdTrack = 0x0 ;
362 AliAODTrack * aodTrack = 0x0 ;
363 if (isESDTrack) esdTrack = dynamic_cast<AliESDtrack*>(obj);
364 if (isAODTrack) aodTrack = dynamic_cast<AliAODTrack*>(obj);
563113d0 365
8edd0c2c 366 // get the track to vertex parameter for ESD track
89d7d478 367 Float_t nSigmaToVertex = 0.;
368 if (isESDTrack) nSigmaToVertex = AliESDtrackCuts::GetSigmaToVertex(esdTrack);
369
370 Float_t b[2];
371 Float_t bRes[2];
372 Float_t bCov[3];
373 Float_t b2Dmin = 0, b2Dmax = 0;
374 if (isESDTrack) {
375 esdTrack->GetImpactParameters(b,bCov);
376 if (bCov[0]<=0 || bCov[2]<=0) {
377// // // AliDebugClass(1, "Estimated b resolution lower or equal zero!");
378 bCov[0]=0; bCov[2]=0;
379 }
380 b[0] = TMath::Abs(b[0]);
381 b[1] = TMath::Abs(b[1]);
382 bRes[0] = TMath::Sqrt(bCov[0]);
383 bRes[1] = TMath::Sqrt(bCov[2]);
384 if (!fAbsDCAToVertex) {
385 if (bRes[0] > 0) b[0] = b[0]/bRes[0];
386// // // else AliDebugClass(1, "Estimated b resolution equal zero!");
387 if (bRes[1] > 0) b[1] = b[1]/bRes[1];
388// // // else AliDebugClass(1, "Estimated b resolution equal zero!");
389 }
390 if (fMinDCAToVertexXY>0 && fMinDCAToVertexZ>0)
391 b2Dmin = b[0]*b[0]/fMinDCAToVertexXY/fMinDCAToVertexXY + b[1]*b[1]/fMinDCAToVertexZ/fMinDCAToVertexZ;
392 if (fMaxDCAToVertexXY>0 && fMaxDCAToVertexZ>0)
393 b2Dmax = b[0]*b[0]/fMaxDCAToVertexXY/fMaxDCAToVertexXY + b[1]*b[1]/fMaxDCAToVertexZ/fMaxDCAToVertexZ;
394 }
563113d0 395
396 // fill the bitmap
397 Int_t iCutBit = 0;
8edd0c2c 398
399 if (isESDTrack) {
89d7d478 400 if (fDCAToVertex2D || (!fDCAToVertex2D && b[0] >= fMinDCAToVertexXY && b[0] <= fMaxDCAToVertexXY)) {
401 fBitmap->SetBitNumber(iCutBit,kTRUE);
402 }
403 }
404 else fBitmap->SetBitNumber(iCutBit,kTRUE);
405
406 iCutBit++;
407
408 if (isESDTrack) {
409 if (fDCAToVertex2D || (!fDCAToVertex2D && b[1] >= fMinDCAToVertexZ && b[1] <= fMaxDCAToVertexZ)) {
410 fBitmap->SetBitNumber(iCutBit,kTRUE);
411 }
412 }
413 else fBitmap->SetBitNumber(iCutBit,kTRUE);
414
415 iCutBit++;
416
417 if (isESDTrack) {
418 if (!fDCAToVertex2D || (fDCAToVertex2D && b2Dmin > 1 && b2Dmax < 1)) {
8edd0c2c 419 fBitmap->SetBitNumber(iCutBit,kTRUE);
420 }
421 }
422 else fBitmap->SetBitNumber(iCutBit,kTRUE);
423
563113d0 424 iCutBit++;
8edd0c2c 425
426 if (isESDTrack) {
89d7d478 427 if (nSigmaToVertex >= fNSigmaToVertexMin && nSigmaToVertex <= fNSigmaToVertexMax) {
428 fBitmap->SetBitNumber(iCutBit,kTRUE);
429 }
430 }
431 else fBitmap->SetBitNumber(iCutBit,kTRUE);
432
433 iCutBit++;
434
435 if (isESDTrack) {
436 if (bRes[0] < fSigmaDCAxy) {
437 fBitmap->SetBitNumber(iCutBit,kTRUE);
438 }
439 }
440 else fBitmap->SetBitNumber(iCutBit,kTRUE);
441
442 iCutBit++;
443
444 if (isESDTrack) {
445 if (bRes[1] < fSigmaDCAz) {
446 fBitmap->SetBitNumber(iCutBit,kTRUE);
447 }
448 }
449 else fBitmap->SetBitNumber(iCutBit,kTRUE);
450
451 iCutBit++;
452
453 if (isESDTrack) {
454 if (!fRequireSigmaToVertex || (nSigmaToVertex>=0 && fRequireSigmaToVertex)) {
8edd0c2c 455 fBitmap->SetBitNumber(iCutBit,kTRUE);
456 }
457 }
458 else fBitmap->SetBitNumber(iCutBit,kTRUE);
459
563113d0 460 iCutBit++;
563113d0 461
8edd0c2c 462 if (esdTrack) {
463 if (fAcceptKinkDaughters || (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)<=0)) {
464 fBitmap->SetBitNumber(iCutBit,kTRUE);
465 }
466 }
467 else fBitmap->SetBitNumber(iCutBit,kTRUE);
468
469 iCutBit++;
470
471 if (isAODTrack) {
472 if (fAODType==AliAODTrack::kUndef || fAODType == aodTrack->GetType()) {
473 fBitmap->SetBitNumber(iCutBit,kTRUE);
474 }
475 }
476 else fBitmap->SetBitNumber(iCutBit,kTRUE);
477
107a3100 478 return;
563113d0 479}
480//__________________________________________________________________________________
481Bool_t AliCFTrackIsPrimaryCuts::IsSelected(TObject* obj) {
482 //
483 // loops over decisions of single cuts and returns if the track is accepted
484 //
107a3100 485 SelectionBitMap(obj);
563113d0 486
107a3100 487 if (fIsQAOn) FillHistograms(obj,0);
563113d0 488 Bool_t isSelected = kTRUE;
489
107a3100 490 for (UInt_t icut=0; icut<fBitmap->GetNbits();icut++) {
491 if(!fBitmap->TestBitNumber(icut)) {
492 isSelected = kFALSE;
493 break;
494 }
495 }
496 if (!isSelected) return kFALSE ;
497 if (fIsQAOn) FillHistograms(obj,1);
498 return kTRUE;
563113d0 499}
500//__________________________________________________________________________________
501void AliCFTrackIsPrimaryCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t *bins)
502{
503 //
504 // variable bin size
505 //
506 if(!fIsQAOn) return;
507
508 switch(index){
509 case kCutNSigmaToVertex:
db6722a5 510 fhNBinsNSigma=nbins+1;
563113d0 511 fhBinLimNSigma=new Double_t[nbins+1];
512 for(Int_t i=0;i<nbins+1;i++)fhBinLimNSigma[i]=bins[i];
513 break;
514
515 case kCutRequireSigmaToVertex:
db6722a5 516 fhNBinsRequireSigma=nbins+1;
563113d0 517 fhBinLimRequireSigma=new Double_t[nbins+1];
518 for(Int_t i=0;i<nbins+1;i++)fhBinLimRequireSigma[i]=bins[i];
519 break;
520
521 case kCutAcceptKinkDaughters:
db6722a5 522 fhNBinsAcceptKink=nbins+1;
563113d0 523 fhBinLimAcceptKink=new Double_t[nbins+1];
524 for(Int_t i=0;i<nbins+1;i++)fhBinLimAcceptKink[i]=bins[i];
525 break;
526
527 case kDcaXY:
db6722a5 528 fhNBinsDcaXY=nbins+1;
563113d0 529 fhBinLimDcaXY=new Double_t[nbins+1];
530 for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXY[i]=bins[i];
531 break;
62037e79 532
563113d0 533 case kDcaZ:
db6722a5 534 fhNBinsDcaZ=nbins+1;
563113d0 535 fhBinLimDcaZ=new Double_t[nbins+1];
536 for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZ[i]=bins[i];
537 break;
62037e79 538
563113d0 539 case kDcaXYnorm:
db6722a5 540 fhNBinsDcaXYnorm=nbins+1;
563113d0 541 fhBinLimDcaXYnorm=new Double_t[nbins+1];
542 for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXYnorm[i]=bins[i];
543 break;
62037e79 544
563113d0 545 case kDcaZnorm:
db6722a5 546 fhNBinsDcaZnorm=nbins+1;
563113d0 547 fhBinLimDcaZnorm=new Double_t[nbins+1];
548 for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZnorm[i]=bins[i];
549 break;
89d7d478 550
551 case kSigmaDcaXY:
552 fhNBinsSigmaDcaXY=nbins+1;
553 fhBinLimSigmaDcaXY=new Double_t[nbins+1];
554 for(Int_t i=0;i<nbins+1;i++)fhBinLimSigmaDcaXY[i]=bins[i];
555 break;
556
557 case kSigmaDcaZ:
558 fhNBinsSigmaDcaZ=nbins+1;
559 fhBinLimSigmaDcaZ=new Double_t[nbins+1];
560 for(Int_t i=0;i<nbins+1;i++)fhBinLimSigmaDcaZ[i]=bins[i];
561 break;
563113d0 562 }
563}
564//__________________________________________________________________________________
565void AliCFTrackIsPrimaryCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t xmin, Double_t xmax)
566{
567 //
568 // fixed bin size
569 //
563113d0 570 switch(index){
571 case kCutNSigmaToVertex:
db6722a5 572 fhNBinsNSigma=nbins+1;
563113d0 573 fhBinLimNSigma=new Double_t[nbins+1];
574 for(Int_t i=0;i<nbins+1;i++)fhBinLimNSigma[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
575 break;
576
577 case kCutRequireSigmaToVertex:
db6722a5 578 fhNBinsRequireSigma=nbins+1;
563113d0 579 fhBinLimRequireSigma=new Double_t[nbins+1];
580 for(Int_t i=0;i<nbins+1;i++)fhBinLimRequireSigma[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
581 break;
582
583 case kCutAcceptKinkDaughters:
db6722a5 584 fhNBinsAcceptKink=nbins+1;
563113d0 585 fhBinLimAcceptKink=new Double_t[nbins+1];
586 for(Int_t i=0;i<nbins+1;i++)fhBinLimAcceptKink[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
587 break;
588
589 case kDcaXY:
db6722a5 590 fhNBinsDcaXY=nbins+1;
563113d0 591 fhBinLimDcaXY=new Double_t[nbins+1];
592 for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXY[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
593 break;
62037e79 594
563113d0 595 case kDcaZ:
db6722a5 596 fhNBinsDcaZ=nbins+1;
563113d0 597 fhBinLimDcaZ=new Double_t[nbins+1];
598 for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZ[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
599 break;
62037e79 600
563113d0 601 case kDcaXYnorm:
db6722a5 602 fhNBinsDcaXYnorm=nbins+1;
563113d0 603 fhBinLimDcaXYnorm=new Double_t[nbins+1];
604 for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXYnorm[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
605 break;
62037e79 606
563113d0 607 case kDcaZnorm:
db6722a5 608 fhNBinsDcaZnorm=nbins+1;
563113d0 609 fhBinLimDcaZnorm=new Double_t[nbins+1];
610 for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZnorm[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
611 break;
89d7d478 612
613 case kSigmaDcaXY:
614 fhNBinsSigmaDcaXY=nbins+1;
615 fhBinLimSigmaDcaXY=new Double_t[nbins+1];
616 for(Int_t i=0;i<nbins+1;i++)fhBinLimSigmaDcaXY[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
617 break;
618
619 case kSigmaDcaZ:
620 fhNBinsSigmaDcaZ=nbins+1;
621 fhBinLimSigmaDcaZ=new Double_t[nbins+1];
622 for(Int_t i=0;i<nbins+1;i++)fhBinLimSigmaDcaZ[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
623 break;
563113d0 624 }
625}
626//__________________________________________________________________________________
627 void AliCFTrackIsPrimaryCuts::DefineHistograms() {
628 //
629 // histograms for cut variables, cut statistics and cut correlations
630 //
563113d0 631 Int_t color = 2;
632
633 // book cut statistics and cut correlation histograms
634 fhCutStatistics = new TH1F(Form("%s_cut_statistics",GetName()), Form("%s cut statistics",GetName()), kNCuts,0.5,kNCuts+0.5);
635 fhCutStatistics->SetLineWidth(2);
89d7d478 636 fhCutStatistics->GetXaxis()->SetBinLabel(1,"dca xy");
637 fhCutStatistics->GetXaxis()->SetBinLabel(2,"dca z");
638 fhCutStatistics->GetXaxis()->SetBinLabel(3,"dca ellipse");
639 fhCutStatistics->GetXaxis()->SetBinLabel(4,"n dca");
640 fhCutStatistics->GetXaxis()->SetBinLabel(5,"sigma dca xy");
641 fhCutStatistics->GetXaxis()->SetBinLabel(6,"sigma dca z");
642 fhCutStatistics->GetXaxis()->SetBinLabel(7,"require dca");
643 fhCutStatistics->GetXaxis()->SetBinLabel(8,"kink daughter");
644 fhCutStatistics->GetXaxis()->SetBinLabel(9,"AOD type");
563113d0 645
646 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);
647 fhCutCorrelation->SetLineWidth(2);
89d7d478 648 fhCutCorrelation->GetXaxis()->SetBinLabel(1,"dca xy");
649 fhCutCorrelation->GetXaxis()->SetBinLabel(2,"dca z");
650 fhCutCorrelation->GetXaxis()->SetBinLabel(3,"dca ellipse");
651 fhCutCorrelation->GetXaxis()->SetBinLabel(4,"n dca");
652 fhCutCorrelation->GetXaxis()->SetBinLabel(5,"sigma dca xy");
653 fhCutCorrelation->GetXaxis()->SetBinLabel(6,"sigma dca z");
654 fhCutCorrelation->GetXaxis()->SetBinLabel(7,"require dca");
655 fhCutCorrelation->GetXaxis()->SetBinLabel(8,"kink daughter");
656 fhCutCorrelation->GetXaxis()->SetBinLabel(9,"AOD type");
657
658 fhCutCorrelation->GetYaxis()->SetBinLabel(1,"dca xy");
659 fhCutCorrelation->GetYaxis()->SetBinLabel(2,"dca z");
660 fhCutCorrelation->GetYaxis()->SetBinLabel(3,"dca ellipse");
661 fhCutCorrelation->GetYaxis()->SetBinLabel(4,"n dca");
662 fhCutCorrelation->GetYaxis()->SetBinLabel(5,"sigma dca xy");
663 fhCutCorrelation->GetYaxis()->SetBinLabel(6,"sigma dca z");
664 fhCutCorrelation->GetYaxis()->SetBinLabel(7,"require dca");
665 fhCutCorrelation->GetYaxis()->SetBinLabel(8,"kink daughter");
666 fhCutCorrelation->GetYaxis()->SetBinLabel(9,"AOD type");
563113d0 667
668 // book QA histograms
669 Char_t str[256];
670 for (Int_t i=0; i<kNStepQA; i++) {
671 if (i==0) sprintf(str," ");
672 else sprintf(str,"_cut");
62037e79 673
563113d0 674 fhDcaXYvsDcaZ[i] = new TH2F(Form("%s_dcaXYvsDcaZ%s",GetName(),str),"",200,-10,10,200,-10,10);
675 fhDcaXYvsDcaZnorm[i] = new TH2F(Form("%s_dcaXYvsDcaZnorm%s",GetName(),str),"",200,-10,10,200,-10,10);
db6722a5 676 fhQA[kCutNSigmaToVertex][i] = new TH1F(Form("%s_nSigmaToVertex%s",GetName(),str),"",fhNBinsNSigma-1,fhBinLimNSigma);
677 fhQA[kCutRequireSigmaToVertex][i] = new TH1F(Form("%s_requireSigmaToVertex%s",GetName(),str),"",fhNBinsRequireSigma-1,fhBinLimRequireSigma);
678 fhQA[kCutAcceptKinkDaughters][i] = new TH1F(Form("%s_acceptKinkDaughters%s",GetName(),str),"",fhNBinsAcceptKink-1,fhBinLimAcceptKink);
679 fhQA[kDcaXY][i] = new TH1F(Form("%s_dcaXY%s",GetName(),str),"",fhNBinsDcaXY-1,fhBinLimDcaXY);
680 fhQA[kDcaZ][i] = new TH1F(Form("%s_dcaZ%s",GetName(),str),"",fhNBinsDcaZ-1,fhBinLimDcaZ);
681 fhQA[kDcaXYnorm][i] = new TH1F(Form("%s_dcaXYnorm%s",GetName(),str),"",fhNBinsDcaXYnorm-1,fhBinLimDcaXYnorm);
682 fhQA[kDcaZnorm][i] = new TH1F(Form("%s_dcaZnorm%s",GetName(),str),"",fhNBinsDcaZnorm-1,fhBinLimDcaZnorm);
89d7d478 683 fhQA[kSigmaDcaXY][i] = new TH1F(Form("%s_sigmaDcaXY%s",GetName(),str),"",fhNBinsSigmaDcaXY-1,fhBinLimSigmaDcaXY);
684 fhQA[kSigmaDcaZ][i] = new TH1F(Form("%s_sigmaDcaZ%s",GetName(),str),"",fhNBinsSigmaDcaZ-1,fhBinLimSigmaDcaZ);
563113d0 685
686 fhDcaXYvsDcaZ[i]->SetXTitle("impact par. d_{z}");
687 fhDcaXYvsDcaZ[i]->SetYTitle("impact par. d_{xy}");
688 fhDcaXYvsDcaZnorm[i]->SetXTitle("norm. impact par. d_{z} / #sigma_{z}");
689 fhDcaXYvsDcaZnorm[i]->SetYTitle("norm. impact par. d_{xy} / #sigma_{xy}");
690
691 fhQA[kCutNSigmaToVertex][i]->SetXTitle("n #sigma to vertex");
692 fhQA[kCutRequireSigmaToVertex][i]->SetXTitle("require #sigma to vertex");
693 fhQA[kCutAcceptKinkDaughters][i]->SetXTitle("accept kink daughters");
694 fhQA[kDcaXY][i]->SetXTitle("impact par. d_{xy}");
695 fhQA[kDcaZ][i]->SetXTitle("impact par. d_{z}");
696 fhQA[kDcaXYnorm][i]->SetXTitle("norm. impact par. d_{xy} / #sigma_{xy}");
697 fhQA[kDcaZnorm][i]->SetXTitle("norm. impact par. d_{z} / #sigma_{z}");
89d7d478 698 fhQA[kSigmaDcaXY][i]->SetXTitle("impact par. resolution #sigma_{xy}");
699 fhQA[kSigmaDcaZ][i]->SetXTitle("impact par. resolution #sigma_{z}");
563113d0 700 }
563113d0 701 for(Int_t i=0; i<kNHist; i++) fhQA[i][1]->SetLineColor(color);
563113d0 702}
703//__________________________________________________________________________________
704void AliCFTrackIsPrimaryCuts::FillHistograms(TObject* obj, Bool_t f)
705{
706 //
707 // fill the QA histograms
708 //
563113d0 709
107a3100 710 if (!obj) return;
563113d0 711
8edd0c2c 712 Bool_t isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
713 Bool_t isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
563113d0 714
8edd0c2c 715 AliESDtrack * esdTrack = 0x0 ;
716 AliAODTrack * aodTrack = 0x0 ;
717 if (isESDTrack) esdTrack = dynamic_cast<AliESDtrack*>(obj);
718 if (isAODTrack) aodTrack = dynamic_cast<AliAODTrack*>(obj);
563113d0 719
8edd0c2c 720 // f = 0: fill histograms before cuts
721 // f = 1: fill histograms after cuts
563113d0 722
89d7d478 723 // get the track to vertex parameter for ESD track
724 Float_t nSigmaToVertex = 0.;
725 if (isESDTrack) nSigmaToVertex = AliESDtrackCuts::GetSigmaToVertex(esdTrack);
8edd0c2c 726 if (esdTrack) {
727 Float_t b[2];
728 Float_t bRes[2];
729 Float_t bCov[3];
730 esdTrack->GetImpactParameters(b,bCov);
731 if (bCov[0]<=0 || bCov[2]<=0) {
732 AliDebug(1, "Estimated b resolution lower or equal zero!");
733 bCov[0]=0; bCov[2]=0;
734 }
735 bRes[0] = TMath::Sqrt(bCov[0]);
736 bRes[1] = TMath::Sqrt(bCov[2]);
737
738 fhQA[kDcaZ][f]->Fill(b[1]);
739 fhQA[kDcaXY][f]->Fill(b[0]);
740 fhDcaXYvsDcaZ[f]->Fill(b[1],b[0]);
89d7d478 741 fhQA[kSigmaDcaXY][f]->Fill(bRes[0]);
742 fhQA[kSigmaDcaZ][f]->Fill(bRes[1]);
743
8edd0c2c 744 if (bRes[0]!=0 && bRes[1]!=0) {
745 fhQA[kDcaZnorm][f]->Fill(b[1]/bRes[1]);
746 fhQA[kDcaXYnorm][f]->Fill(b[0]/bRes[0]);
747 fhDcaXYvsDcaZnorm[f]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
748 }
563113d0 749
89d7d478 750 fhQA[kCutNSigmaToVertex][f]->Fill(nSigmaToVertex);
751 if (nSigmaToVertex<0 && fRequireSigmaToVertex) fhQA[kCutRequireSigmaToVertex][f]->Fill(0.);
752 if (!(nSigmaToVertex<0 && fRequireSigmaToVertex)) fhQA[kCutRequireSigmaToVertex][f]->Fill(1.);
8edd0c2c 753
754 if (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0) fhQA[kCutAcceptKinkDaughters][f]->Fill(0.);
755 if (!(!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)) fhQA[kCutAcceptKinkDaughters][f]->Fill(0.);
756 }
757
563113d0 758 // fill cut statistics and cut correlation histograms with information from the bitmap
759 if (f) return;
760
761 // Get the bitmap of the single cuts
762 if ( !obj ) return;
107a3100 763 SelectionBitMap(obj);
563113d0 764
765 // Number of single cuts in this class
107a3100 766 UInt_t ncuts = fBitmap->GetNbits();
563113d0 767 for(UInt_t bit=0; bit<ncuts;bit++) {
107a3100 768 if (!fBitmap->TestBitNumber(bit)) {
563113d0 769 fhCutStatistics->Fill(bit+1);
770 for (UInt_t bit2=bit; bit2<ncuts;bit2++) {
107a3100 771 if (!fBitmap->TestBitNumber(bit2))
563113d0 772 fhCutCorrelation->Fill(bit+1,bit2+1);
773 }
774 }
775 }
776}
777//__________________________________________________________________________________
778void AliCFTrackIsPrimaryCuts::SaveHistograms(const Char_t* dir) {
779 //
780 // saves the histograms in a directory (dir)
781 //
782 if(!fIsQAOn) return;
783
784 if (!dir)
785 dir = GetName();
786
787 gDirectory->mkdir(dir);
788 gDirectory->cd(dir);
789
790 gDirectory->mkdir("before_cuts");
791 gDirectory->mkdir("after_cuts");
792
793 fhCutStatistics->Write();
794 fhCutCorrelation->Write();
795
796 for (Int_t j=0; j<kNStepQA; j++) {
797 if (j==0)
798 gDirectory->cd("before_cuts");
799 else
800 gDirectory->cd("after_cuts");
801
802 fhDcaXYvsDcaZ[j] ->Write();
803 fhDcaXYvsDcaZnorm[j]->Write();
804
805 for(Int_t i=0; i<kNHist; i++) fhQA[i][j]->Write();
806
807 gDirectory->cd("../");
808 }
809 gDirectory->cd("../");
810}
811//__________________________________________________________________________________
812void AliCFTrackIsPrimaryCuts::DrawHistograms()
813{
814 //
815 // draws some histograms
816 //
817 if(!fIsQAOn) return;
818
819 // pad margins
820 Float_t right = 0.03;
821 Float_t left = 0.175;
822 Float_t top = 0.03;
823 Float_t bottom = 0.175;
824
825 TCanvas* canvas1 = new TCanvas("Track_QA_Primary_1", "Track QA Primary 1", 800, 500);
826 canvas1->Divide(2, 1);
827
828 canvas1->cd(1);
829 fhCutStatistics->SetStats(kFALSE);
830 fhCutStatistics->LabelsOption("v");
831 gPad->SetLeftMargin(left);
832 gPad->SetBottomMargin(0.25);
833 gPad->SetRightMargin(right);
834 gPad->SetTopMargin(0.1);
835 fhCutStatistics->Draw();
836
837 canvas1->cd(2);
838 fhCutCorrelation->SetStats(kFALSE);
839 fhCutCorrelation->LabelsOption("v");
840 gPad->SetLeftMargin(0.30);
841 gPad->SetRightMargin(bottom);
842 gPad->SetTopMargin(0.1);
843 gPad->SetBottomMargin(0.25);
844 fhCutCorrelation->Draw("COLZ");
845
846 canvas1->SaveAs(Form("%s.eps", canvas1->GetName()));
847 canvas1->SaveAs(Form("%s.ps", canvas1->GetName()));
848
849 // -----
850
851 TCanvas* canvas2 = new TCanvas("Track_QA_Primary_2", "Track QA Primary 2", 800, 800);
852 canvas2->Divide(2, 2);
853
854 canvas2->cd(1);
855 gPad->SetRightMargin(right);
856 gPad->SetLeftMargin(left);
857 gPad->SetTopMargin(top);
858 gPad->SetBottomMargin(bottom);
859 fhQA[kDcaXY][0]->SetStats(kFALSE);
860 fhQA[kDcaXY][0]->Draw();
861 fhQA[kDcaXY][1]->Draw("same");
862
863 canvas2->cd(2);
864 gPad->SetRightMargin(right);
865 gPad->SetLeftMargin(left);
866 gPad->SetTopMargin(top);
867 gPad->SetBottomMargin(bottom);
868 fhQA[kDcaZ][0]->SetStats(kFALSE);
869 fhQA[kDcaZ][0]->Draw();
870 fhQA[kDcaZ][1]->Draw("same");
871
872 canvas2->cd(3);
873// fhDXYvsDZ[0]->SetStats(kFALSE);
874 gPad->SetLogz();
875 gPad->SetLeftMargin(bottom);
876 gPad->SetTopMargin(0.1);
877 gPad->SetBottomMargin(bottom);
878 gPad->SetRightMargin(0.2);
879 fhDcaXYvsDcaZ[0]->Draw("COLZ");
880
881 canvas2->cd(4);
882// fhDXYvsDZ[1]->SetStats(kFALSE);
883 gPad->SetLogz();
884 gPad->SetLeftMargin(bottom);
885 gPad->SetTopMargin(0.1);
886 gPad->SetBottomMargin(bottom);
887 gPad->SetRightMargin(0.2);
888 fhDcaXYvsDcaZ[1]->Draw("COLZ");
889
890 canvas2->SaveAs(Form("%s.eps", canvas2->GetName()));
891 canvas2->SaveAs(Form("%s.ps", canvas2->GetName()));
892
893 // -----
894
895 TCanvas* canvas3 = new TCanvas("Track_QA_Primary_3", "Track QA Primary 3", 800, 800);
896 canvas3->Divide(2, 2);
897
898 canvas3->cd(1);
899 gPad->SetRightMargin(right);
900 gPad->SetLeftMargin(left);
901 gPad->SetTopMargin(top);
902 gPad->SetBottomMargin(bottom);
903 fhQA[kDcaXYnorm][0]->SetStats(kFALSE);
904 fhQA[kDcaXYnorm][0]->Draw();
905 fhQA[kDcaXYnorm][1]->Draw("same");
906
907 canvas3->cd(2);
908 gPad->SetRightMargin(right);
909 gPad->SetLeftMargin(left);
910 gPad->SetTopMargin(top);
911 gPad->SetBottomMargin(bottom);
912 fhQA[kDcaZnorm][0]->SetStats(kFALSE);
913 fhQA[kDcaZnorm][0]->Draw();
914 fhQA[kDcaZnorm][1]->Draw("same");
915
916 canvas3->cd(3);
917// fhDXYvsDZ[0]->SetStats(kFALSE);
918 gPad->SetLogz();
919 gPad->SetLeftMargin(bottom);
920 gPad->SetTopMargin(0.1);
921 gPad->SetBottomMargin(bottom);
922 gPad->SetRightMargin(0.2);
923 fhDcaXYvsDcaZnorm[0]->Draw("COLZ");
924
925 canvas3->cd(4);
926// fhDXYvsDZ[1]->SetStats(kFALSE);
927 gPad->SetLogz();
928 gPad->SetLeftMargin(bottom);
929 gPad->SetTopMargin(0.1);
930 gPad->SetBottomMargin(bottom);
931 gPad->SetRightMargin(0.2);
932 fhDcaXYvsDcaZnorm[1]->Draw("COLZ");
933
934 canvas3->SaveAs(Form("%s.eps", canvas3->GetName()));
935 canvas3->SaveAs(Form("%s.ps", canvas3->GetName()));
936
937 // -----
938
89d7d478 939 TCanvas* canvas4 = new TCanvas("Track_QA_Primary_4", "Track QA Primary 4", 1200, 800);
940 canvas4->Divide(3, 2);
563113d0 941
942 canvas4->cd(1);
943 gPad->SetRightMargin(right);
944 gPad->SetLeftMargin(left);
945 gPad->SetTopMargin(top);
946 gPad->SetBottomMargin(bottom);
89d7d478 947 fhQA[kSigmaDcaXY][0]->SetStats(kFALSE);
948 fhQA[kSigmaDcaXY][0]->Draw();
949 fhQA[kSigmaDcaXY][1]->Draw("same");
950
951 canvas4->cd(2);
952 gPad->SetRightMargin(right);
953 gPad->SetLeftMargin(left);
954 gPad->SetTopMargin(top);
955 gPad->SetBottomMargin(bottom);
956 fhQA[kSigmaDcaZ][0]->SetStats(kFALSE);
957 fhQA[kSigmaDcaZ][0]->Draw();
958 fhQA[kSigmaDcaZ][1]->Draw("same");
959
960 canvas4->cd(4);
961 gPad->SetRightMargin(right);
962 gPad->SetLeftMargin(left);
963 gPad->SetTopMargin(top);
964 gPad->SetBottomMargin(bottom);
563113d0 965 fhQA[kCutNSigmaToVertex][0]->SetStats(kFALSE);
966 fhQA[kCutNSigmaToVertex][0]->Draw();
967 fhQA[kCutNSigmaToVertex][1]->Draw("same");
968
89d7d478 969 canvas4->cd(5);
563113d0 970 gPad->SetRightMargin(right);
971 gPad->SetLeftMargin(left);
972 gPad->SetTopMargin(top);
973 gPad->SetBottomMargin(bottom);
974 fhQA[kCutRequireSigmaToVertex][0]->SetStats(kFALSE);
975 fhQA[kCutRequireSigmaToVertex][0]->Draw();
976 fhQA[kCutRequireSigmaToVertex][1]->Draw("same");
977
89d7d478 978 canvas4->cd(6);
563113d0 979 gPad->SetRightMargin(right);
980 gPad->SetLeftMargin(left);
981 gPad->SetTopMargin(top);
982 gPad->SetBottomMargin(bottom);
983 fhQA[kCutAcceptKinkDaughters][0]->SetStats(kFALSE);
984 fhQA[kCutAcceptKinkDaughters][0]->Draw();
985 fhQA[kCutAcceptKinkDaughters][1]->Draw("same");
986
987 canvas4->SaveAs(Form("%s.eps", canvas4->GetName()));
988 canvas4->SaveAs(Form("%s.ps", canvas4->GetName()));
989}
990//__________________________________________________________________________________
107a3100 991void AliCFTrackIsPrimaryCuts::AddQAHistograms(TList *qaList) {
563113d0 992 //
993 // saves the histograms in a TList
994 //
107a3100 995 DefineHistograms();
563113d0 996
997 qaList->Add(fhCutStatistics);
998 qaList->Add(fhCutCorrelation);
999
1000 for (Int_t j=0; j<kNStepQA; j++) {
1001 qaList->Add(fhDcaXYvsDcaZ[j]);
62037e79 1002 qaList->Add(fhDcaXYvsDcaZnorm[j]);
563113d0 1003 for(Int_t i=0; i<kNHist; i++)
62037e79 1004 qaList->Add(fhQA[i][j]);
563113d0 1005 }
1006}