update the calculation of used clusters per tracklet
authorabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 3 Mar 2009 13:04:54 +0000 (13:04 +0000)
committerabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 3 Mar 2009 13:04:54 +0000 (13:04 +0000)
purge used clusters before entering the stand alone tracker
clean up the stand alone code

TRD/AliTRDchamberTimeBin.cxx
TRD/AliTRDseedV1.cxx
TRD/AliTRDtrackerV1.cxx
TRD/AliTRDtrackerV1.h
TRD/AliTRDtrackingChamber.cxx
TRD/AliTRDtrackingChamber.h
TRD/AliTRDtrackingSector.cxx
TRD/qaRec/AliTRDtrackingEfficiencyCombined.cxx

index 757cf88..83d8708 100644 (file)
@@ -246,7 +246,7 @@ void AliTRDchamberTimeBin::BuildIndices(Int_t iter)
   // Select clusters that belong to the Stack
   Int_t nClStack = 0;                                  // Internal counter
   for(Int_t i = 0; i < fN; i++){
-    if(fClusters[i]->IsUsed()){
+    if(fClusters[i]->IsUsed() || fClusters[i]->IsShared()){
       fClusters[i] = 0x0;
       fIndex[i] = 0xffff;
     } else nClStack++;
index 9776967..476a55e 100644 (file)
@@ -436,7 +436,7 @@ void AliTRDseedV1::CookLabels()
     }
   }
 
-  fLabels[2] = AliTRDtrackerV1::Freq(nlab,labels,out,kTRUE);
+  fLabels[2] = AliMathBase::Freq(nlab,labels,out,kTRUE);
   fLabels[0] = out[0];
   if ((fLabels[2]  > 1) && (out[3] > 1)) fLabels[1] = out[2];
 }
@@ -1286,7 +1286,6 @@ Bool_t AliTRDseedV1::Fit(Bool_t tilt, Int_t errors)
 //     fCross[0] = fX0 - fCross[0];
 //   }
 
-  UpdateUsed();
   return kTRUE;
 }
 
index d922f57..d938dc8 100644 (file)
@@ -37,6 +37,7 @@
 #include <TTreeStream.h>
 
 #include "AliLog.h"
+#include "AliMathBase.h"
 #include "AliESDEvent.h"
 #include "AliGeomManager.h"
 #include "AliRieman.h"
@@ -227,7 +228,7 @@ TLinearFitter* AliTRDtrackerV1::GetTiltedRiemanFitterConstraint()
 //____________________________________________________________________ 
 AliRieman* AliTRDtrackerV1::GetRiemanFitter()
 {
-  if(!fgRieman) fgRieman = new AliRieman(AliTRDtrackingChamber::kNTimeBins * AliTRDgeometry::kNlayer);
+  if(!fgRieman) fgRieman = new AliRieman(AliTRDseedV1::kNtb * AliTRDgeometry::kNlayer);
   return fgRieman;
 }
   
@@ -1697,23 +1698,23 @@ void AliTRDtrackerV1::UnloadClusters()
   AliTRDtrackerDebug::SetEventNumber(AliTRDtrackerDebug::GetEventNumber()  + 1);
 }
 
-//____________________________________________________________________
-void AliTRDtrackerV1::UseClusters(const AliKalmanTrack *t, Int_t) const
-{
-  const AliTRDtrackV1 *track = dynamic_cast<const AliTRDtrackV1*>(t);
-  if(!track) return;
-
-  AliTRDseedV1 *tracklet = 0x0;
-  for(Int_t ily=AliTRDgeometry::kNlayer; ily--;){
-    if(!(tracklet = track->GetTracklet(ily))) continue;
-    AliTRDcluster *c = 0x0;
-    for(Int_t ic=AliTRDseed::knTimebins; ic--;){
-      if(!(c=tracklet->GetClusters(ic))) continue;
-      c->Use();
-    }
-  }
-}
-
+// //____________________________________________________________________
+// void AliTRDtrackerV1::UseClusters(const AliKalmanTrack *t, Int_t) const
+// {
+//   const AliTRDtrackV1 *track = dynamic_cast<const AliTRDtrackV1*>(t);
+//   if(!track) return;
+// 
+//   AliTRDseedV1 *tracklet = 0x0;
+//   for(Int_t ily=AliTRDgeometry::kNlayer; ily--;){
+//     if(!(tracklet = track->GetTracklet(ily))) continue;
+//     AliTRDcluster *c = 0x0;
+//     for(Int_t ic=AliTRDseed::knTimebins; ic--;){
+//       if(!(c=tracklet->GetClusters(ic))) continue;
+//       c->Use();
+//     }
+//   }
+// }
+// 
 
 //_____________________________________________________________________________
 Bool_t AliTRDtrackerV1::AdjustSector(AliTRDtrackV1 *track) 
@@ -1894,6 +1895,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
 
   const AliTRDCalDet *cal = AliTRDcalibDB::Instance()->GetT0Det();
   AliTRDtrackingChamber *chamber = 0x0;
+  AliTRDtrackingChamber **ci = 0x0;
   AliTRDseedV1 sseed[kMaxTracksStack*6]; // to be initialized
   Int_t pars[4]; // MakeSeeds parameters
 
@@ -1901,6 +1903,13 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
   //Double_t shift = .5 * alpha;
   Int_t configs[kNConfigs];
   
+  // Purge used clusters from the containers
+  ci = &stack[0];
+  for(Int_t ic = kNPlanes; ic--; ci++){
+    if(!(*ci)) continue;
+    (*ci)->Update();
+  }
+
   // Build initial seeding configurations
   Double_t quality = BuildSeedingConfigs(stack, configs);
   if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
@@ -1916,10 +1925,10 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
   fSieveSeeding = 0;
 
   // Get stack index
-  Int_t ic = 0; AliTRDtrackingChamber **cIter = &stack[0];
-  while(ic<kNPlanes && !(*cIter)){ic++; cIter++;}
-  if(!(*cIter)) return ntracks2;
-  Int_t istack = fGeom->GetStack((*cIter)->GetDetector());
+  Int_t ic = 0; ci = &stack[0];
+  while(ic<kNPlanes && !(*ci)){ic++; ci++;}
+  if(!(*ci)) return ntracks2;
+  Int_t istack = fGeom->GetStack((*ci)->GetDetector());
 
   do{
     // Loop over seeding configurations
@@ -2045,49 +2054,8 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
         if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
           AliInfo(Form("Track %d [%d] nlayers %d trackQuality = %e nused %d, yref = %3.3f", itrack, trackIndex, nlayers, fTrackQuality[trackIndex], nused, trackParams[1]));
 
-          Int_t nclusters = 0;
           AliTRDseedV1 *dseed[6];
-
-          // Build track label - what happens if measured data ???
-          Int_t labels[1000];
-          Int_t outlab[1000];
-          Int_t nlab = 0;
-
-          Int_t labelsall[1000];
-          Int_t nlabelsall = 0;
-          Int_t naccepted  = 0;
-
-          for (Int_t iLayer = 0; iLayer < kNPlanes; iLayer++) {
-            Int_t jseed = kNPlanes*trackIndex+iLayer;
-            dseed[iLayer] = new AliTRDseedV1(sseed[jseed]);
-            dseed[iLayer]->SetOwner();
-            printf("Layer[%d], NClusters[%d]\n", iLayer, sseed[jseed].GetN2());
-            nclusters += sseed[jseed].GetN2();
-            if(!sseed[jseed].IsOK()) continue;
-            for(int ilab=0; ilab<2; ilab++){
-              if(sseed[jseed].GetLabels(ilab) < 0) continue;
-              labels[nlab] = sseed[jseed].GetLabels(ilab);
-              nlab++;
-            }
-
-            // Cooking label
-            for (Int_t itime = 0; itime < fgNTimeBins; itime++) {
-              if(!sseed[jseed].IsUsable(itime)) continue;
-              naccepted++;
-              Int_t tindex = 0, ilab = 0;
-              while(ilab<3 && (tindex = sseed[jseed].GetClusters(itime)->GetLabel(ilab)) >= 0){
-                labelsall[nlabelsall++] = tindex;
-                ilab++;
-              }
-            }
-          }
-          Freq(nlab,labels,outlab,kFALSE);
-          Int_t   label     = outlab[0];
-          Int_t   frequency = outlab[1];
-          Freq(nlabelsall,labelsall,outlab,kFALSE);
-          Int_t   label1    = outlab[0];
-          Int_t   label2    = outlab[2];
-          Float_t fakeratio = (naccepted - outlab[1]) / Float_t(naccepted);
+          memcpy(dseed, lseed, 6*sizeof(AliTRDseedV1*));
 
           //Int_t eventNrInFile = esd->GetEventNumberInFile();
           //AliInfo(Form("Number of clusters %d.", nclusters));
@@ -2114,11 +2082,6 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
               << "p4="                         << trackParams[4]
               << "p5="                         << trackParams[5]
               << "p6="                         << trackParams[6]
-              << "Label="                              << label
-              << "Label1="                     << label1
-              << "Label2="                     << label2
-              << "FakeRatio="                  << fakeratio
-              << "Freq="                               << frequency
               << "Ncl="                                << ncl
               << "NLayers="                    << nlayers
               << "Findable="                   << findable
@@ -2544,32 +2507,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
         //chi2Vals[2] = GetChi2ZTest(&cseed[0]);
         fTrackQuality[ntracks] = CalculateTrackLikelihood(&cseed[0], &chi2Vals[0]);
         //AliInfo("Hyperplane fit done\n");
-      
-        // finalize tracklets
-        Int_t labels[12];
-        Int_t outlab[24];
-        Int_t nlab = 0;
-        for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
-          if (!cseed[iLayer].IsOK()) continue;
-      
-          if (cseed[iLayer].GetLabels(0) >= 0) {
-            labels[nlab] = cseed[iLayer].GetLabels(0);
-            nlab++;
-          }
-      
-          if (cseed[iLayer].GetLabels(1) >= 0) {
-            labels[nlab] = cseed[iLayer].GetLabels(1);
-            nlab++;
-          }
-        }
-        Freq(nlab,labels,outlab,kFALSE);
-        Int_t label     = outlab[0];
-        Int_t frequency = outlab[1];
-//         for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
-//           cseed[iLayer].SetFreq(frequency);
-//           cseed[iLayer].SetChi2Z(chi2[1]);
-//         }
-            
+                  
         if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
           TTreeSRedirector &cstreamer = *fReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
           Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
@@ -2594,8 +2532,6 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 *ss
               << "S3.="                                << &cseed[3]
               << "S4.="                                << &cseed[4]
               << "S5.="                                << &cseed[5]
-              << "Label="                              << label
-              << "Freq="                               << frequency
               << "FitterT.="                   << fitterT
               << "FitterTC.="                  << fitterTC
               << "\n";
@@ -3226,64 +3162,64 @@ Float_t AliTRDtrackerV1::CalculateReferenceX(AliTRDseedV1 *tracklets){
   return tracklets[startIndex].GetX0() + (2.5 - startIndex) * meanDistance - 0.5 * (AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick());
 }
 
-//_____________________________________________________________________________
-Int_t AliTRDtrackerV1::Freq(Int_t n, const Int_t *inlist
-          , Int_t *outlist, Bool_t down)
-{    
-  //
-  // Sort eleements according occurancy 
-  // The size of output array has is 2*n 
-  //
-
-  if (n <= 0) {
-    return 0;
-  }
-
-  Int_t *sindexS = new Int_t[n];   // Temporary array for sorting
-  Int_t *sindexF = new Int_t[2*n];   
-  for (Int_t i = 0; i < n; i++) {
-    sindexF[i] = 0;
-  }
-
-  TMath::Sort(n,inlist,sindexS,down); 
-
-  Int_t last     = inlist[sindexS[0]];
-  Int_t val      = last;
-  sindexF[0]     = 1;
-  sindexF[0+n]   = last;
-  Int_t countPos = 0;
-
-  // Find frequency
-  for (Int_t i = 1; i < n; i++) {
-    val = inlist[sindexS[i]];
-    if (last == val) {
-      sindexF[countPos]++;
-    }
-    else {      
-      countPos++;
-      sindexF[countPos+n] = val;
-      sindexF[countPos]++;
-      last                = val;
-    }
-  }
-  if (last == val) {
-    countPos++;
-  }
-
-  // Sort according frequency
-  TMath::Sort(countPos,sindexF,sindexS,kTRUE);
-
-  for (Int_t i = 0; i < countPos; i++) {
-    outlist[2*i  ] = sindexF[sindexS[i]+n];
-    outlist[2*i+1] = sindexF[sindexS[i]];
-  }
-
-  delete [] sindexS;
-  delete [] sindexF;
-  
-  return countPos;
-
-}
+// //_____________________________________________________________________________
+// Int_t AliTRDtrackerV1::Freq(Int_t n, const Int_t *inlist
+//           , Int_t *outlist, Bool_t down)
+// {    
+//   //
+//   // Sort eleements according occurancy 
+//   // The size of output array has is 2*n 
+//   //
+// 
+//   if (n <= 0) {
+//     return 0;
+//   }
+// 
+//   Int_t *sindexS = new Int_t[n];   // Temporary array for sorting
+//   Int_t *sindexF = new Int_t[2*n];   
+//   for (Int_t i = 0; i < n; i++) {
+//     sindexF[i] = 0;
+//   }
+// 
+//   TMath::Sort(n,inlist,sindexS,down); 
+// 
+//   Int_t last     = inlist[sindexS[0]];
+//   Int_t val      = last;
+//   sindexF[0]     = 1;
+//   sindexF[0+n]   = last;
+//   Int_t countPos = 0;
+// 
+//   // Find frequency
+//   for (Int_t i = 1; i < n; i++) {
+//     val = inlist[sindexS[i]];
+//     if (last == val) {
+//       sindexF[countPos]++;
+//     }
+//     else {      
+//       countPos++;
+//       sindexF[countPos+n] = val;
+//       sindexF[countPos]++;
+//       last                = val;
+//     }
+//   }
+//   if (last == val) {
+//     countPos++;
+//   }
+// 
+//   // Sort according frequency
+//   TMath::Sort(countPos,sindexF,sindexS,kTRUE);
+// 
+//   for (Int_t i = 0; i < countPos; i++) {
+//     outlist[2*i  ] = sindexF[sindexS[i]+n];
+//     outlist[2*i+1] = sindexF[sindexS[i]];
+//   }
+// 
+//   delete [] sindexS;
+//   delete [] sindexF;
+//   
+//   return countPos;
+// 
+// }
 
 
 //____________________________________________________________________
index 9ad8dd3..49a9e87 100644 (file)
@@ -105,9 +105,8 @@ public:
   static void     SetNTimeBins(Int_t nTimeBins){fgNTimeBins = nTimeBins; }
   void            SetReconstructor(const AliTRDReconstructor *rec){ fReconstructor = rec; }
   void            UnloadClusters();
-  void            UseClusters(const AliKalmanTrack *t, Int_t from = 0) const;
-  
-  static Int_t    Freq(Int_t n, const Int_t *inlist, Int_t *outlist, Bool_t down); // to be removed 
+//   void            UseClusters(const AliKalmanTrack *t, Int_t from = 0) const;
+//   static Int_t    Freq(Int_t n, const Int_t *inlist, Int_t *outlist, Bool_t down); // to be removed 
 
   class AliTRDLeastSquare{
   public:
index 2f4f91c..a22a716 100644 (file)
@@ -52,7 +52,7 @@ AliTRDtrackingChamber::AliTRDtrackingChamber()
 //_______________________________________________________
 void AliTRDtrackingChamber::Clear(const Option_t *opt)
 {
-  for(Int_t itb=0; itb<kNTimeBins; itb++) fTB[itb].Clear(opt);
+  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++) fTB[itb].Clear(opt);
 }
 
 //_______________________________________________________
