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