]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
coverity fix (M. Verweij)
[u/mrichter/AliRoot.git] / PWG4 / JetTasks / AliPWG4HighPtTrackQA.cxx
diff --git a/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx b/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx
index 5960f57289775bcdf45d354f4fe9c727ef6b186d..7d40cd317caf2f54530c7fd27f19a961f1aeb9b4 100644 (file)
--- a/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx
+++ b/PWG4/JetTasks/AliPWG4HighPtTrackQA.cxx
@@ -73,7 +73,7 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA()
   fPtMax(100.),
   fIsPbPb(0),
   fCentClass(10),
-  fNVariables(20),
+  fNVariables(23),
   fVariables(0x0),
   fAvgTrials(1),
   fNEventAll(0),
@@ -95,6 +95,8 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA()
   fPtDCAZ(0x0),
   fPtNClustersTPC(0x0),
   fPtNClustersTPCIter1(0x0),
+  fPtNClustersTPCShared(0x0),
+  fPtNClustersTPCSharedFrac(0x0),
   fPtNPointITS(0x0),
   fPtChi2C(0x0),
   fPtNSigmaToVertex(0x0),
@@ -104,13 +106,17 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA()
   fPtRelUncertainty1PtChi2(0x0),
   fPtRelUncertainty1PtChi2Iter1(0x0),
   fPtRelUncertainty1PtPhi(0x0),
-  fPtRelUncertainty1PtTrkLength(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),
@@ -126,7 +132,7 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA()
   fSystTrackCuts(0x0),
   fHistList(0)
 {
-  SetNVariables(20);
+  SetNVariables(23);
 
   fPtBinEdges[0][0] = 10.;
   fPtBinEdges[0][1] = 1.;
@@ -152,7 +158,7 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA(const char *name):
   fPtMax(100.),
   fIsPbPb(0),
   fCentClass(10),
-  fNVariables(20),
+  fNVariables(23),
   fVariables(0x0),
   fAvgTrials(1),
   fNEventAll(0),
@@ -174,6 +180,8 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA(const char *name):
   fPtDCAZ(0x0),
   fPtNClustersTPC(0x0),
   fPtNClustersTPCIter1(0x0),
+  fPtNClustersTPCShared(0x0),
+  fPtNClustersTPCSharedFrac(0x0),
   fPtNPointITS(0x0),
   fPtChi2C(0x0),
   fPtNSigmaToVertex(0x0),
@@ -183,13 +191,17 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA(const char *name):
   fPtRelUncertainty1PtChi2(0x0),
   fPtRelUncertainty1PtChi2Iter1(0x0),
   fPtRelUncertainty1PtPhi(0x0),
-  fPtRelUncertainty1PtTrkLength(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),
@@ -210,7 +222,7 @@ AliPWG4HighPtTrackQA::AliPWG4HighPtTrackQA(const char *name):
   //
   AliDebug(2,Form("AliPWG4HighPtTrackQA Calling Constructor"));
 
-  SetNVariables(20);
+  SetNVariables(23);
 
   fPtBinEdges[0][0] = 10.;
   fPtBinEdges[0][1] = 1.;
@@ -294,7 +306,7 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
   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.;
   }
@@ -317,21 +329,21 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
   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=20;
+  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;
+  Float_t fgkRel1PtUncertaintyMax = 1.;
   if(fTrackType!=0 && fTrackType!=3) {
     fgkNRel1PtUncertaintyBins = 50;
     fgkRel1PtUncertaintyMax = 1.; 
@@ -496,6 +508,12 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
 
   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);
@@ -524,9 +542,6 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
   fPtRelUncertainty1PtPhi = new TH3F("fPtRelUncertainty1PtPhi","fPtRelUncertainty1PtPhi",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNPhiBins,binsPhi);
   fHistList->Add(fPtRelUncertainty1PtPhi);
 
-  fPtRelUncertainty1PtTrkLength = new TH3F("fPtRelUncertainty1PtTrkLength","fPtRelUncertainty1PtTrkLength",fgkNPtBins,binsPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty,fgkNNClustersTPCBins,binsNClustersTPC);
-  fHistList->Add(fPtRelUncertainty1PtTrkLength);
-
   fPtUncertainty1Pt = new TH2F("fPtUncertainty1Pt","fPtUncertainty1Pt",fgkNPtBins,binsPt,fgkNUncertainty1PtBins,binsUncertainty1Pt);
   fHistList->Add(fPtUncertainty1Pt);
  
@@ -545,6 +560,22 @@ void AliPWG4HighPtTrackQA::UserCreateOutputObjects() {
   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);
 
@@ -881,6 +912,9 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
     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++) {
@@ -893,11 +927,13 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
       fh1NTracksReject->Fill("noESDtrack",1);
       continue;
     }
+    AliESDtrack *origtrack = new AliESDtrack(*esdtrack);
 
     if(fTrackType==4) {
       FillSystematicCutHist(esdtrack);
       if (!(fTrackCuts->AcceptTrack(esdtrack))) {
        fh1NTracksReject->Fill("trackCuts",1);
+       if(origtrack) delete origtrack;
        continue;
       }
     }
@@ -908,6 +944,7 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
       track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
       if(!track) {
        fh1NTracksReject->Fill("noTPConly",1);
+       if(origtrack) delete origtrack;
        continue;
       }
       AliExternalTrackParam exParam;
@@ -915,12 +952,14 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
       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==5 || fTrackType==6) {
       if(fTrackCuts->AcceptTrack(esdtrack)) {
+       if(origtrack) delete origtrack;
        continue;
       }
       else {
@@ -931,6 +970,7 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
            track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
            if(!track) {
              fh1NTracksReject->Fill("noTPConly",1);
+             if(origtrack) delete origtrack;
              continue;
            }
            AliExternalTrackParam exParam;
@@ -938,13 +978,14 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
            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 = esdtrack;
+           track = new AliESDtrack(*esdtrack);
            track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
 
          }
@@ -953,13 +994,13 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
     }
     else if(fTrackType==7) {
       //use global constrained track
-      track = esdtrack;
-      //     track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
+      track = new AliESDtrack(*esdtrack);
     }
     else
       track = esdtrack;
     
     if(!track) {
+      if(origtrack) delete origtrack;
       continue;
     }
 
@@ -968,6 +1009,7 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
       if(track->GetConstrainedChi2TPC() > fSigmaConstrainedMax*fSigmaConstrainedMax && fSigmaConstrainedMax>0.) {
        fh1NTracksReject->Fill("chi2",1);
        if(track) delete track;
+       if(origtrack) delete origtrack;
        continue;
       }
     }
@@ -979,24 +1021,34 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
 
     if (!(fTrackCuts->AcceptTrack(track)) && fTrackType!=4 && fTrackType!=5 && fTrackType!=6) {
       fh1NTracksReject->Fill("trackCuts",1);
-      if(fTrackType==1 || fTrackType==2) {
+      if(fTrackType==1 || fTrackType==2 || fTrackType==7) {
        if(track) delete track;
       }
+      if(origtrack) delete origtrack;
       continue;
     }
 
     if(fTrackType==7) {
       if(fTrackCutsITSLoose ) {
-       if(fTrackCutsITSLoose->AcceptTrack(track) )
+       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) continue;
-
+    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.);
@@ -1015,7 +1067,7 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
       track->GetImpactParameters(dca2D,dcaz);    //Global
 
     fVariables->SetAt(dca2D,3);
-    fVariables->SetAt(dcaz,5);
+    fVariables->SetAt(dcaz,4);
 
     fVariables->SetAt((float)track->GetTPCNcls(),5);
 
@@ -1048,14 +1100,23 @@ void AliPWG4HighPtTrackQA::DoAnalysisESD() {
 
     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 || fTrackType==5) {
+    if(fTrackType==1  || fTrackType==2 || fTrackType==4 || fTrackType==5 || fTrackType==6 || fTrackType==7) {
       if(track) delete track;
     }
+    if(origtrack) delete origtrack;
     
   }//track loop
 
@@ -1114,7 +1175,13 @@ void AliPWG4HighPtTrackQA::DoAnalysisAOD() {
 
     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();
@@ -1136,6 +1203,10 @@ void AliPWG4HighPtTrackQA::FillHistograms() {
 
   
   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));
   
@@ -1148,7 +1219,6 @@ void AliPWG4HighPtTrackQA::FillHistograms() {
   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));
-  fPtRelUncertainty1PtTrkLength->Fill(fVariables->At(0),fVariables->At(0)*TMath::Sqrt(fVariables->At(17)),fVariables->At(9));
   
   fPtUncertainty1Pt->Fill(fVariables->At(0),TMath::Sqrt(fVariables->At(17)));
   fPtSigmaY2->Fill(1./fVariables->At(0),TMath::Sqrt(fVariables->At(13)));
@@ -1169,6 +1239,16 @@ void AliPWG4HighPtTrackQA::FillHistograms() {
   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));
+
+
 }
 
 //________________________________________________________________________
@@ -1404,6 +1484,57 @@ Int_t AliPWG4HighPtTrackQA::GetTrackLengthTPC(AliAODTrack *track) {
   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) {