@@ -81,7 +81,7 @@ Bool_t AliTRDtrackingChamber::Build(AliTRDgeometry *geo, const AliTRDCalDet *cal
   Int_t nrows = pp->GetNrows();
   
   Int_t index[50], jtb = 0;
-  for(Int_t itb=0; itb<kNTimeBins; itb++){ 
+  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){ 
     if(!fTB[itb]) continue;
     fTB[itb].SetRange(z0, zl);
     fTB[itb].SetNRows(nrows);
@@ -116,7 +116,7 @@ Int_t AliTRDtrackingChamber::GetNClusters() const
 // Returns number of clusters in chamber
 //
   Int_t n = 0;
-  for(Int_t itb=0; itb<kNTimeBins; itb++){ 
+  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){ 
     n += Int_t(fTB[itb]);
   }
   return n;    
@@ -129,7 +129,7 @@ void AliTRDtrackingChamber::Bootstrap(const AliTRDReconstructor *rec)
 // Bootstrap each time bin
 //
   AliTRDchamberTimeBin *jtb = &fTB[0];
-  for(Int_t itb=0; itb<kNTimeBins; itb++, ++jtb){ 
+  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++, ++jtb){ 
     (*jtb).Bootstrap(rec, fDetector);
   }
 }
@@ -141,7 +141,7 @@ void  AliTRDtrackingChamber::SetOwner()
 // Set ownership in time bins
 //
   AliTRDchamberTimeBin *jtb = &fTB[0];
-  for(Int_t itb=0; itb<kNTimeBins; itb++, ++jtb){ 
+  for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++, ++jtb){ 
     if(!(Int_t(*jtb))) continue;
     (*jtb).SetOwner();
   }
@@ -172,7 +172,7 @@ Double_t AliTRDtrackingChamber::GetQuality()
   Int_t ncl   = 0;
   Int_t nused = 0;
   Int_t nClLayer;
-  for(int itb=0; itb<kNTimeBins; itb++){
+  for(int itb=0; itb<AliTRDseedV1::kNtb; itb++){
     if(!(nClLayer = fTB[itb].GetNClusters())) continue;
     ncl += nClLayer;
     for(Int_t incl = 0; incl < nClLayer; incl++){
@@ -239,7 +239,7 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
     histogram[irs] = &hvals[irs*kMaxCols];
     sigmas[irs] = &svals[irs*kMaxCols];
   }
-  for(Int_t iTime = timeBinMin; iTime < kNTimeBins-timeBinMax; iTime++){
+  for(Int_t iTime = timeBinMin; iTime < AliTRDseedV1::kNtb-timeBinMax; iTime++){
     if(!(nClusters = fTB[iTime].GetNClusters())) continue;
     z0 = fTB[iTime].GetZ0();
     zl = fTB[iTime].GetDZ0();
@@ -362,7 +362,7 @@ Bool_t AliTRDtrackingChamber::GetSeedingLayer(AliTRDchamberTimeBin *&fakeLayer,
       col = cand[ican] % nCols;
       //temporary
       Int_t n = 0; Double_t x = 0., y = 0., z = 0.;
-      for(int itb=0; itb<kNTimeBins; itb++){
+      for(int itb=0; itb<AliTRDseedV1::kNtb; itb++){
         if(!(nClusters = fTB[itb].GetNClusters())) continue;
         for(Int_t incl = 0; incl < nClusters; incl++){
           c = fTB[itb].GetCluster(incl);       
@@ -413,5 +413,19 @@ void AliTRDtrackingChamber::Print(Option_t *opt) const
   AliInfo(Form("fDetector   = %d", fDetector));
   AliInfo(Form("fX0         = %7.3f", fX0));
   const AliTRDchamberTimeBin *itb = &fTB[0];
-  for(Int_t jtb=0; jtb<kNTimeBins; jtb++, itb++) (*itb).Print(opt);
+  for(Int_t jtb=0; jtb<AliTRDseedV1::kNtb; jtb++, itb++) (*itb).Print(opt);
 }
+
+
+//_______________________________________________________
+void AliTRDtrackingChamber::Update()
+{
+// Steer purging of used and shared clusters 
+
+  AliTRDchamberTimeBin *jtb = &fTB[0];
+  for(Int_t itb=AliTRDseedV1::kNtb; itb--; ++jtb){ 
+    if(!(Int_t(*jtb))) continue;
+    (*jtb).BuildIndices();
+  }
+}
+
index 6d17f0f..54fb5a3 100644 (file)
@@ -21,8 +21,8 @@
 #endif
 
 
-#ifndef ALITRDSEED_H
-#include "AliTRDseed.h"
+#ifndef ALITRDSEEDV1_H
+#include "AliTRDseedV1.h"
 #endif
 
 class AliTRDCalDet;
@@ -32,9 +32,6 @@ class AliTRDtrackingChamber : public TObject
 {
 
 public:
-  enum{
-    kNTimeBins = AliTRDseed::knTimebins
-  };
   AliTRDtrackingChamber();
   virtual ~AliTRDtrackingChamber(){}
   
@@ -46,19 +43,20 @@ public:
   Double_t GetQuality();
   Bool_t   GetSeedingLayer(AliTRDchamberTimeBin *&layer, AliTRDgeometry *geo, const AliTRDReconstructor *rec);
   Float_t  GetX()        const {return fX0;}
-  AliTRDchamberTimeBin* GetTB(int tb) {return tb >= 0 && tb < kNTimeBins ? &fTB[tb] : 0x0;}
+  AliTRDchamberTimeBin* GetTB(int tb) {return tb >= 0 && tb < AliTRDseedV1::kNtb ? &fTB[tb] : 0x0;}
   void     InsertCluster(AliTRDcluster *c, Int_t index);
   
   void     Print(Option_t *opt = 0x0) const;
 
   void     SetDetector(Int_t det) { fDetector = det;}
   void     SetOwner();
+  void     Update();
 
 private:
   Int_t         fDetector;  // detector number
   Float_t       fX0;        // approximate position of the pad plane
   
-  AliTRDchamberTimeBin fTB[kNTimeBins];    // time bins 
+  AliTRDchamberTimeBin fTB[AliTRDseedV1::kNtb];    // time bins 
   
   
   ClassDef(AliTRDtrackingChamber, 1)  // TRD tracker container for one chamber
index 794e246..f63de7c 100644 (file)
@@ -74,7 +74,7 @@ void AliTRDtrackingSector::Init(const AliTRDReconstructor *rec, const AliTRDCalD
   AliTRDchamberTimeBin *tb = 0x0;\r
   AliTRDtrackingChamber **tc = &fChamber[0];\r
   for(Int_t ic = 0; (ic<AliTRDgeometry::kNdets) && (*tc); ic++, tc++){\r
-    for(Int_t itb=0; itb<AliTRDseed::knTimebins; itb++){\r
+    for(Int_t itb=0; itb<AliTRDseedV1::kNtb; itb++){\r
       if(!(tb = (*tc)->GetTB(itb))) continue;\r
       tb->SetReconstructor(rec);\r
     }\r
index 7e4b2dd..9544147 100644 (file)
@@ -34,6 +34,7 @@
 #include "AliMagF.h"
 #include "AliPID.h"
 #include "AliTracker.h"
+#include "AliMathBase.h"
 #include "AliTrackReference.h"
 #include "AliAnalysisManager.h"
 
@@ -458,7 +459,7 @@ void AliTRDtrackingEfficiencyCombined::FillStreamTrackWOMC(AliTRDtrackInfo *trkI
     while((c = tracklet->NextCluster())) TRDlabels[nclusters++] = c->GetLabel(0);
   }
   // Determine Label and Frequency
-  AliTRDtrackerV1::Freq(nclusters, const_cast<const Int_t *>(&TRDlabels[0]), &sortlabels[0], kTRUE);
+  AliMathBase::Freq(nclusters, const_cast<const Int_t *>(&TRDlabels[0]), &sortlabels[0], kTRUE);
   Int_t TRDLabel = sortlabels[0];
   Int_t freqTRD = sortlabels[1];
   // find the track info object matching to the TRD track