// - require that the dca calculation doesn't fail
// - accept or not accept daughter tracks of kink decays
//
+// By default, the distance to 'vertex calculated from tracks' is used.
+// Optionally the SPD (tracklet based) or TPC (TPC only tracks based) vertex
+// can be used.
+// Note: the distance to the TPC-vertex is already stored in the ESD,
+// the distance to the SPD-vertex has to be re-calculated by propagating each
+// track while executing this cut.
+//
// The cut values for these cuts are set with the corresponding set functions.
// All cut classes provided by the correction framework are supposed to be
// added in the Analysis Framwork's class AliAnalysisFilter and applied by
#include <TBits.h>
#include <AliESDtrack.h>
+#include <AliAODTrack.h>
+#include <AliESDEvent.h>
+#include <AliAODEvent.h>
#include <AliLog.h>
#include "AliCFTrackIsPrimaryCuts.h"
//__________________________________________________________________________________
AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts() :
AliCFCutBase(),
+ fEvt(0x0),
+ fUseSPDvertex(0),
+ fUseTPCvertex(0),
fMinDCAToVertexXY(0),
fMinDCAToVertexZ(0),
fMaxDCAToVertexXY(0),
//__________________________________________________________________________________
AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts(Char_t* name, Char_t* title) :
AliCFCutBase(name,title),
+ fEvt(0x0),
+ fUseSPDvertex(0),
+ fUseTPCvertex(0),
fMinDCAToVertexXY(0),
fMinDCAToVertexZ(0),
fMaxDCAToVertexXY(0),
//__________________________________________________________________________________
AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts(const AliCFTrackIsPrimaryCuts& c) :
AliCFCutBase(c),
+ fEvt(c.fEvt),
+ fUseSPDvertex(c.fUseSPDvertex),
+ fUseTPCvertex(c.fUseTPCvertex),
fMinDCAToVertexXY(c.fMinDCAToVertexXY),
fMinDCAToVertexZ(c.fMinDCAToVertexZ),
fMaxDCAToVertexXY(c.fMaxDCAToVertexXY),
//
if (this != &c) {
AliCFCutBase::operator=(c) ;
+ fEvt = c.fEvt;
+ fUseSPDvertex = c.fUseSPDvertex;
+ fUseTPCvertex = c.fUseTPCvertex;
fMinDCAToVertexXY = c.fMinDCAToVertexXY;
fMinDCAToVertexZ = c.fMinDCAToVertexZ;
fMaxDCAToVertexXY = c.fMaxDCAToVertexXY;
fhBinLimSigmaDcaXY = c.fhBinLimSigmaDcaXY;
fhBinLimSigmaDcaZ = c.fhBinLimSigmaDcaZ;
+ for (Int_t j=0; j<6; j++) fDCA[j] = c.fDCA[j];
for (Int_t j=0; j<c.kNStepQA; j++){
if(c.fhDcaXYvsDcaZ[j]) fhDcaXYvsDcaZ[j] = (TH2F*)c.fhDcaXYvsDcaZ[j]->Clone();
- if(c.fhDcaXYvsDcaZnorm[j]) fhDcaXYvsDcaZnorm[j] = (TH2F*)c.fhDcaXYvsDcaZnorm[j]->Clone();
for (Int_t i=0; i<c.kNHist; i++){
if(c.fhQA[i][j]) fhQA[i][j] = (TH1F*)c.fhQA[i][j]->Clone();
}
for (Int_t j=0; j<kNStepQA; 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(fEvt) delete fEvt;
if(fBitmap) delete fBitmap;
if(fhBinLimNSigma) delete fhBinLimNSigma;
if(fhBinLimRequireSigma) delete fhBinLimRequireSigma;
//
// sets everything to zero
//
+ fUseSPDvertex = 0;
+ fUseTPCvertex = 0;
fMinDCAToVertexXY = 0;
fMinDCAToVertexZ = 0;
fMaxDCAToVertexXY = 0;
SetAcceptKinkDaughters();
SetAODType();
+ for (Int_t j=0; j<6; j++) fDCA[j] = 0.;
for (Int_t j=0; j<kNStepQA; j++) {
fhDcaXYvsDcaZ[j] = 0x0;
- fhDcaXYvsDcaZnorm[j] = 0x0;
for (Int_t i=0; i<kNHist; i++)
fhQA[i][j] = 0x0;
}
fBitmap=new TBits(0);
//set default bining for QA histograms
- SetHistogramBins(kCutNSigmaToVertex,500,0.,50.);
+ SetHistogramBins(kCutNSigmaToVertex,100,0.,10.);
SetHistogramBins(kCutRequireSigmaToVertex,5,-0.75,1.75);
SetHistogramBins(kCutAcceptKinkDaughters,5,-0.75,1.75);
SetHistogramBins(kDcaXY,500,-10.,10.);
if (fhCutStatistics) target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
+ for (Int_t j=0; j<6; j++) target.fDCA[j] = fDCA[j];
for (Int_t j=0; j<kNStepQA; j++){
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);
}
//__________________________________________________________________________________
+void AliCFTrackIsPrimaryCuts::SetRecEventInfo(const TObject* evt) {
+ //
+ // Sets pointer to event information (AliESDEvent or AliAODEvent)
+ //
+ if (!evt) {
+ AliError("Pointer to AliVEvent !");
+ return;
+ }
+ TString className(evt->ClassName());
+ if (! (className.CompareTo("AliESDEvent")==0 || className.CompareTo("AliAODEvent")==0)) {
+ AliError("argument must point to an AliESDEvent or AliAODEvent !");
+ return ;
+ }
+ fEvt = (AliVEvent*) evt;
+}
+//__________________________________________________________________________________
+void AliCFTrackIsPrimaryCuts::UseSPDvertex(Bool_t b) {
+ fUseSPDvertex = b;
+ if(fUseTPCvertex && fUseSPDvertex) {
+ fUseSPDvertex = kFALSE;
+ AliError("SPD and TPC vertex chosen. TPC vertex is preferred.");
+ }
+}
+//__________________________________________________________________________________
+void AliCFTrackIsPrimaryCuts::UseTPCvertex(Bool_t b) {
+ fUseTPCvertex = b;
+ if(fUseTPCvertex) fUseSPDvertex = kFALSE;
+}
+//__________________________________________________________________________________
+void AliCFTrackIsPrimaryCuts::GetDCA(AliESDtrack* esdTrack)
+{
+ if (!esdTrack) return;
+
+ Float_t b[2] = {0.,0.};
+ Float_t bCov[3] = {0.,0.,0.};
+ if(!fUseSPDvertex && !fUseTPCvertex) esdTrack->GetImpactParameters(b,bCov);
+ if( fUseTPCvertex) esdTrack->GetImpactParametersTPC(b,bCov);
+
+ if( fUseSPDvertex) {
+ if (!fEvt) return;
+ AliESDEvent * evt = 0x0 ;
+ evt = dynamic_cast<AliESDEvent*>(fEvt);
+ if (!evt) {
+ AliError("event not found");
+ return;
+ }
+ const AliESDVertex *vtx = evt->GetVertex();
+ const Double_t Bz = evt->GetMagneticField();
+ AliExternalTrackParam *cParam = 0;
+ Bool_t success = esdTrack->RelateToVertex(vtx, Bz, kVeryBig, cParam);
+ if (success) esdTrack->GetImpactParameters(b,bCov);
+ }
+
+ if (bCov[0]<=0 || bCov[2]<=0) {
+ bCov[0]=0; bCov[2]=0;
+ }
+ fDCA[0] = b[0]; // impact parameter xy
+ fDCA[1] = b[1]; // impact parameter z
+ fDCA[2] = TMath::Sqrt(bCov[0]); // resolution xy
+ fDCA[3] = TMath::Sqrt(bCov[2]); // resolution z
+
+ if (!fAbsDCAToVertex) {
+ if (fDCA[2] > 0) fDCA[0] = fDCA[0]/fDCA[2]; // normalised impact parameter xy
+ if (fDCA[3] > 0) fDCA[1] = fDCA[1]/fDCA[3]; // normalised impact parameter z
+ }
+
+ // get n_sigma
+ if(!fUseSPDvertex && !fUseTPCvertex)
+ fDCA[5] = AliESDtrackCuts::GetSigmaToVertex(esdTrack);
+
+ if(fUseTPCvertex) {
+ fDCA[5] = -1;
+ if (fDCA[2]==0 || fDCA[3]==0)
+ return;
+ fDCA[5] = 1000.;
+ Float_t d = TMath::Sqrt(TMath::Power(b[0]/fDCA[2],2) + TMath::Power(b[1]/fDCA[3],2));
+ if (TMath::Exp(-d * d / 2) < 1e-15)
+ return;
+ fDCA[5] = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
+ }
+ return;
+}
+//__________________________________________________________________________________
+void AliCFTrackIsPrimaryCuts::GetDCA(AliAODTrack* aodTrack)
+{
+ if (!aodTrack) return;
+
+ Double_t p[3] = {0.,0.,0.};
+ 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.};
+
+ aodTrack->XYZAtDCA(p); // position at DCA
+ aodTrack->GetCovarianceXYZPxPyPz(cov);
+
+
+ fDCA[5] = -1; // n_sigma
+ if (p[0]==-999. || p[1]==-999. || p[2]==-999.) {
+ AliError("dca info not available !");
+ fDCA[0] = -999.; // impact parameter xy
+ fDCA[1] = -999.; // impact parameter z
+ return;
+ }
+
+ AliAODEvent * evt = 0x0;
+ evt = dynamic_cast<AliAODEvent*>(fEvt);
+ if (!evt) return;
+
+ // primary vertex is the "best": tracks, SPD or TPC vertex
+ AliAODVertex * primaryVertex = evt->GetVertex(0);
+ // dca = track postion - primary vertex position
+ p[0] = p[0] - primaryVertex->GetX();
+ p[1] = p[1] - primaryVertex->GetY();
+ p[2] = p[2] - primaryVertex->GetZ();
+ // calculate dca in transverse plane
+ Float_t b[2] = {0.,0.};
+ b[0] = TMath::Sqrt(p[0]*p[0]+p[1]*p[1]);
+ b[1] = p[2];
+ // resolution
+ Double_t bCov[3] = {0.,0.,0.};
+ // how to calculate the resoultion in the transverse plane ?
+ bCov[0] = 0.; // to do: calculate cov in transverse plane
+ bCov[2] = 0.; // from cov in x and y, need to know correlation
+
+ if (bCov[0]<=0 || bCov[2]<=0) {
+ bCov[0]=0; bCov[2]=0;
+ }
+ fDCA[0] = b[0]; // impact parameter xy
+ fDCA[1] = b[1]; // impact parameter z
+ fDCA[2] = TMath::Sqrt(bCov[0]); // resolution xy
+ fDCA[3] = TMath::Sqrt(bCov[2]); // resolution z
+
+ if (!fAbsDCAToVertex) {
+ AliError("resolution of impact parameter not available, use absolute dca cut instead !");
+ if (fDCA[2] > 0) fDCA[0] = fDCA[0]/fDCA[2]; // normalised impact parameter xy
+ if (fDCA[3] > 0) fDCA[1] = fDCA[1]/fDCA[3]; // normalised impact parameter z
+ }
+
+ // get n_sigma
+ if (fDCA[2]==0 || fDCA[3]==0)
+ return;
+ fDCA[5] = 1000.;
+ Float_t d = TMath::Sqrt(TMath::Power(b[0]/fDCA[2],2) + TMath::Power(b[1]/fDCA[3],2));
+ if (TMath::Exp(-d * d / 2) < 1e-15)
+ return;
+ fDCA[5] = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
+
+ return;
+}
+//__________________________________________________________________________________
void AliCFTrackIsPrimaryCuts::SelectionBitMap(TObject* obj)
{
//
AliError("object must derived from AliVParticle !");
return;
}
+
+ AliESDtrack * esdTrack = dynamic_cast<AliESDtrack*>(obj);
+ AliAODTrack * aodTrack = dynamic_cast<AliAODTrack*>(obj);
- Bool_t isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
- Bool_t isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
+ if (!(esdTrack || aodTrack)) {
+ AliError("object must be an ESDtrack or an AODtrack !");
+ return;
+ }
- AliESDtrack * esdTrack = 0x0 ;
- AliAODTrack * aodTrack = 0x0 ;
- if (isESDTrack) esdTrack = dynamic_cast<AliESDtrack*>(obj);
- if (isAODTrack) aodTrack = dynamic_cast<AliAODTrack*>(obj);
+ Bool_t isESDTrack = kFALSE;
+ Bool_t isAODTrack = kFALSE;
+
+ if (esdTrack) isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
+ if (aodTrack) isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
// get the track to vertex parameter for ESD track
- Float_t nSigmaToVertex = 0.;
- if (isESDTrack) nSigmaToVertex = AliESDtrackCuts::GetSigmaToVertex(esdTrack);
+ if (isESDTrack) GetDCA(esdTrack);
+ if (isAODTrack) GetDCA(aodTrack);
+
+ // check whether dca info is filled
+ Bool_t dcaInfo = 0;
+ if (fDCA[0]>-990. && fDCA[1]>-990.) dcaInfo = 1;
+
+ Float_t bxy = 0, bz = 0;
+ bxy = TMath::Abs(fDCA[0]);
+ bz = TMath::Abs(fDCA[1]);
- Float_t b[2];
- Float_t bRes[2];
- Float_t bCov[3];
Float_t b2Dmin = 0, b2Dmax = 0;
- if (isESDTrack) {
- esdTrack->GetImpactParameters(b,bCov);
- if (bCov[0]<=0 || bCov[2]<=0) {
-// // // AliDebugClass(1, "Estimated b resolution lower or equal zero!");
- bCov[0]=0; bCov[2]=0;
- }
- b[0] = TMath::Abs(b[0]);
- b[1] = TMath::Abs(b[1]);
- bRes[0] = TMath::Sqrt(bCov[0]);
- bRes[1] = TMath::Sqrt(bCov[2]);
- if (!fAbsDCAToVertex) {
- if (bRes[0] > 0) b[0] = b[0]/bRes[0];
-// // // else AliDebugClass(1, "Estimated b resolution equal zero!");
- if (bRes[1] > 0) b[1] = b[1]/bRes[1];
-// // // else AliDebugClass(1, "Estimated b resolution equal zero!");
- }
- if (fMinDCAToVertexXY>0 && fMinDCAToVertexZ>0)
- b2Dmin = b[0]*b[0]/fMinDCAToVertexXY/fMinDCAToVertexXY + b[1]*b[1]/fMinDCAToVertexZ/fMinDCAToVertexZ;
- if (fMaxDCAToVertexXY>0 && fMaxDCAToVertexZ>0)
- b2Dmax = b[0]*b[0]/fMaxDCAToVertexXY/fMaxDCAToVertexXY + b[1]*b[1]/fMaxDCAToVertexZ/fMaxDCAToVertexZ;
- }
+ if (fMinDCAToVertexXY>0 && fMinDCAToVertexZ>0)
+ b2Dmin = fDCA[0]*fDCA[0]/fMinDCAToVertexXY/fMinDCAToVertexXY + fDCA[1]*fDCA[1]/fMinDCAToVertexZ/fMinDCAToVertexZ;
+ if (fMaxDCAToVertexXY>0 && fMaxDCAToVertexZ>0)
+ b2Dmax = fDCA[0]*fDCA[0]/fMaxDCAToVertexXY/fMaxDCAToVertexXY + fDCA[1]*fDCA[1]/fMaxDCAToVertexZ/fMaxDCAToVertexZ;
+
// fill the bitmap
Int_t iCutBit = 0;
- if (isESDTrack) {
- if (fDCAToVertex2D || (!fDCAToVertex2D && b[0] >= fMinDCAToVertexXY && b[0] <= fMaxDCAToVertexXY)) {
- fBitmap->SetBitNumber(iCutBit,kTRUE);
- }
- }
- else fBitmap->SetBitNumber(iCutBit,kTRUE);
-
+ if (!dcaInfo || fDCAToVertex2D || (!fDCAToVertex2D && bxy >= fMinDCAToVertexXY && bxy <= fMaxDCAToVertexXY))
+ fBitmap->SetBitNumber(iCutBit,kTRUE);
iCutBit++;
- if (isESDTrack) {
- if (fDCAToVertex2D || (!fDCAToVertex2D && b[1] >= fMinDCAToVertexZ && b[1] <= fMaxDCAToVertexZ)) {
- fBitmap->SetBitNumber(iCutBit,kTRUE);
- }
- }
- else fBitmap->SetBitNumber(iCutBit,kTRUE);
-
+ if (!dcaInfo || fDCAToVertex2D || (!fDCAToVertex2D && bz >= fMinDCAToVertexZ && bz <= fMaxDCAToVertexZ))
+ fBitmap->SetBitNumber(iCutBit,kTRUE);
iCutBit++;
- if (isESDTrack) {
- if (!fDCAToVertex2D || (fDCAToVertex2D && b2Dmin > 1 && b2Dmax < 1)) {
+ if (!dcaInfo || !fDCAToVertex2D || (fDCAToVertex2D && TMath::Sqrt(b2Dmin) > 1 && TMath::Sqrt(b2Dmax) < 1))
fBitmap->SetBitNumber(iCutBit,kTRUE);
- }
- }
- else fBitmap->SetBitNumber(iCutBit,kTRUE);
-
iCutBit++;
- if (isESDTrack) {
- if (nSigmaToVertex >= fNSigmaToVertexMin && nSigmaToVertex <= fNSigmaToVertexMax) {
+ if (!dcaInfo || (fDCA[5] >= fNSigmaToVertexMin && fDCA[5] <= fNSigmaToVertexMax))
fBitmap->SetBitNumber(iCutBit,kTRUE);
- }
- }
- else fBitmap->SetBitNumber(iCutBit,kTRUE);
-
iCutBit++;
- if (isESDTrack) {
- if (bRes[0] < fSigmaDCAxy) {
+ if (!dcaInfo || fDCA[2] < fSigmaDCAxy)
fBitmap->SetBitNumber(iCutBit,kTRUE);
- }
- }
- else fBitmap->SetBitNumber(iCutBit,kTRUE);
-
iCutBit++;
- if (isESDTrack) {
- if (bRes[1] < fSigmaDCAz) {
+ if (!dcaInfo || fDCA[3] < fSigmaDCAz)
fBitmap->SetBitNumber(iCutBit,kTRUE);
- }
- }
- else fBitmap->SetBitNumber(iCutBit,kTRUE);
-
iCutBit++;
- if (isESDTrack) {
- if (!fRequireSigmaToVertex || (nSigmaToVertex>=0 && fRequireSigmaToVertex)) {
+ if (!dcaInfo || !fRequireSigmaToVertex || (fDCA[5]>=0 && fRequireSigmaToVertex))
fBitmap->SetBitNumber(iCutBit,kTRUE);
- }
- }
- else fBitmap->SetBitNumber(iCutBit,kTRUE);
-
iCutBit++;
- if (esdTrack) {
- if (fAcceptKinkDaughters || (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)<=0)) {
+ if (!dcaInfo || fAcceptKinkDaughters || (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)<=0))
fBitmap->SetBitNumber(iCutBit,kTRUE);
- }
- }
- else fBitmap->SetBitNumber(iCutBit,kTRUE);
-
iCutBit++;
-
+
if (isAODTrack) {
if (fAODType==AliAODTrack::kUndef || fAODType == aodTrack->GetType()) {
fBitmap->SetBitNumber(iCutBit,kTRUE);
}
}
else fBitmap->SetBitNumber(iCutBit,kTRUE);
-
+
return;
}
//__________________________________________________________________________________
break;
}
}
+
if (!isSelected) return kFALSE ;
if (fIsQAOn) FillHistograms(obj,1);
return kTRUE;
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-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);
fhDcaXYvsDcaZ[i]->SetXTitle("impact par. d_{z}");
fhDcaXYvsDcaZ[i]->SetYTitle("impact par. d_{xy}");
- fhDcaXYvsDcaZnorm[i]->SetXTitle("norm. impact par. d_{z} / #sigma_{z}");
- fhDcaXYvsDcaZnorm[i]->SetYTitle("norm. impact par. d_{xy} / #sigma_{xy}");
fhQA[kCutNSigmaToVertex][i]->SetXTitle("n #sigma to vertex");
fhQA[kCutRequireSigmaToVertex][i]->SetXTitle("require #sigma to vertex");
// fill the QA histograms
//
- if (!obj) return;
-
Bool_t isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
Bool_t isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
// f = 1: fill histograms after cuts
// get the track to vertex parameter for ESD track
- Float_t nSigmaToVertex = 0.;
- if (isESDTrack) nSigmaToVertex = AliESDtrackCuts::GetSigmaToVertex(esdTrack);
if (esdTrack) {
- Float_t b[2];
- Float_t bRes[2];
- Float_t bCov[3];
- esdTrack->GetImpactParameters(b,bCov);
- if (bCov[0]<=0 || bCov[2]<=0) {
- AliDebug(1, "Estimated b resolution lower or equal zero!");
- bCov[0]=0; bCov[2]=0;
- }
- bRes[0] = TMath::Sqrt(bCov[0]);
- bRes[1] = TMath::Sqrt(bCov[2]);
-
- fhQA[kDcaZ][f]->Fill(b[1]);
- fhQA[kDcaXY][f]->Fill(b[0]);
- fhDcaXYvsDcaZ[f]->Fill(b[1],b[0]);
- fhQA[kSigmaDcaXY][f]->Fill(bRes[0]);
- fhQA[kSigmaDcaZ][f]->Fill(bRes[1]);
-
- if (bRes[0]!=0 && bRes[1]!=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]);
- }
- fhQA[kCutNSigmaToVertex][f]->Fill(nSigmaToVertex);
- if (nSigmaToVertex<0 && fRequireSigmaToVertex) fhQA[kCutRequireSigmaToVertex][f]->Fill(0.);
- if (!(nSigmaToVertex<0 && fRequireSigmaToVertex)) fhQA[kCutRequireSigmaToVertex][f]->Fill(1.);
-
- if (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0) fhQA[kCutAcceptKinkDaughters][f]->Fill(0.);
- if (!(!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)) fhQA[kCutAcceptKinkDaughters][f]->Fill(0.);
+ fhQA[kDcaZ][f]->Fill(fDCA[1]);
+ fhQA[kDcaXY][f]->Fill(fDCA[0]);
+ fhDcaXYvsDcaZ[f]->Fill(fDCA[1],fDCA[0]);
+ fhQA[kSigmaDcaXY][f]->Fill(fDCA[2]);
+ fhQA[kSigmaDcaZ][f]->Fill(fDCA[3]);
+// // // // // // // delete histograms
+ fhQA[kDcaZnorm][f]->Fill(fDCA[1]);
+ fhQA[kDcaXYnorm][f]->Fill(fDCA[0]);
+
+ fhQA[kCutNSigmaToVertex][f]->Fill(fDCA[5]);
+ if (fDCA[5]<0 && fRequireSigmaToVertex)
+ fhQA[kCutRequireSigmaToVertex][f]->Fill(0.);
+ else
+ fhQA[kCutRequireSigmaToVertex][f]->Fill(1.);
+
+ if (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
+ fhQA[kCutAcceptKinkDaughters][f]->Fill(0.);
+ else
+ fhQA[kCutAcceptKinkDaughters][f]->Fill(1.);
}
-
+
// fill cut statistics and cut correlation histograms with information from the bitmap
if (f) return;
gDirectory->cd("after_cuts");
fhDcaXYvsDcaZ[j] ->Write();
- fhDcaXYvsDcaZnorm[j]->Write();
for(Int_t i=0; i<kNHist; i++) fhQA[i][j]->Write();
// -----
- TCanvas* canvas3 = new TCanvas("Track_QA_Primary_3", "Track QA Primary 3", 800, 800);
- canvas3->Divide(2, 2);
+ TCanvas* canvas3 = new TCanvas("Track_QA_Primary_3", "Track QA Primary 3", 800, 400);
+ canvas3->Divide(2, 1);
canvas3->cd(1);
gPad->SetRightMargin(right);
fhQA[kDcaZnorm][0]->Draw();
fhQA[kDcaZnorm][1]->Draw("same");
- canvas3->cd(3);
-// fhDXYvsDZ[0]->SetStats(kFALSE);
- gPad->SetLogz();
- gPad->SetLeftMargin(bottom);
- gPad->SetTopMargin(0.1);
- gPad->SetBottomMargin(bottom);
- gPad->SetRightMargin(0.2);
- fhDcaXYvsDcaZnorm[0]->Draw("COLZ");
-
- canvas3->cd(4);
-// fhDXYvsDZ[1]->SetStats(kFALSE);
- gPad->SetLogz();
- gPad->SetLeftMargin(bottom);
- gPad->SetTopMargin(0.1);
- gPad->SetBottomMargin(bottom);
- gPad->SetRightMargin(0.2);
- fhDcaXYvsDcaZnorm[1]->Draw("COLZ");
-
canvas3->SaveAs(Form("%s.eps", canvas3->GetName()));
canvas3->SaveAs(Form("%s.ps", canvas3->GetName()));
for (Int_t j=0; j<kNStepQA; j++) {
qaList->Add(fhDcaXYvsDcaZ[j]);
- qaList->Add(fhDcaXYvsDcaZnorm[j]);
for(Int_t i=0; i<kNHist; i++)
qaList->Add(fhQA[i][j]);
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff