#include <TCanvas.h>
#include <TDirectory.h>
-#include <TBits.h>
#include <TH2.h>
+#include <TBits.h>
+
#include <AliESDtrack.h>
#include <AliLog.h>
#include "AliCFTrackIsPrimaryCuts.h"
//__________________________________________________________________________________
AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts() :
AliCFCutBase(),
+ fNSigmaToVertex(0),
fNSigmaToVertexMax(0),
fRequireSigmaToVertex(0),
fAcceptKinkDaughters(0),
//
// Default constructor
//
- fBitmap=new TBits(0);
Initialise();
}
//__________________________________________________________________________________
AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts(Char_t* name, Char_t* title) :
AliCFCutBase(name,title),
+ fNSigmaToVertex(0),
fNSigmaToVertexMax(0),
fRequireSigmaToVertex(0),
fAcceptKinkDaughters(0),
//
// Constructor
//
- fBitmap=new TBits(0);
Initialise();
}
//__________________________________________________________________________________
AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts(const AliCFTrackIsPrimaryCuts& c) :
AliCFCutBase(c),
+ fNSigmaToVertex(c.fNSigmaToVertex),
fNSigmaToVertexMax(c.fNSigmaToVertexMax),
fRequireSigmaToVertex(c.fRequireSigmaToVertex),
fAcceptKinkDaughters(c.fAcceptKinkDaughters),
//
if (this != &c) {
AliCFCutBase::operator=(c) ;
+ fNSigmaToVertex = c.fNSigmaToVertex ;
fNSigmaToVertexMax = c.fNSigmaToVertexMax ;
fRequireSigmaToVertex = c.fRequireSigmaToVertex ;
fAcceptKinkDaughters = c.fAcceptKinkDaughters ;
fhBinLimDcaZ = c.fhBinLimDcaZ;
fhBinLimDcaXYnorm = c.fhBinLimDcaXYnorm;
fhBinLimDcaZnorm = c.fhBinLimDcaZnorm;
-
+
for (Int_t i=0; i<c.kNHist; i++){
for (Int_t j=0; j<c.kNStepQA; j++){
if(c.fhQA[i][j]) fhQA[i][j] = (TH1F*)c.fhQA[i][j]->Clone();
if(c.fhDcaXYvsDcaZnorm[j]) fhDcaXYvsDcaZnorm[j] = (TH2F*)c.fhDcaXYvsDcaZnorm[j]->Clone();
}
}
-
((AliCFTrackIsPrimaryCuts &) c).Copy(*this);
}
return *this;
if (fhCutCorrelation) delete fhCutCorrelation;
for (Int_t j=0; j<kNStepQA; j++){
- for (Int_t i=0; i<kNHist; i++){
- if(fhQA[i][j]) delete fhQA[i][j];
- }
- if(fhDcaXYvsDcaZ[j]) delete fhDcaXYvsDcaZ[j];
- if(fhDcaXYvsDcaZnorm[j]) delete fhDcaXYvsDcaZnorm[j];
+ if(fhDcaXYvsDcaZ[j]) delete fhDcaXYvsDcaZ[j];
+ if(fhDcaXYvsDcaZnorm[j]) delete fhDcaXYvsDcaZnorm[j];
+ for (Int_t i=0; i<kNHist; i++)
+ if(fhQA[i][j]) delete fhQA[i][j];
}
-
- if (fBitmap) delete fBitmap;
-
- if(fhBinLimNSigma) delete fhBinLimNSigma;
- if(fhBinLimRequireSigma) delete fhBinLimRequireSigma;
- if(fhBinLimAcceptKink) delete fhBinLimAcceptKink;
- if(fhBinLimDcaXY) delete fhBinLimDcaXY;
- if(fhBinLimDcaZ) delete fhBinLimDcaZ;
- if(fhBinLimDcaXYnorm) delete fhBinLimDcaXYnorm;
- if(fhBinLimDcaZnorm) delete fhBinLimDcaZnorm;
+ if(fBitmap) delete fBitmap;
+ if(fhBinLimNSigma) delete fhBinLimNSigma;
+ if(fhBinLimRequireSigma) delete fhBinLimRequireSigma;
+ if(fhBinLimAcceptKink) delete fhBinLimAcceptKink;
+ if(fhBinLimDcaXY) delete fhBinLimDcaXY;
+ if(fhBinLimDcaZ) delete fhBinLimDcaZ;
+ if(fhBinLimDcaXYnorm) delete fhBinLimDcaXYnorm;
+ if(fhBinLimDcaZnorm) delete fhBinLimDcaZnorm;
}
//__________________________________________________________________________________
void AliCFTrackIsPrimaryCuts::Initialise()
//
// sets everything to zero
//
+ fNSigmaToVertex = 0;
fNSigmaToVertexMax = 0;
fRequireSigmaToVertex = 0;
fAcceptKinkDaughters = 0;
SetRequireSigmaToVertex();
for (Int_t j=0; j<kNStepQA; j++) {
- for (Int_t i=0; i<kNHist; i++){
- fhQA[i][j] = 0x0;
- }
fhDcaXYvsDcaZ[j] = 0x0;
fhDcaXYvsDcaZnorm[j] = 0x0;
+ for (Int_t i=0; i<kNHist; i++)
+ fhQA[i][j] = 0x0;
}
fhCutStatistics = 0;
fhCutCorrelation = 0;
-
+ fBitmap=new TBits(0);
+
//set default bining for QA histograms
- SetHistogramBins(kCutNSigmaToVertex,500,0,50);
- SetHistogramBins(kCutRequireSigmaToVertex,2,-0.5,1.5);
- SetHistogramBins(kCutAcceptKinkDaughters,2,-0.5,1.5);
- SetHistogramBins(kDcaXY,500,-10,10);
- SetHistogramBins(kDcaZ,500,-10,10);
- SetHistogramBins(kDcaXYnorm,500,-10,10);
- SetHistogramBins(kDcaZnorm,500,-10,10);
+ SetHistogramBins(kCutNSigmaToVertex,500,0.,50.);
+ SetHistogramBins(kCutRequireSigmaToVertex,5,-0.75,1.75);
+ SetHistogramBins(kCutAcceptKinkDaughters,5,-0.75,1.75);
+ SetHistogramBins(kDcaXY,500,-10.,10.);
+ SetHistogramBins(kDcaZ,500,-10.,10.);
+ SetHistogramBins(kDcaXYnorm,500,-10.,10.);
+ SetHistogramBins(kDcaZnorm,500,-10.,10.);
}
//__________________________________________________________________________________
void AliCFTrackIsPrimaryCuts::Copy(TObject &c) const
if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
for (Int_t j=0; j<kNStepQA; j++){
- for (Int_t i=0; i<kNHist; i++){
- if(fhQA[i][j]) target.fhQA[i][j] = (TH1F*)fhQA[i][j]->Clone();
-
- }
if(fhDcaXYvsDcaZ[j]) target.fhDcaXYvsDcaZ[j] = (TH2F*)fhDcaXYvsDcaZ[j]->Clone();
if(fhDcaXYvsDcaZnorm[j]) target.fhDcaXYvsDcaZnorm[j] = (TH2F*)fhDcaXYvsDcaZnorm[j]->Clone();
+ for (Int_t i=0; i<kNHist; i++)
+ if(fhQA[i][j]) target.fhQA[i][j] = (TH1F*)fhQA[i][j]->Clone();
}
-
TNamed::Copy(c);
}
//____________________________________________________________________
-Float_t AliCFTrackIsPrimaryCuts::GetSigmaToVertex(AliESDtrack* esdTrack) const
+void AliCFTrackIsPrimaryCuts::GetSigmaToVertex(AliESDtrack* esdTrack)
{
//
// Calculates the number of sigma to the vertex.
// It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-x**2)/2)
// Can this be expressed in a different way?
- if (bRes[0] == 0 || bRes[1] ==0)
- return -1;
+ if (bRes[0] == 0 || bRes[1] ==0) {
+ fNSigmaToVertex = -1;
+ return;
+ }
Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
// stupid rounding problem screws up everything:
// if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
- if (TMath::Exp(-d * d / 2) < 1e-10)
- return 1000;
+ if (TMath::Exp(-d * d / 2) < 1e-10) {
+ fNSigmaToVertex = 1000;
+ return;
+ }
d = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
- return d;
+ fNSigmaToVertex = d;
+ return;
}
//__________________________________________________________________________________
-void AliCFTrackIsPrimaryCuts::GetBitMap(TObject* obj, TBits *bitmap) {
- //
- // retrieve the pointer to the bitmap
- //
- bitmap = SelectionBitMap(obj);
-}
-//__________________________________________________________________________________
-TBits* AliCFTrackIsPrimaryCuts::SelectionBitMap(TObject* obj)
+void AliCFTrackIsPrimaryCuts::SelectionBitMap(TObject* obj)
{
//
// test if the track passes the single cuts
// bitmap stores the decision of each single cut
for(Int_t i=0; i<kNCuts; i++)fBitmap->SetBitNumber(i,kFALSE);
- // cast TObject into ESDtrack
+ // check TObject and cast into ESDtrack
+ if (!obj) return;
+ if (!obj->InheritsFrom("AliESDtrack")) AliError("object must derived from AliESDtrack !");
AliESDtrack* esdTrack = dynamic_cast<AliESDtrack *>(obj);
- if ( !esdTrack ) return fBitmap ;
-
-
- for(Int_t i=0; i<kNCuts; i++)fBitmap->SetBitNumber(i,kTRUE);
+ if ( !esdTrack ) return;
// get the track to vertex parameter
- Float_t nSigmaToVertex = GetSigmaToVertex(esdTrack);
+ GetSigmaToVertex(esdTrack);
// fill the bitmap
Int_t iCutBit = 0;
- if (nSigmaToVertex > fNSigmaToVertexMax)
- fBitmap->SetBitNumber(iCutBit,kFALSE);
+ if (fNSigmaToVertex <= fNSigmaToVertexMax)
+ fBitmap->SetBitNumber(iCutBit,kTRUE);
iCutBit++;
- if (nSigmaToVertex<0 && fRequireSigmaToVertex)
- fBitmap->SetBitNumber(iCutBit,kFALSE);
+ if (!fRequireSigmaToVertex || (fNSigmaToVertex>=0 && fRequireSigmaToVertex))
+ fBitmap->SetBitNumber(iCutBit,kTRUE);
iCutBit++;
- if (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
- fBitmap->SetBitNumber(iCutBit,kFALSE);
+ if (fAcceptKinkDaughters || (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)<=0))
+ fBitmap->SetBitNumber(iCutBit,kTRUE);
- return fBitmap;
+ return;
}
//__________________________________________________________________________________
Bool_t AliCFTrackIsPrimaryCuts::IsSelected(TObject* obj) {
//
// loops over decisions of single cuts and returns if the track is accepted
//
- TBits* bitmap = SelectionBitMap(obj);
+ SelectionBitMap(obj);
+ if (fIsQAOn) FillHistograms(obj,0);
Bool_t isSelected = kTRUE;
- for (UInt_t icut=0; icut<bitmap->GetNbits();icut++)
- if(!bitmap->TestBitNumber(icut)) isSelected = kFALSE;
-
- return isSelected;
-}
-//__________________________________________________________________________________
-void AliCFTrackIsPrimaryCuts::Init() {
- //
- // initialises all histograms and the TList which holds the histograms
- //
- if(fIsQAOn)
- DefineHistograms();
+ for (UInt_t icut=0; icut<fBitmap->GetNbits();icut++) {
+ if(!fBitmap->TestBitNumber(icut)) {
+ isSelected = kFALSE;
+ break;
+ }
+ }
+ if (!isSelected) return kFALSE ;
+ if (fIsQAOn) FillHistograms(obj,1);
+ return kTRUE;
}
//__________________________________________________________________________________
void AliCFTrackIsPrimaryCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t *bins)
switch(index){
case kCutNSigmaToVertex:
- fhNBinsNSigma=nbins;
+ fhNBinsNSigma=nbins+1;
fhBinLimNSigma=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimNSigma[i]=bins[i];
break;
case kCutRequireSigmaToVertex:
- fhNBinsRequireSigma=nbins;
+ fhNBinsRequireSigma=nbins+1;
fhBinLimRequireSigma=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimRequireSigma[i]=bins[i];
break;
case kCutAcceptKinkDaughters:
- fhNBinsAcceptKink=nbins;
+ fhNBinsAcceptKink=nbins+1;
fhBinLimAcceptKink=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimAcceptKink[i]=bins[i];
break;
case kDcaXY:
- fhNBinsDcaXY=nbins;
+ fhNBinsDcaXY=nbins+1;
fhBinLimDcaXY=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXY[i]=bins[i];
break;
-
+
case kDcaZ:
- fhNBinsDcaZ=nbins;
+ fhNBinsDcaZ=nbins+1;
fhBinLimDcaZ=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZ[i]=bins[i];
break;
-
+
case kDcaXYnorm:
- fhNBinsDcaXYnorm=nbins;
+ fhNBinsDcaXYnorm=nbins+1;
fhBinLimDcaXYnorm=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXYnorm[i]=bins[i];
break;
-
+
case kDcaZnorm:
- fhNBinsDcaZnorm=nbins;
+ fhNBinsDcaZnorm=nbins+1;
fhBinLimDcaZnorm=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZnorm[i]=bins[i];
break;
//
// fixed bin size
//
- if(!fIsQAOn) return;
-
switch(index){
case kCutNSigmaToVertex:
- fhNBinsNSigma=nbins;
+ fhNBinsNSigma=nbins+1;
fhBinLimNSigma=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimNSigma[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
break;
case kCutRequireSigmaToVertex:
- fhNBinsRequireSigma=nbins;
+ fhNBinsRequireSigma=nbins+1;
fhBinLimRequireSigma=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimRequireSigma[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
break;
case kCutAcceptKinkDaughters:
- fhNBinsAcceptKink=nbins;
+ fhNBinsAcceptKink=nbins+1;
fhBinLimAcceptKink=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimAcceptKink[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
break;
case kDcaXY:
- fhNBinsDcaXY=nbins;
+ fhNBinsDcaXY=nbins+1;
fhBinLimDcaXY=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXY[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
break;
-
+
case kDcaZ:
- fhNBinsDcaZ=nbins;
+ fhNBinsDcaZ=nbins+1;
fhBinLimDcaZ=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZ[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
break;
-
+
case kDcaXYnorm:
- fhNBinsDcaXYnorm=nbins;
+ fhNBinsDcaXYnorm=nbins+1;
fhBinLimDcaXYnorm=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXYnorm[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
break;
-
+
case kDcaZnorm:
- fhNBinsDcaZnorm=nbins;
+ fhNBinsDcaZnorm=nbins+1;
fhBinLimDcaZnorm=new Double_t[nbins+1];
for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZnorm[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
break;
//
// histograms for cut variables, cut statistics and cut correlations
//
-
Int_t color = 2;
// book cut statistics and cut correlation histograms
for (Int_t i=0; i<kNStepQA; i++) {
if (i==0) sprintf(str," ");
else sprintf(str,"_cut");
-
+
fhDcaXYvsDcaZ[i] = new TH2F(Form("%s_dcaXYvsDcaZ%s",GetName(),str),"",200,-10,10,200,-10,10);
fhDcaXYvsDcaZnorm[i] = new TH2F(Form("%s_dcaXYvsDcaZnorm%s",GetName(),str),"",200,-10,10,200,-10,10);
-
- fhQA[kCutNSigmaToVertex][i] = new TH1F(Form("%s_nSigmaToVertex%s",GetName(),str),"",fhNBinsNSigma,fhBinLimNSigma);
- fhQA[kCutRequireSigmaToVertex][i] = new TH1F(Form("%s_requireSigmaToVertex%s",GetName(),str),"",fhNBinsRequireSigma,fhBinLimRequireSigma);
- fhQA[kCutAcceptKinkDaughters][i] = new TH1F(Form("%s_acceptKinkDaughters%s",GetName(),str),"",fhNBinsAcceptKink,fhBinLimAcceptKink);
- fhQA[kDcaXY][i] = new TH1F(Form("%s_dcaXY%s",GetName(),str),"",fhNBinsDcaXY,fhBinLimDcaXY);
- fhQA[kDcaZ][i] = new TH1F(Form("%s_dcaZ%s",GetName(),str),"",fhNBinsDcaZ,fhBinLimDcaZ);
- fhQA[kDcaXYnorm][i] = new TH1F(Form("%s_dcaXYnorm%s",GetName(),str),"",fhNBinsDcaXYnorm,fhBinLimDcaXYnorm);
- fhQA[kDcaZnorm][i] = new TH1F(Form("%s_dcaZnorm%s",GetName(),str),"",fhNBinsDcaZnorm,fhBinLimDcaZnorm);
+ fhQA[kCutNSigmaToVertex][i] = new TH1F(Form("%s_nSigmaToVertex%s",GetName(),str),"",fhNBinsNSigma-1,fhBinLimNSigma);
+ fhQA[kCutRequireSigmaToVertex][i] = new TH1F(Form("%s_requireSigmaToVertex%s",GetName(),str),"",fhNBinsRequireSigma-1,fhBinLimRequireSigma);
+ fhQA[kCutAcceptKinkDaughters][i] = new TH1F(Form("%s_acceptKinkDaughters%s",GetName(),str),"",fhNBinsAcceptKink-1,fhBinLimAcceptKink);
+ fhQA[kDcaXY][i] = new TH1F(Form("%s_dcaXY%s",GetName(),str),"",fhNBinsDcaXY-1,fhBinLimDcaXY);
+ fhQA[kDcaZ][i] = new TH1F(Form("%s_dcaZ%s",GetName(),str),"",fhNBinsDcaZ-1,fhBinLimDcaZ);
+ fhQA[kDcaXYnorm][i] = new TH1F(Form("%s_dcaXYnorm%s",GetName(),str),"",fhNBinsDcaXYnorm-1,fhBinLimDcaXYnorm);
+ fhQA[kDcaZnorm][i] = new TH1F(Form("%s_dcaZnorm%s",GetName(),str),"",fhNBinsDcaZnorm-1,fhBinLimDcaZnorm);
fhDcaXYvsDcaZ[i]->SetXTitle("impact par. d_{z}");
fhDcaXYvsDcaZ[i]->SetYTitle("impact par. d_{xy}");
fhQA[kDcaXYnorm][i]->SetXTitle("norm. impact par. d_{xy} / #sigma_{xy}");
fhQA[kDcaZnorm][i]->SetXTitle("norm. impact par. d_{z} / #sigma_{z}");
}
-
for(Int_t i=0; i<kNHist; i++) fhQA[i][1]->SetLineColor(color);
-
}
//__________________________________________________________________________________
void AliCFTrackIsPrimaryCuts::FillHistograms(TObject* obj, Bool_t f)
//
// fill the QA histograms
//
- if(!fIsQAOn) return;
// cast TObject into ESDtrack
+ if (!obj) return;
AliESDtrack* esdTrack = dynamic_cast<AliESDtrack *>(obj);
if ( !esdTrack ) return;
- // index = 0: fill histograms before cuts
- // index = 1: fill histograms after cuts
- Int_t index = -1;
- index = ((f) ? 1 : 0);
+ // f = 0: fill histograms before cuts
+ // f = 1: fill histograms after cuts
Float_t b[2];
Float_t bRes[2];
bRes[0] = TMath::Sqrt(bCov[0]);
bRes[1] = TMath::Sqrt(bCov[2]);
- fhQA[kDcaZ][index]->Fill(b[1]);
- fhQA[kDcaXY][index]->Fill(b[0]);
- fhDcaXYvsDcaZ[index]->Fill(b[1],b[0]);
+ fhQA[kDcaZ][f]->Fill(b[1]);
+ fhQA[kDcaXY][f]->Fill(b[0]);
+ fhDcaXYvsDcaZ[f]->Fill(b[1],b[0]);
if (bRes[0]!=0 && bRes[1]!=0) {
- fhQA[kDcaZnorm][index]->Fill(b[1]/bRes[1]);
- fhQA[kDcaXYnorm][index]->Fill(b[0]/bRes[0]);
- fhDcaXYvsDcaZnorm[index]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
+ fhQA[kDcaZnorm][f]->Fill(b[1]/bRes[1]);
+ fhQA[kDcaXYnorm][f]->Fill(b[0]/bRes[0]);
+ fhDcaXYvsDcaZnorm[f]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
}
- // getting the track to vertex parameters
- Float_t nSigmaToVertex = GetSigmaToVertex(esdTrack);
-
- fhQA[kCutNSigmaToVertex][index]->Fill(nSigmaToVertex);
- if (nSigmaToVertex<0 && fRequireSigmaToVertex) fhQA[kCutRequireSigmaToVertex][index]->Fill(0.);
- if (!(nSigmaToVertex<0 && fRequireSigmaToVertex)) fhQA[kCutRequireSigmaToVertex][index]->Fill(1.);
+ fhQA[kCutNSigmaToVertex][f]->Fill(fNSigmaToVertex);
+ if (fNSigmaToVertex<0 && fRequireSigmaToVertex) fhQA[kCutRequireSigmaToVertex][f]->Fill(0.);
+ if (!(fNSigmaToVertex<0 && fRequireSigmaToVertex)) fhQA[kCutRequireSigmaToVertex][f]->Fill(1.);
- if (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0) fhQA[kCutAcceptKinkDaughters][index]->Fill(0.);
- if (!(!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)) fhQA[kCutAcceptKinkDaughters][index]->Fill(0.);
+ if (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0) fhQA[kCutAcceptKinkDaughters][f]->Fill(0.);
+ if (!(!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)) fhQA[kCutAcceptKinkDaughters][f]->Fill(0.);
// fill cut statistics and cut correlation histograms with information from the bitmap
if (f) return;
// Get the bitmap of the single cuts
if ( !obj ) return;
- TBits* bitmap = SelectionBitMap(obj);
+ SelectionBitMap(obj);
// Number of single cuts in this class
- UInt_t ncuts = bitmap->GetNbits();
+ UInt_t ncuts = fBitmap->GetNbits();
for(UInt_t bit=0; bit<ncuts;bit++) {
- if (!bitmap->TestBitNumber(bit)) {
+ if (!fBitmap->TestBitNumber(bit)) {
fhCutStatistics->Fill(bit+1);
for (UInt_t bit2=bit; bit2<ncuts;bit2++) {
- if (!bitmap->TestBitNumber(bit2))
+ if (!fBitmap->TestBitNumber(bit2))
fhCutCorrelation->Fill(bit+1,bit2+1);
}
}
canvas4->SaveAs(Form("%s.ps", canvas4->GetName()));
}
//__________________________________________________________________________________
-void AliCFTrackIsPrimaryCuts::AddQAHistograms(TList *qaList) const {
+void AliCFTrackIsPrimaryCuts::AddQAHistograms(TList *qaList) {
//
// saves the histograms in a TList
//
- if(!fIsQAOn) return;
+ DefineHistograms();
qaList->Add(fhCutStatistics);
qaList->Add(fhCutCorrelation);
for (Int_t j=0; j<kNStepQA; j++) {
qaList->Add(fhDcaXYvsDcaZ[j]);
- qaList->Add(fhDcaXYvsDcaZnorm[j]);
+ qaList->Add(fhDcaXYvsDcaZnorm[j]);
for(Int_t i=0; i<kNHist; i++)
- qaList->Add(fhQA[i][j]);
+ qaList->Add(fhQA[i][j]);
}
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff