fEvent(0x0),
fESD(0x0),
fVtx(0x0),
- fTrackCuts(0),
+ fTrackCuts(0x0),
+ fTrackCutsITSLoose(0x0),
+ fTrackCutsTPConly(0x0),
fTrackType(0),
fFilterMask(0),
fSigmaConstrainedMax(-1.),
fPtMax(100.),
fIsPbPb(0),
fCentClass(10),
- fNVariables(18),
+ fNVariables(23),
fVariables(0x0),
fAvgTrials(1),
fNEventAll(0),
fPtDCA2D(0x0),
fPtDCAZ(0x0),
fPtNClustersTPC(0x0),
+ fPtNClustersTPCIter1(0x0),
+ fPtNClustersTPCShared(0x0),
+ fPtNClustersTPCSharedFrac(0x0),
fPtNPointITS(0x0),
fPtChi2C(0x0),
fPtNSigmaToVertex(0x0),
fPtRelUncertainty1Pt(0x0),
+ fPtRelUncertainty1PtNClus(0x0),
+ fPtRelUncertainty1PtNClusIter1(0x0),
+ fPtRelUncertainty1PtChi2(0x0),
+ fPtRelUncertainty1PtChi2Iter1(0x0),
+ fPtRelUncertainty1PtPhi(0x0),
fPtUncertainty1Pt(0x0),
fPtChi2PerClusterTPC(0x0),
+ fPtChi2PerClusterTPCIter1(0x0),
fPtNCrossedRows(0x0),
fPtNCrossedRowsNClusF(0x0),
fPtNCrRNCrRNClusF(0x0),
+ fPtChi2Gold(0x0),
+ fPtChi2GGC(0x0),
+ fPtChi2GoldPhi(0x0),
+ fPtChi2GGCPhi(0x0),
+ fChi2GoldChi2GGC(0x0),
fPtSigmaY2(0x0),
fPtSigmaZ2(0x0),
fPtSigmaSnp2(0x0),
fSystTrackCuts(0x0),
fHistList(0)
{
- SetNVariables(18);
+ SetNVariables(23);
fPtBinEdges[0][0] = 10.;
fPtBinEdges[0][1] = 1.;
fPtBinEdges[1][0] = 20.;
fPtBinEdges[1][1] = 2.;
- fPtBinEdges[2][0] = 50.;
+ fPtBinEdges[2][0] = 100.;
fPtBinEdges[2][1] = 5.;
}
fEvent(0x0),
fESD(0x0),
fVtx(0x0),
- fTrackCuts(),
+ fTrackCuts(0x0),
+ fTrackCutsITSLoose(0x0),
+ fTrackCutsTPConly(0x0),
fTrackType(0),
fFilterMask(0),
fSigmaConstrainedMax(-1.),
fPtMax(100.),
fIsPbPb(0),
fCentClass(10),
- fNVariables(18),
+ fNVariables(23),
fVariables(0x0),
fAvgTrials(1),
fNEventAll(0),
fPtDCA2D(0x0),
fPtDCAZ(0x0),
fPtNClustersTPC(0x0),
+ fPtNClustersTPCIter1(0x0),
+ fPtNClustersTPCShared(0x0),
+ fPtNClustersTPCSharedFrac(0x0),
fPtNPointITS(0x0),
fPtChi2C(0x0),
fPtNSigmaToVertex(0x0),
fPtRelUncertainty1Pt(0x0),
+ fPtRelUncertainty1PtNClus(0x0),
+ fPtRelUncertainty1PtNClusIter1(0x0),
+ fPtRelUncertainty1PtChi2(0x0),
+ fPtRelUncertainty1PtChi2Iter1(0x0),
+ fPtRelUncertainty1PtPhi(0x0),
fPtUncertainty1Pt(0x0),
fPtChi2PerClusterTPC(0x0),
+ fPtChi2PerClusterTPCIter1(0x0),
fPtNCrossedRows(0x0),
fPtNCrossedRowsNClusF(0x0),
fPtNCrRNCrRNClusF(0x0),
+ fPtChi2Gold(0x0),
+ fPtChi2GGC(0x0),
+ fPtChi2GoldPhi(0x0),
+ fPtChi2GGCPhi(0x0),
+ fChi2GoldChi2GGC(0x0),
fPtSigmaY2(0x0),
fPtSigmaZ2(0x0),
fPtSigmaSnp2(0x0),
//
AliDebug(2,Form("AliPWG4HighPtTrackQA Calling Constructor"));
- SetNVariables(18);
+ SetNVariables(23);
fPtBinEdges[0][0] = 10.;
fPtBinEdges[0][1] = 1.;
fPtBinEdges[1][0] = 20.;
fPtBinEdges[1][1] = 2.;
- fPtBinEdges[2][0] = 50.;
+ fPtBinEdges[2][0] = 100.;
fPtBinEdges[2][1] = 5.;
// Input slot #0 works with a TChain ESD
fHistList->SetOwner(kTRUE);
Float_t fgkPtMin = 0.;
- Float_t fgkPtMax = fPtMax;
-
- // Float_t ptBinEdges[2][2];
- // ptBinEdges[0][0] = 10.;
- // ptBinEdges[0][1] = 1.;
- // ptBinEdges[1][0] = 20.;
- // ptBinEdges[1][1] = 2.;
- // Float_t binWidth3 = 5.;
- // if(fPtMax>100.) {
- // ptBinEdges[0][0] = 100.;
- // ptBinEdges[0][1] = 5.;
- // ptBinEdges[1][0] = 300.;
- // ptBinEdges[1][1] = 10.;
- // binWidth3 = 20.;
- // }
+ // Float_t fgkPtMax = fPtMax;
//fPtBinEdges[region][0] = ptmax of region ; fPtBinEdges[region][1] = binWidth of region
const Float_t ptmin1 = fgkPtMin;
const Float_t ptmin2 = ptmax1 ;
const Float_t ptmax2 = fPtBinEdges[1][0];
const Float_t ptmin3 = ptmax2 ;
- const Float_t ptmax3 = fgkPtMax;
+ const Float_t ptmax3 = fPtBinEdges[2][0];//fgkPtMax;
const Int_t nbin11 = (int)((ptmax1-ptmin1)/fPtBinEdges[0][1]);
const Int_t nbin12 = (int)((ptmax2-ptmin2)/fPtBinEdges[1][1])+nbin11;
- const Int_t nbin13 = (int)((ptmax3-ptmin3)/fPtBinEdges[2][2])+nbin12;
+ const Int_t nbin13 = (int)((ptmax3-ptmin3)/fPtBinEdges[2][1])+nbin12;
Int_t fgkNPtBins=nbin13;
//Create array with low edges of each bin
Double_t *binsPt=new Double_t[fgkNPtBins+1];
Int_t fgkNDCA2DBins=80;
Float_t fgkDCA2DMin = -0.2;
Float_t fgkDCA2DMax = 0.2;
- if(fTrackType==1 || fTrackType==2 || fTrackType==4) {
+ if(fTrackType==1 || fTrackType==2 || fTrackType==4 || fTrackType==7) {
fgkDCA2DMin = -2.;
fgkDCA2DMax = 2.;
}
Double_t *binsNPointITS=new Double_t[fgkNNPointITSBins+1];
for(Int_t i=0; i<=fgkNNPointITSBins; i++) binsNPointITS[i]=(Double_t)fgkNPointITSMin + (fgkNPointITSMax-fgkNPointITSMin)/fgkNNPointITSBins*(Double_t)i ;
- Int_t fgkNNSigmaToVertexBins=40;
+ Int_t fgkNNSigmaToVertexBins=9;
Float_t fgkNSigmaToVertexMin = 0.;
- Float_t fgkNSigmaToVertexMax = 8.;
+ Float_t fgkNSigmaToVertexMax = 9.;
Double_t *binsNSigmaToVertex=new Double_t[fgkNNSigmaToVertexBins+1];
for(Int_t i=0; i<=fgkNNSigmaToVertexBins; i++) binsNSigmaToVertex[i]=(Double_t)fgkNSigmaToVertexMin + (fgkNSigmaToVertexMax-fgkNSigmaToVertexMin)/fgkNNSigmaToVertexBins*(Double_t)i ;
- Int_t fgkNChi2CBins=20;
- Float_t fgkChi2CMin = 0.;
- Float_t fgkChi2CMax = 100.;
+ Int_t fgkNChi2CBins=10;
+ // Float_t fgkChi2CMin = 0.;
+ // Float_t fgkChi2CMax = 100.; //10 sigma
Double_t *binsChi2C=new Double_t[fgkNChi2CBins+1];
- for(Int_t i=0; i<=fgkNChi2CBins; i++) binsChi2C[i]=(Double_t)fgkChi2CMin + (fgkChi2CMax-fgkChi2CMin)/fgkNChi2CBins*(Double_t)i ;
+ for(Int_t i=0; i<=fgkNChi2CBins; i++) binsChi2C[i] = (Double_t)i * (Double_t)i;
- Int_t fgkNRel1PtUncertaintyBins=30;
+ Int_t fgkNRel1PtUncertaintyBins=50;
Float_t fgkRel1PtUncertaintyMin = 0.;
- Float_t fgkRel1PtUncertaintyMax = 0.3;
- if(fTrackType==1 || fTrackType==2 || fTrackType==4)
- fgkRel1PtUncertaintyMax = 0.5;
+ Float_t fgkRel1PtUncertaintyMax = 1.;
+ if(fTrackType!=0 && fTrackType!=3) {
+ fgkNRel1PtUncertaintyBins = 50;
+ fgkRel1PtUncertaintyMax = 1.;
+ }
Double_t *binsRel1PtUncertainty=new Double_t[fgkNRel1PtUncertaintyBins+1];
for(Int_t i=0; i<=fgkNRel1PtUncertaintyBins; i++) binsRel1PtUncertainty[i]=(Double_t)fgkRel1PtUncertaintyMin + (fgkRel1PtUncertaintyMax-fgkRel1PtUncertaintyMin)/fgkNRel1PtUncertaintyBins*(Double_t)i ;
fPtNClustersTPC = new TH2F("fPtNClustersTPC","fPtNClustersTPC",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
fHistList->Add(fPtNClustersTPC);
+
+ fPtNClustersTPCIter1 = new TH2F("fPtNClustersTPCIter1","fPtNClustersTPCIter1",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
+ fHistList->Add(fPtNClustersTPCIter1);
+
+ fPtNClustersTPCShared = new TH2F("fPtNClustersTPCShared","fPtNClustersTPCShared",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
+ fHistList->Add(fPtNClustersTPCShared);
+
+ fPtNClustersTPCSharedFrac = new TH2F("fPtNClustersTPCSharedFrac","fPtNClustersTPCSharedFrac",fgkNPtBins,binsPt,fgkNSigma1Pt2Bins,binsSigma1Pt2);
+ fHistList->Add(fPtNClustersTPCSharedFrac);
fPtNPointITS = new TH2F("fPtNPointITS","fPtNPointITS",fgkNPtBins,binsPt,fgkNNPointITSBins,binsNPointITS);
fHistList->Add(fPtNPointITS);
fPtRelUncertainty1Pt = new TH2F("fPtRelUncertainty1Pt","fPtRelUncertainty1Pt",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty);
fHistList->Add(fPtRelUncertainty1Pt);
+ fPtRelUncertainty1PtNClus = new TH3F("fPtRelUncertainty1PtNClus","fPtRelUncertainty1PtNClus",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
+ fHistList->Add(fPtRelUncertainty1PtNClus);
+
+ fPtRelUncertainty1PtNClusIter1 = new TH3F("fPtRelUncertainty1PtNClusIter1","fPtRelUncertainty1PtNClusIter1",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
+ fHistList->Add(fPtRelUncertainty1PtNClusIter1);
+
+ fPtRelUncertainty1PtChi2 = new TH3F("fPtRelUncertainty1PtChi2","fPtRelUncertainty1PtChi2",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNChi2PerClusBins,binsChi2PerClus);
+ fHistList->Add(fPtRelUncertainty1PtChi2);
+
+ fPtRelUncertainty1PtChi2Iter1 = new TH3F("fPtRelUncertainty1PtChi2Iter1","fPtRelUncertainty1PtChi2Iter1",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNChi2PerClusBins,binsChi2PerClus);
+ fHistList->Add(fPtRelUncertainty1PtChi2Iter1);
+
+ fPtRelUncertainty1PtPhi = new TH3F("fPtRelUncertainty1PtPhi","fPtRelUncertainty1PtPhi",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNPhiBins,binsPhi);
+ fHistList->Add(fPtRelUncertainty1PtPhi);
+
fPtUncertainty1Pt = new TH2F("fPtUncertainty1Pt","fPtUncertainty1Pt",fgkNPtBins,binsPt,fgkNUncertainty1PtBins,binsUncertainty1Pt);
fHistList->Add(fPtUncertainty1Pt);
fPtChi2PerClusterTPC = new TH2F("fPtChi2PerClusterTPC","fPtChi2PerClusterTPC",fgkNPtBins,binsPt,fgkNChi2PerClusBins,binsChi2PerClus);
fHistList->Add(fPtChi2PerClusterTPC);
+
+ fPtChi2PerClusterTPCIter1 = new TH2F("fPtChi2PerClusterTPCIter1","fPtChi2PerClusterTPCIter1",fgkNPtBins,binsPt,fgkNChi2PerClusBins,binsChi2PerClus);
+ fHistList->Add(fPtChi2PerClusterTPCIter1);
fPtNCrossedRows = new TH2F("fPtNCrossedRows","fPtNCrossedRows",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC);
fHistList->Add(fPtNCrossedRows);
fPtNCrRNCrRNClusF = new TH3F("fPtNCrRNCrRNClusF","fPtNCrRNCrRNClusF",fgkNPtBins,binsPt,fgkNNClustersTPCBins,binsNClustersTPC,fgkNCrossedRowsNClusFBins,binsNCrossedRowsNClusF);
fHistList->Add(fPtNCrRNCrRNClusF);
+ fPtChi2Gold = new TH2F("fPtChi2Gold","fPtChi2Gold",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C);
+ fHistList->Add(fPtChi2Gold);
+
+ fPtChi2GGC = new TH2F("fPtChi2GGC","fPtChi2GGC",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C);
+ fHistList->Add(fPtChi2GGC);
+
+ fPtChi2GoldPhi = new TH3F("fPtChi2GoldPhi","fPtChi2GoldPhi",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C,fgkNPhiBins,binsPhi);
+ fHistList->Add(fPtChi2GoldPhi);
+
+ fPtChi2GGCPhi = new TH3F("fPtChi2GGCPhi","fPtChi2GGCPhi",fgkNPtBins,binsPt,fgkNChi2CBins,binsChi2C,fgkNPhiBins,binsPhi);
+ fHistList->Add(fPtChi2GGCPhi);
+
+ fChi2GoldChi2GGC = new TH2F("fChi2GoldChi2GGC","fChi2GoldChi2GGC;#chi^{2}_{gold};#chi^{2}_{ggc}",fgkNChi2CBins,binsChi2C,fgkNChi2CBins,binsChi2C);
+ fHistList->Add(fChi2GoldChi2GGC);
+
+
fPtSigmaY2 = new TH2F("fPtSigmaY2","fPtSigmaY2",fgkN1PtBins,bins1Pt,fgkNSigmaY2Bins,binsSigmaY2);
fHistList->Add(fPtSigmaY2);
//________________________________________________________________________
Int_t AliPWG4HighPtTrackQA::CalculateCentrality(AliVEvent *ev){
+ //
+ // Get centrality from ESD or AOD
+ //
+
if(fDataType==kESD)
return CalculateCentrality(dynamic_cast<AliESDEvent*>(ev));
else if(fDataType==kAOD)
//________________________________________________________________________
Int_t AliPWG4HighPtTrackQA::CalculateCentrality(AliESDEvent *esd){
+ //
+ // Get centrality from ESD
+ //
-
- Float_t cent = 999;
+ Float_t cent = -1;
if(esd){
if(esd->GetCentrality()){
cent = esd->GetCentrality()->GetCentralityPercentile("V0M");
- if(fDebug>3) cout << "centrality: " << cent << endl;
+ if(fDebug>3) printf("centrality: %f\n",cent);
}
}
- if(cent>80)return 4;
- if(cent>50)return 3;
- if(cent>30)return 2;
- if(cent>10)return 1;
- return 0;
+ return GetCentralityClass(cent);
}
//________________________________________________________________________
Int_t AliPWG4HighPtTrackQA::CalculateCentrality(AliAODEvent *aod){
+ //
+ // Get centrality from AOD
+ //
- if(!aod)return 4;
+ if(!aod) return 5;
Float_t cent = aod->GetHeader()->GetCentrality();
- cout << "centrality: " << cent << endl;
- if(cent>80)return 4;
- if(cent>50)return 3;
- if(cent>30)return 2;
- if(cent>10)return 1;
+ if(fDebug>3) printf("centrality: %f\n",cent);
+
+ return GetCentralityClass(cent);
+
+}
+
+//________________________________________________________________________
+Int_t AliPWG4HighPtTrackQA::GetCentralityClass(Float_t cent) {
+ //
+ // Get centrality class
+ //
+
+ if(cent<0) return 5; // OB - cent sometimes negative
+ if(cent>80) return 4;
+ if(cent>50) return 3;
+ if(cent>30) return 2;
+ if(cent>10) return 1;
return 0;
}
//________________________________________________________________________
void AliPWG4HighPtTrackQA::DoAnalysisESD() {
+ //
+ // Run analysis on ESD
+ //
if(!fESD) {
PostData(1, fHistList);
6: nPointITS
7: chi2C
8: nSigmaToVertex
- 9: relUncertainty1Pt
+ 9: trackLengthTPC
10: chi2PerClusterTPC
11: #crossed rows
12: (#crossed rows)/(#findable clusters)
15: SigmaSnp2
16: SigmaTgl2
17: Sigma1Pt2
+ 18: NClustersTPCIter1
+ 19: Chi2TPCIter1
+ 20: nClustersTPCShared
+ 21: Golden Chi2 - global vs TPC constrained
+ 22: Chi2 between global and global constrained
*/
for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
//Get track for analysis
AliESDtrack *track = 0x0;
AliESDtrack *esdtrack = fESD->GetTrack(iTrack);
+ AliESDtrack *origtrack = new AliESDtrack(*esdtrack);
if(!esdtrack) {
fh1NTracksReject->Fill("noESDtrack",1);
+ if(origtrack) delete origtrack;
continue;
}
FillSystematicCutHist(esdtrack);
if (!(fTrackCuts->AcceptTrack(esdtrack))) {
fh1NTracksReject->Fill("trackCuts",1);
+ if(origtrack) delete origtrack;
continue;
}
}
track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
if(!track) {
fh1NTracksReject->Fill("noTPConly",1);
+ if(origtrack) delete origtrack;
continue;
}
AliExternalTrackParam exParam;
Bool_t relate = track->RelateToVertexTPC(fVtx,fESD->GetMagneticField(),kVeryBig,&exParam);
if( !relate ) {
fh1NTracksReject->Fill("relate",1);
- delete track;
+ if(track) delete track;
+ if(origtrack) delete origtrack;
continue;
}
track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
}
+ else if(fTrackType==5 || fTrackType==6) {
+ if(fTrackCuts->AcceptTrack(esdtrack)) {
+ if(origtrack) delete origtrack;
+ continue;
+ }
+ else {
+ if( !(fTrackCutsITSLoose->AcceptTrack(esdtrack)) && fTrackCutsTPConly->AcceptTrack(esdtrack) ) {
+
+ if(fTrackType==5) {
+ //use TPConly constrained track
+ track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
+ if(!track) {
+ fh1NTracksReject->Fill("noTPConly",1);
+ if(origtrack) delete origtrack;
+ continue;
+ }
+ AliExternalTrackParam exParam;
+ Bool_t relate = track->RelateToVertexTPC(fVtx,fESD->GetMagneticField(),kVeryBig,&exParam);
+ if( !relate ) {
+ fh1NTracksReject->Fill("relate",1);
+ if(track) delete track;
+ if(origtrack) delete origtrack;
+ continue;
+ }
+ track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
+ }
+ else if(fTrackType==6) {
+ //use global constrained track
+ track = new AliESDtrack(*esdtrack);
+ track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
+
+ }
+ }
+ }
+ }
+ else if(fTrackType==7) {
+ //use global constrained track
+ track = new AliESDtrack(*esdtrack);
+ }
else
track = esdtrack;
if(!track) {
- if(fTrackType==1 || fTrackType==2 || fTrackType==4) delete track;
+ if(origtrack) delete origtrack;
continue;
}
- if(fTrackType==2 || fTrackType==4) {
+ if(fTrackType==2 || fTrackType==4 || fTrackType==5) {
//Cut on chi2 of constrained fit
if(track->GetConstrainedChi2TPC() > fSigmaConstrainedMax*fSigmaConstrainedMax && fSigmaConstrainedMax>0.) {
fh1NTracksReject->Fill("chi2",1);
- delete track;
+ if(track) delete track;
+ if(origtrack) delete origtrack;
continue;
}
}
fPtAll->Fill(track->Pt());
- if (!(fTrackCuts->AcceptTrack(track)) && fTrackType!=4) {
+ if (!(fTrackCuts->AcceptTrack(track)) && fTrackType!=4 && fTrackType!=5 && fTrackType!=6) {
fh1NTracksReject->Fill("trackCuts",1);
- if(fTrackType==1 || fTrackType==2) delete track;
+ if(fTrackType==1 || fTrackType==2 || fTrackType==7) {
+ if(track) delete track;
+ }
+ if(origtrack) delete origtrack;
continue;
}
- //Cut out laser tracks
- if(track->GetTPCsignal()<10) { //Cut on laser tracks
- fh1NTracksReject->Fill("laser",1);
- if(fTrackType==1 || fTrackType==2 || fTrackType==4) delete track;
- continue;
+ if(fTrackType==7) {
+ if(fTrackCutsITSLoose ) {
+ if(fTrackCutsITSLoose->AcceptTrack(track) ) {
+ if(track) delete track;
+ if(origtrack) delete origtrack;
+ continue;
+ }
+ }
+
+ if(esdtrack->GetConstrainedParam())
+ track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
}
+ if(!track) {
+ if(fTrackType==1 || fTrackType==2 || fTrackType==4 || fTrackType==5 || fTrackType==6 || fTrackType==7) {
+ if(track) delete track;
+ }
+ if(origtrack) delete origtrack;
+ continue;
+ }
+
fh1NTracksSel->Fill(0.);
fVariables->Reset(0.);
Float_t dca2D = 0.;
Float_t dcaz = 0.;
- if(fTrackType==0) { //Global
- track->GetImpactParameters(dca2D,dcaz);
- }
- else if(fTrackType==1 || fTrackType==2 || fTrackType==4) { //TPConly
- track->GetImpactParametersTPC(dca2D,dcaz);
+
+ if(fTrackType==1 || fTrackType==2 || fTrackType==4) {
+ track->GetImpactParametersTPC(dca2D,dcaz); //TPConly
}
+ else
+ track->GetImpactParameters(dca2D,dcaz); //Global
+
fVariables->SetAt(dca2D,3);
- fVariables->SetAt(dcaz,5);
+ fVariables->SetAt(dcaz,4);
fVariables->SetAt((float)track->GetTPCNcls(),5);
fVariables->SetAt(chi2C,7);
fVariables->SetAt(fTrackCuts->GetSigmaToVertex(track),8);// Calculates the number of sigma to the vertex for a track.
- fVariables->SetAt(TMath::Sqrt(track->GetSigma1Pt2())*fVariables->At(0),9);
+ fVariables->SetAt(GetTrackLengthTPC(track),9);
if(fVariables->At(5)>0.) fVariables->SetAt(track->GetTPCchi2()/fVariables->At(5),10);
- //cout << "#crossed rows (1): " << track->GetTPCClusterInfo(1) << endl;
- //cout << "#crossed rows (2): " << track->GetTPCClusterInfo(2) << endl;
fVariables->SetAt(track->GetTPCClusterInfo(2,1),11); //#crossed rows
- Float_t crossedRowsTPCNClsF = track->GetTPCClusterInfo(2,0);
- //if(track->GetTPCNclsF()>0.) crossedRowsTPCNClsF = fVariables->At(11)/track->GetTPCNclsF();
+ Float_t crossedRowsTPCNClsF = 1.;//track->GetTPCClusterInfo(2,0);
+ if(track->GetTPCNclsF()>0.) crossedRowsTPCNClsF = fVariables->At(11)/track->GetTPCNclsF();
fVariables->SetAt(crossedRowsTPCNClsF,12);//(#crossed rows)/(#findable clusters)
fVariables->SetAt(track->GetSigmaY2(),13);
fVariables->SetAt(track->GetSigmaZ2(),14);
fVariables->SetAt(track->GetSigmaSnp2(),15);
fVariables->SetAt(track->GetSigmaTgl2(),16);
fVariables->SetAt(track->GetSigma1Pt2(),17);
+
+ fVariables->SetAt(track->GetTPCNclsIter1(),18);
+ fVariables->SetAt(track->GetTPCchi2Iter1(),19);
+
+ fVariables->SetAt(track->GetTPCnclsS(),20);
+
+ Float_t chi2Gold = GetGoldenChi2(origtrack);
+ Float_t chi2GGC = GetGGCChi2(origtrack);
+
+ fVariables->SetAt(chi2Gold,21);
+ fVariables->SetAt(chi2GGC,22);
FillHistograms();
// int mult = fTrackCuts->CountAcceptedTracks(fESD);
- if(fTrackType==1 || fTrackType==2 || fTrackType==4) delete track;
+ if(fTrackType==1 || fTrackType==2 || fTrackType==4 || fTrackType==5 || fTrackType==6 || fTrackType==7) {
+ if(track) delete track;
+ }
}//track loop
AliAODEvent *aod = dynamic_cast<AliAODEvent*>(fEvent);
if(!aod)return;
+ AliExternalTrackParam *exParam = new AliExternalTrackParam();
for (Int_t iTrack = 0; iTrack < fEvent->GetNumberOfTracks(); iTrack++) {
AliAODTrack *aodtrack = aod->GetTrack(iTrack);
fVariables->SetAt((float)aodtrack->GetITSNcls(),6);
fVariables->SetAt(aodtrack->Chi2perNDF(),7);
fVariables->SetAt(0.,8);
- fVariables->SetAt(0.,9);
+ fVariables->SetAt(GetTrackLengthTPC(aodtrack),9);
fVariables->SetAt(aodtrack->Chi2perNDF(),10);
fVariables->SetAt(GetTPCClusterInfo(aodtrack,2),11);
Float_t crossedRowsTPCNClsF = 0.;
if(aodtrack->GetTPCNclsF()>0.) crossedRowsTPCNClsF = fVariables->At(11)/aodtrack->GetTPCNclsF();
fVariables->SetAt(crossedRowsTPCNClsF,12);
+
+ //get covariance matrix
+ Double_t cov[21] = {0,};
+ aodtrack->GetCovMatrix(cov);
+ Double_t pxpypz[3] = {0,};
+ aodtrack->PxPyPz(pxpypz);
+ Double_t xyz[3] = {0,};
+ aodtrack->GetXYZ(xyz);
+ Short_t sign = aodtrack->Charge();
+ exParam->Set(xyz,pxpypz,cov,sign);
+
+ fVariables->SetAt(exParam->GetSigmaY2(),13);
+ fVariables->SetAt(exParam->GetSigmaZ2(),14);
+ fVariables->SetAt(exParam->GetSigmaSnp2(),15);
+ fVariables->SetAt(exParam->GetSigmaTgl2(),16);
+ fVariables->SetAt(exParam->GetSigma1Pt2(),17);
+
+ fVariables->SetAt(0.,18);
+ fVariables->SetAt(0.,19);
+
+ TBits sharedClusterMap = aodtrack->GetTPCSharedMap();
+ fVariables->SetAt(sharedClusterMap.CountBits(),20);
+ fVariables->SetAt(0.,21); //not available in AOD
+ fVariables->SetAt(0.,22); //not available in AOD
+
fPtAll->Fill(fVariables->At(0));
FillHistograms();
fPtDCAZ->Fill(fVariables->At(0),fVariables->At(4));
fPtNClustersTPC->Fill(fVariables->At(0),fVariables->At(5));
fPtNPointITS->Fill(fVariables->At(0),fVariables->At(6));
- if(fDataType==kESD) {
- fPtChi2C->Fill(fVariables->At(0),fVariables->At(7));
- fPtNSigmaToVertex->Fill(fVariables->At(0),fVariables->At(8));
- fPtRelUncertainty1Pt->Fill(fVariables->At(0),fVariables->At(9));
- fPtUncertainty1Pt->Fill(fVariables->At(0),fVariables->At(0)/fVariables->At(9));
- fPtSigmaY2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(13)));
- fPtSigmaZ2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(14)));
- fPtSigmaSnp2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(15)));
- fPtSigmaTgl2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(16)));
- fPtSigma1Pt2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
-
- fProfPtSigmaY2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(13)));
- fProfPtSigmaZ2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(14)));
- fProfPtSigmaSnp2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(15)));
- fProfPtSigmaTgl2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(16)));
- fProfPtSigma1Pt2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
- fProfPtSigma1Pt->Fill(fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
- fProfPtPtSigma1Pt->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)));
- }
+
+
+ fPtNClustersTPCIter1->Fill(fVariables->At(0),fVariables->At(18));
+ fPtNClustersTPCShared->Fill(fVariables->At(0),fVariables->At(20));
+ if(fVariables->At(5)>0.)
+ fPtNClustersTPCSharedFrac->Fill(fVariables->At(0),fVariables->At(20)/fVariables->At(5));
+
+ if(fVariables->At(18)>0.)
+ fPtChi2PerClusterTPCIter1->Fill(fVariables->At(0),fVariables->At(19)/fVariables->At(18));
+
+ fPtChi2C->Fill(fVariables->At(0),fVariables->At(7));
+ fPtNSigmaToVertex->Fill(fVariables->At(0),fVariables->At(8));
+ fPtRelUncertainty1Pt->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)));
+ fPtRelUncertainty1PtNClus->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(5));
+ fPtRelUncertainty1PtNClusIter1->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(18));
+ fPtRelUncertainty1PtChi2->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(10));
+ if(fVariables->At(18)>0.)
+ fPtRelUncertainty1PtChi2Iter1->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(19)/fVariables->At(18));
+ fPtRelUncertainty1PtPhi->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(1));
+
+ fPtUncertainty1Pt->Fill(fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
+ fPtSigmaY2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(13)));
+ fPtSigmaZ2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(14)));
+ fPtSigmaSnp2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(15)));
+ fPtSigmaTgl2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(16)));
+ fPtSigma1Pt2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
+
+ fProfPtSigmaY2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(13)));
+ fProfPtSigmaZ2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(14)));
+ fProfPtSigmaSnp2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(15)));
+ fProfPtSigmaTgl2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(16)));
+ fProfPtSigma1Pt2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
+ fProfPtSigma1Pt->Fill(fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
+ fProfPtPtSigma1Pt->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)));
+
fPtChi2PerClusterTPC->Fill(fVariables->At(0),fVariables->At(10));
fPtNCrossedRows->Fill(fVariables->At(0),fVariables->At(11));
fPtNCrossedRowsNClusF->Fill(fVariables->At(0),fVariables->At(12));
fPtNCrRNCrRNClusF->Fill(fVariables->At(0),fVariables->At(11),fVariables->At(12));
+
+ fPtChi2Gold->Fill(fVariables->At(0),fVariables->At(21));
+ fPtChi2GGC->Fill(fVariables->At(0),fVariables->At(22));
+
+ fPtChi2GoldPhi->Fill(fVariables->At(0),fVariables->At(21),fVariables->At(1));
+ fPtChi2GGCPhi->Fill(fVariables->At(0),fVariables->At(22),fVariables->At(1));
+
+ fChi2GoldChi2GGC->Fill(fVariables->At(21),fVariables->At(22));
+
+
}
//________________________________________________________________________
return 0; // undefined type - default value
}
+//_______________________________________________________________________
+Int_t AliPWG4HighPtTrackQA::GetTrackLengthTPC(AliESDtrack *track) {
+ //
+ // returns distance between 1st and last hit in TPC
+ // distance given in number of padrows
+ //
+
+ TBits fTPCClusterMap = track->GetTPCClusterMap();
+ int firstHit = 0;
+ int lastHit = 0;
+
+ for(int i=0; i<=159; i++) {
+ if(fTPCClusterMap[i]>0) firstHit = i;
+ }
+ for(int i=159; i>=0; i--) {
+ if(fTPCClusterMap[i]>0) lastHit = i;
+ }
+
+ Int_t trackLength = lastHit - firstHit;
+
+ return trackLength;
+}
+
+//_______________________________________________________________________
+Int_t AliPWG4HighPtTrackQA::GetTrackLengthTPC(AliAODTrack *track) {
+ //
+ // returns distance between 1st and last hit in TPC
+ // distance given in number of padrows
+ //
+
+ TBits fTPCClusterMap = track->GetTPCClusterMap();
+ int firstHit = 0;
+ int lastHit = 0;
+
+ for(int i=0; i<=159; i++) {
+ if(fTPCClusterMap[i]>0) firstHit = i;
+ }
+ for(int i=159; i>=0; i--) {
+ if(fTPCClusterMap[i]>0) lastHit = i;
+ }
+
+ Int_t trackLength = lastHit - firstHit;
+
+ return trackLength;
+}
+
+//_______________________________________________________________________
+Float_t AliPWG4HighPtTrackQA::GetGoldenChi2(AliESDtrack *origtrack) {
+ //
+ // Return chi2 between global and TPC constrained track
+ // track should be the global unconstrained track
+ //
+
+ Float_t chi2Gold = 0.;
+
+ AliESDtrack *tpcTrack = 0x0;
+ tpcTrack = AliESDtrackCuts::GetTPCOnlyTrack(fESD,origtrack->GetID());
+ if(tpcTrack) {
+ AliExternalTrackParam exParam;
+ Bool_t relate = tpcTrack->RelateToVertexTPC(fVtx,fESD->GetMagneticField(),kVeryBig,&exParam);
+ if( relate ) {
+ tpcTrack->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
+ // Double_t pTPC[2],covTPC[3]; tpcTrack->PropagateToDCA(fVtx, fESD->GetMagneticField(), 10000, pTPC, covTPC);
+ }
+
+ tpcTrack->Propagate(origtrack->GetAlpha(), origtrack->GetX(), fESD->GetMagneticField());
+ chi2Gold = (Float_t)origtrack->GetPredictedChi2(tpcTrack);
+ }
+
+ if(tpcTrack) delete tpcTrack;
+
+ return chi2Gold;
+
+}
+
+//_______________________________________________________________________
+Float_t AliPWG4HighPtTrackQA::GetGGCChi2(AliESDtrack *origtrack) {
+ //
+ // Return chi2 between global and global constrained track
+ // track should be the global unconstrained track
+ //
+
+ Float_t chi2GGC = 0.;
+
+ AliESDtrack *esdtrackC = new AliESDtrack(*origtrack);
+ if(esdtrackC) {
+ if(origtrack->GetConstrainedParam()) {
+ esdtrackC->Set(origtrack->GetConstrainedParam()->GetX(),origtrack->GetConstrainedParam()->GetAlpha(),origtrack->GetConstrainedParam()->GetParameter(),origtrack->GetConstrainedParam()->GetCovariance());
+ chi2GGC = (Float_t)origtrack->GetPredictedChi2(esdtrackC);
+ }
+ delete esdtrackC;
+ }
+
+ return chi2GGC;
+
+}
+
+//_______________________________________________________________________
void AliPWG4HighPtTrackQA::FillSystematicCutHist(AliESDtrack *track) {
fSystTrackCuts->Fill("noCut",1);
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff