Some changes
authorvestbo <vestbo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Jul 2001 13:30:43 +0000 (13:30 +0000)
committervestbo <vestbo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Jul 2001 13:30:43 +0000 (13:30 +0000)
HLT/hough/AliL3Hough.cxx
HLT/hough/AliL3Hough.h
HLT/hough/AliL3HoughEval.cxx
HLT/hough/AliL3HoughEval.h

index 6bdb419060a16336f9236f585b360d1b2de7d116..c4e2dda9eb771286e542a92055d009c74cd51479 100644 (file)
@@ -1,9 +1,21 @@
+//Author:        Anders Strand Vestbo
+//Last Modified: 28.6.01
+
 #include <string.h>
-#include <TH2.h>
+#include <TCanvas.h>
+#include <TFile.h>
 
+#include "AliL3Histogram.h"
 #include "AliL3Hough.h"
 #include "AliL3HoughTransformer.h"
 #include "AliL3HoughMaxFinder.h"
+#include "AliL3FileHandler.h"
+#include "AliL3DigitData.h"
+#include "AliL3HoughEval.h"
+#include "AliL3Transform.h"
+#include "AliL3Defs.h"
+#include "AliL3TrackArray.h"
+#include "AliL3HoughTrack.h"
 
 ClassImp(AliL3Hough)
 
@@ -15,19 +27,23 @@ AliL3Hough::AliL3Hough()
 }
 
 
-AliL3Hough::AliL3Hough(Char_t *rootfile,TH2F *hist)
+AliL3Hough::AliL3Hough(Int_t n_eta_segments,Int_t xbin,Double_t *xrange,Int_t ybin,Double_t *yrange)
 {
   
-  fParamSpace = hist;
-  strcpy(fInputFile,rootfile);
-  
-}
-
-AliL3Hough::AliL3Hough(Char_t *rootfile,Int_t xbin,Double_t *xrange,Int_t ybin,Double_t *yrange)
-{
-
-  fParamSpace = new TH2F("fParamSpace","Parameter space",xbin,xrange[0],xrange[1],ybin,yrange[0],yrange[1]);
-  strcpy(fInputFile,rootfile);
+  fNEtaSegments = n_eta_segments;
+  fNxbin = xbin;
+  fNybin = ybin;
+  fXmin = xrange[0];
+  fXmax = xrange[1];
+  fYmin = yrange[0];
+  fYmax = yrange[1];
+
+  fMemHandler = new AliL3FileHandler();
+  fMaxFinder = new AliL3HoughMaxFinder("KappaPhi");
+  fEval = new AliL3HoughEval();
+  fTransform = new AliL3Transform();
+  fDeleteTrack = kTRUE;
+  fTracks = new AliL3TrackArray("AliL3HoughTrack");
 }
 
 
@@ -36,29 +52,102 @@ AliL3Hough::~AliL3Hough()
   
   if(fHoughTransformer)
     delete fHoughTransformer;
+  if(fMemHandler)
+    delete fMemHandler;
+  if(fMaxFinder)
+    delete fMaxFinder;
+  if(fEval)
+    delete fEval;
+  if(fTransform)
+    delete fTransform;
 }
 
-
-
-void AliL3Hough::ProcessSlice(Int_t slice)
+void AliL3Hough::SetInput(Char_t *input,Bool_t binary)
 {
+  if(binary)
+    {
+      strcpy(fPath,input);
+      fUseBinary = kTRUE;
+    }
+  else
+    {
+      TFile *file = new TFile(input);
+      fMemHandler->SetAliInput(file);
+      fUseBinary = kFALSE;
+    }
   
-
 }
 
-void AliL3Hough::ProcessPatch(Int_t patch)
+void AliL3Hough::ProcessSlice(Int_t slice)
 {
-    
-
+  
 }
 
-void AliL3Hough::ProcessEtaSlice(Int_t patch,Double_t *eta)
+void AliL3Hough::ProcessPatch(Int_t slice,Int_t patch)
 {
   
-  fHoughTransformer = new AliL3HoughTransformer(2,patch,eta);
-  fHoughTransformer->GetPixels(fInputFile);
-  fParamSpace->Reset();
-  fHoughTransformer->InitTemplates(fParamSpace);
-  fHoughTransformer->Transform2Circle(fParamSpace,0);
+  Char_t histname[50];
+  Int_t i;
+  
+  if(fHoughTransformer)
+    delete fHoughTransformer;
+  fHoughTransformer = new AliL3HoughTransformer(slice,patch);//,0,fNEtaSegments);
+  
+  fHistos = new AliL3Histogram*[fNEtaSegments];
+  printf("Allocating %d bytes to histograms\n",fNEtaSegments*sizeof(AliL3Histogram));
+  for(i=0; i<fNEtaSegments; i++)
+    {
+      sprintf(histname,"hist%d",i);
+      fHistos[i] = new AliL3Histogram(histname,"",fNxbin,fXmin,fXmax,fNybin,fYmin,fYmax);
+    }
+
+  Char_t name[256];
+  
+  UInt_t ndigits=0;
+  AliL3DigitRowData *digits =0;
+  // fMemHandler->Init(slice,patch,NRows[patch]);
+  //fMemHandler->Init(fTransform);
+  if(fUseBinary)
+    {
+      fMemHandler->Free();
+      sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
+      fMemHandler->SetBinaryInput(name);
+      digits = (AliL3DigitRowData *)fMemHandler->CompBinary2Memory(ndigits);
+      fMemHandler->CloseBinaryInput();
+    }
+  else
+    {
+      digits=(AliL3DigitRowData *)fMemHandler->AliDigits2Memory(ndigits); 
+    }
+  printf("Setting up tables\n");
+  fHoughTransformer->SetHistogram(fHistos[0]);
+  fHoughTransformer->InitTables();
+  fHoughTransformer->SetInputData(ndigits,digits);
+  fEval->SetTransformer(fHoughTransformer);
+  
+  AliL3HoughTrack *track;
+  Int_t good_count;
+  while(1)
+    {
+      fHoughTransformer->TransformTables(fHistos);
+      
+      good_count=0;
+      for(Int_t e=0; e<fNEtaSegments; e++)
+       {
+         fMaxFinder->SetHistogram(fHistos[e]);
+         track = (AliL3HoughTrack*)fMaxFinder->FindPeak(3,0.95,5);
+         if(fEval->LookInsideRoad(track,e,fDeleteTrack))
+           {
+             //Found a good track here
+             fTracks->AddLast(track);
+             good_count++;
+           }
+       }
+      break;
+      if(good_count==0)
+       break;
+    }
+  printf("good_count %d\n",good_count);
   
 }
+
index f70bdacf62db676bab020e44b076bbc730e5d860..5e66559dd1866f3db9b18f75721da67b0633cdfb 100644 (file)
@@ -5,29 +5,47 @@
 
 class AliL3HoughMaxFinder;
 class AliL3HoughTransformer;
-class TH2F;
+class AliL3Histogram;
+class AliL3FileHandler;
+class AliL3HoughEval;
+class AliL3Transform;
+class AliL3TrackArray;
 
 class AliL3Hough : public TObject {
   
  private:
 
-  TH2F *fParamSpace;  //!
-  Char_t fInputFile[100];
-  
+  Char_t fPath[256];
+  Int_t fNEtaSegments;
+  AliL3Histogram **fHistos; //!
+  AliL3FileHandler *fMemHandler; //!
+  AliL3HoughMaxFinder *fMaxFinder; 
+  AliL3HoughEval *fEval;
   AliL3HoughTransformer *fHoughTransformer;
-  AliL3HoughMaxFinder *fPeakFinder;
-
+  AliL3Transform *fTransform; //!
+  Bool_t fUseBinary;
+  Bool_t fDeleteTrack;
+  AliL3TrackArray *fTracks; //!
+
+  Int_t fNxbin;
+  Int_t fNybin;
+  Double_t fXmin;
+  Double_t fXmax;
+  Double_t fYmin;
+  Double_t fYmax;
 
  public:
 
   AliL3Hough(); 
-  AliL3Hough(Char_t *rootfile,TH2F *hist);
-  AliL3Hough(Char_t *rootfile,Int_t xbin,Double_t *xrange,Int_t ybin,Double_t *yrange);
+  AliL3Hough(Int_t n_eta_segments,Int_t xbin,Double_t *xrange,Int_t ybin,Double_t *yrange);
   virtual ~AliL3Hough();
   
+  void SetInput(Char_t *input,Bool_t binary);
   void ProcessSlice(Int_t slice);
-  void ProcessPatch(Int_t patch);
-  void ProcessEtaSlice(Int_t patch,Double_t *eta);
+  void ProcessPatch(Int_t slice,Int_t patch);
+  void SetDeleteTrack(Bool_t f) {fDeleteTrack = (Bool_t)f;}
+  
+  AliL3TrackArray *GetTracks() {return fTracks;}
 
   ClassDef(AliL3Hough,1)
 
index 5bdfcc92d345aa0e6b37a43d3c4967df810a6cb0..18fa208aed6bff4a54201b4019dd0a5163087272 100644 (file)
@@ -1,10 +1,16 @@
+//Author:        Anders Strand Vestbo
+//Last Modified: 28.6.01
+
 #include <TClonesArray.h>
 #include <TH2.h>
 #include <TH1.h>
 #include <TFile.h>
 #include <AliRun.h>
 #include <TParticle.h>
+#include <TTree.h>
 
+#include "AliTPCParam.h"
+#include "AliSimDigits.h"
 #include "AliL3TrackArray.h"
 #include "AliL3Transform.h"
 #include "AliL3HoughTransformer.h"
@@ -19,7 +25,9 @@ AliL3HoughEval::AliL3HoughEval()
 {
   //Default constructor
   fTransform = new AliL3Transform();
-  fHoughTransformer = NULL;
+  fHoughTransformer = 0;
+  fNumOfRowsToMiss = 1;
+  fNumOfPadsToLook = 1;
 }
 
 
@@ -28,6 +36,8 @@ AliL3HoughEval::AliL3HoughEval(AliL3HoughTransformer *transformer)
   //Constructor
   fHoughTransformer = transformer;
   fTransform = new AliL3Transform();
+  fNumOfRowsToMiss = 1;
+  fNumOfPadsToLook = 1;
 }
 
 
@@ -36,13 +46,73 @@ AliL3HoughEval::~AliL3HoughEval()
   //Destructor
   if(fTransform)
     delete fTransform;
+  if(fMcTrackTable)
+    delete [] fMcTrackTable;
 }
 
 
-void AliL3HoughEval::LookInsideRoad(AliL3TrackArray *tracks,Bool_t remove,TH2F *hist)
+Bool_t AliL3HoughEval::LookInsideRoad(AliL3HoughTrack *track,Int_t eta_index,Bool_t remove)
 {
   //Look at rawdata along the road specified by the track candidates.
+  
+  if(!fHoughTransformer)
+    {
+      printf("\nAliL3HoughEval: No transformer object\n");
+      return kFALSE;
+    }
+  
+  Int_t patch = fHoughTransformer->fPatch;
+  Int_t slice = fHoughTransformer->fSlice;
+
+  
+  Int_t sector,row;
+  Int_t lut_index;
+  Char_t **track_lut = fHoughTransformer->fTrackTable;
+  Int_t nrow=0,npixs=0;
+  Float_t xyz[3];
+    
+  for(Int_t padrow = NRows[patch][0]; padrow <= NRows[patch][1]; padrow++)
+    {
+      Int_t prow = padrow - NRows[patch][0];
+      if(!track->GetCrossingPoint(padrow,xyz))  
+       {
+         printf("AliL3HoughEval::LookInsideRoad : Track does not cross line!!\n");
+         continue;
+       }
+      
+      fTransform->Slice2Sector(slice,padrow,sector,row);
+      fTransform->Local2Raw(xyz,sector,row);
+      npixs=0;
+      //Look at both sides of the crossing point:
+      for(Int_t p=(Int_t)xyz[1]-fNumOfPadsToLook; p<=(Int_t)xyz[1]+fNumOfPadsToLook; p++)
+       {
+         if(p<0 || p>fTransform->GetNPads(padrow)) continue;
+         lut_index = (prow<<8) + p;
+         if(track_lut[eta_index][lut_index]>0) //There was a signal here
+           npixs++;
+       }
+      
+      if(npixs > 0)
+       {
+         nrow++;
+       }         
+    }
+  if(nrow >= NRows[patch][1]-NRows[patch][0]-fNumOfRowsToMiss)//this was a good track
+    {
+      track->SetEtaIndex(eta_index);
+      if(remove)
+       RemoveTrackFromImage(track,eta_index);
+      return kTRUE;
+    }
+  else
+    return kFALSE;
+}
+
+void AliL3HoughEval::LookInsideRawRoad(AliL3TrackArray *tracks,Int_t eta_index,Bool_t remove)
+{
+  //Evalaute the track candidates by looking along the trajectory.
+  //If remove is on, the pixels along the track will be removed. 
+
 
   if(!fHoughTransformer)
     {
@@ -50,70 +120,91 @@ void AliL3HoughEval::LookInsideRoad(AliL3TrackArray *tracks,Bool_t remove,TH2F *
       return;
     }
   
-  AliL3Digits *pixel;
   Int_t patch = fHoughTransformer->fPatch;
   Int_t slice = fHoughTransformer->fSlice;
-  Int_t num_of_pads_to_look = 1;
-  Int_t rows_to_miss = 1;
 
+  
+  Int_t sector,row;
+  Int_t lut_index;
+  Char_t **track_lut = fHoughTransformer->fTrackTable;
+  Int_t nrow,npixs;
+  Float_t xyz[3];
+  
   for(Int_t i=0; i<tracks->GetNTracks(); i++)
     {
       AliL3HoughTrack *track = (AliL3HoughTrack*)tracks->GetCheckedTrack(i);
       if(!track) {printf("No track\n"); return;}
       
-      Int_t nrow = 0;
+      nrow = 0;
       
       for(Int_t padrow = NRows[patch][0]; padrow <= NRows[patch][1]; padrow++)
        {
-         
-         Float_t xyz[3];
-         //Get the crossing point of the track and current padrow:
-         //if(!track->GetCrossingPoint(slice,padrow,xyz))
+         Int_t prow = padrow - NRows[patch][0];
          if(!track->GetCrossingPoint(padrow,xyz))  
            {
              printf("AliL3HoughEval::LookInsideRoad : Track does not cross line!!\n");
              continue;
            }
-         
-         Int_t npixs = 0;
-         
-         //Get the pixels along the track candidate
-         for(pixel=(AliL3Digits*)fHoughTransformer->fRowContainer[padrow].first; pixel!=0; pixel=(AliL3Digits*)pixel->nextRowPixel)
+                 
+         fTransform->Slice2Sector(slice,padrow,sector,row);
+         fTransform->Local2Raw(xyz,sector,row);
+         npixs=0;
+         //Look at both sides of the crossing point:
+         for(Int_t p=(Int_t)xyz[1]-fNumOfPadsToLook; p<=(Int_t)xyz[1]+fNumOfPadsToLook; p++)
            {
-             
-             Int_t sector,row;
-             Float_t xyz_pix[3];
-             fTransform->Slice2Sector(slice,padrow,sector,row);
-             fTransform->Raw2Local(xyz_pix,sector,row,pixel->fPad,pixel->fTime); //y alone pad
-             
-             
-             //check if we are inside road
-             if(fabs(xyz_pix[1] - xyz[1]) > num_of_pads_to_look*fTransform->GetPadPitchWidthLow()) continue; 
-             npixs++;
-             
-             if(remove) //Remove this pixel from image
-               pixel->fIndex = -1;
-
-             if(hist)
-               {
-                 //fTransform->Local2Global(xyz_pix,slice);
-                 hist->Fill(xyz_pix[0],xyz_pix[1],pixel->fCharge);
-               }    
-             
+             if(p<0 || p>fTransform->GetNPads(padrow)) continue;
+             lut_index = (prow<<8) + p;
+             if(track_lut[eta_index][lut_index]>0) //There was a signal here
+               npixs++;
            }
+         
          if(npixs > 0)
            {
              nrow++;
            }     
        }
-      
-      if(nrow < NRows[patch][1]-NRows[patch][0]-rows_to_miss)
-       tracks->Remove(i);
-             
+      if(nrow < NRows[patch][1]-NRows[patch][0]-fNumOfRowsToMiss)
+       tracks->Remove(i); //this was not a good enough track
+      else if(remove)
+       RemoveTrackFromImage(track,eta_index); //this was a good track, so remove it from the image.
     }
   
   tracks->Compress();
+}
+
+void AliL3HoughEval::RemoveTrackFromImage(AliL3HoughTrack *track,Int_t eta_index)
+{
+  //Remove the pixels along the track in the image. 
+  
+  Int_t patch = fHoughTransformer->fPatch;
+  Int_t slice = fHoughTransformer->fSlice;
 
+  Int_t maxnpads = fTransform->GetNPads(NRows[patch][1]);
+  
+  Int_t lut_index;
+  Char_t **track_lut = fHoughTransformer->fTrackTable;
+  Int_t sector,row;
+  Float_t xyz[3];
+  for(Int_t padrow = NRows[patch][0]; padrow<=NRows[patch][1]; padrow++)
+    {
+      Int_t prow = padrow - NRows[patch][0];
+      if(!track->GetCrossingPoint(padrow,xyz))  
+       {
+         printf("AliL3HoughEval::LookInsideRoad : Track does not cross line!!\n");
+         continue;
+       }
+      
+      fTransform->Slice2Sector(slice,padrow,sector,row);
+      fTransform->Local2Raw(xyz,sector,row);
+      
+      for(Int_t p=(Int_t)xyz[1]-fNumOfPadsToLook; p<=(Int_t)xyz[1]+fNumOfPadsToLook; p++)
+       {
+         if(p<0 || p>fTransform->GetNPads(padrow)) continue;
+         lut_index = (prow<<8) + p;
+         track_lut[eta_index][lut_index] = -1; //remove it!!
+       }
+    }
+  
   
 }
 
@@ -143,8 +234,19 @@ void AliL3HoughEval::DisplaySlice(TH2F *hist)
   
 }
 
-TClonesArray *AliL3HoughEval::GetParticles(Char_t *rootfile)
+void AliL3HoughEval::DefineGoodParticles(Char_t *rootfile,Double_t pet)
 {
+  //define the particles that produce good enough signals to be recognized in the transform
+
+  Int_t num_eta_segments = fHoughTransformer->fNumEtaSegments;
+  Double_t eta_max = fHoughTransformer->fEtaMax;
+  fMcTrackTable = new Int_t[num_eta_segments];
+  for(Int_t i=0; i<num_eta_segments; i++)
+    fMcTrackTable[i]=0;
+  Double_t etaslice = eta_max/num_eta_segments;
+
+  Int_t patch = fHoughTransformer->fPatch;
+  Int_t slice = fHoughTransformer->fSlice;
   
   TFile *file = new TFile(rootfile);
   file->cd();
@@ -153,19 +255,88 @@ TClonesArray *AliL3HoughEval::GetParticles(Char_t *rootfile)
   gAlice->GetEvent(0);
   
   TClonesArray *particles=gAlice->Particles();
-  return particles;
-
+  Int_t np = particles->GetEntriesFast();
+  
+  Int_t row_to_miss = fNumOfRowsToMiss;
+  AliTPCParam *param = (AliTPCParam*)file->Get("75x40_100x60");
+  Int_t zero = param->GetZeroSup();
+  TTree *TD=(TTree*)gDirectory->Get("TreeD_75x40_100x60");
+  AliSimDigits da, *digits=&da;
+  TD->GetBranch("Segment")->SetAddress(&digits); //Return pointer to branch segment.
+  Int_t *good=new Int_t[np];
+  Int_t *count = new Int_t[np]; //np number of particles.
+  Int_t good_number = NRows[patch][1]-NRows[patch][0]-row_to_miss;
+  Int_t i;
+  for (i=0; i<np; i++) count[i]=0;
+  Int_t sectors_by_rows=(Int_t)TD->GetEntries();
+  for (i=0; i<sectors_by_rows; i++) 
+    {
+      if (!TD->GetEvent(i)) continue;
+      Int_t sec,row;
+      param->AdjustSectorRow(digits->GetID(),sec,row);
+      Int_t ss,sr;
+      fTransform->Sector2Slice(ss,sr,sec,row);
+      if(ss!=slice) continue;
+      if(sr < NRows[patch][0]) continue;
+      if(sr > NRows[patch][1]) break;
+      digits->First();
+      while (digits->Next()) {
+       Int_t it=digits->CurrentRow(), ip=digits->CurrentColumn();
+       Short_t dig = digits->GetDigit(it,ip);
+       Int_t idx0=digits->GetTrackID(it,ip,0); 
+       Int_t idx1=digits->GetTrackID(it,ip,1);
+       Int_t idx2=digits->GetTrackID(it,ip,2);
+       if (idx0>=0 && dig>=zero) count[idx0]+=1;
+       if (idx1>=0 && dig>=zero) count[idx1]+=1;
+       if (idx2>=0 && dig>=zero) count[idx2]+=1;
+      }
+      for (Int_t j=0; j<np; j++) 
+       {
+         if (count[j]>1) {//at least two digits at this padrow
+           good[j]++;
+         }
+         count[j]=0;
+       }
+    }
+  delete[] count;
+  
+  Int_t good_one=0;
+  //TObjArray *part = new TObjArray(0,0);
+  for(i=0; i<np; i++)
+   {
+     TParticle *p = (TParticle*)particles->UncheckedAt(i);
+     if(p->GetFirstMother()>0) continue; //secondary particle
+     if(good[i] < good_number) continue; //too few padrows
+     Double_t ptg=p->Pt();
+     if(ptg<pet) continue;
+     Int_t eta_index = (Int_t)(p->Eta()/etaslice);
+     if(eta_index < 0 || eta_index > num_eta_segments)
+       continue;
+     //fMcTrackTable[eta_index]++;
+     //part->AddLast(p);
+     good_one++;
+   }
+  
+  printf("nparticles %d\n",good_one);
   file->Close();
+  delete [] good;
   delete file;
+  //return part;
 }
 
 
 void AliL3HoughEval::CompareMC(Char_t *rootfile,AliL3TrackArray *merged_tracks,Float_t *eta)
 {
   
-  Int_t slice = fSlice;
+  Int_t slice = fHoughTransformer->fSlice;
+  
+  TFile *file = new TFile(rootfile);
+  file->cd();
+  
+  AliRun *gAlice = (AliRun*)file->Get("gAlice");
+  gAlice->GetEvent(0);
   
-  TClonesArray *particles = GetParticles(rootfile);
+  TClonesArray *particles=gAlice->Particles();  
   Int_t n=particles->GetEntriesFast();
   Float_t torad=TMath::Pi()/180;
   Float_t phi_min = slice*20 - 10;
@@ -209,5 +380,7 @@ void AliL3HoughEval::CompareMC(Char_t *rootfile,AliL3TrackArray *merged_tracks,F
     Double_t dphi0 = fabs(phi_part-sel_track->GetPhi0());
     //printf("Found match, min_dist %f dPt %f dPhi0 %f\n",min_dist,dpt,dphi0);
   }
-    
+  file->Close();
+  delete file;
+  
 }
index eb56a8acefc329c91ec6ee27d38ebd22faf2e27d..49c5e27511d1b0efb531b485ccfdd08a43cad5c5 100644 (file)
@@ -15,21 +15,31 @@ class AliL3HoughEval : public TObject {
   
  private:
   
-  Int_t fSlice;
   AliL3HoughTransformer *fHoughTransformer;
   AliL3Transform *fTransform; //!
-
+  Int_t fNumOfPadsToLook;
+  Int_t fNumOfRowsToMiss;
+  Int_t *fMcTrackTable;
+  
  public:
   AliL3HoughEval(); 
   AliL3HoughEval(AliL3HoughTransformer *transformer);
   virtual ~AliL3HoughEval();
 
-  TClonesArray *GetParticles(Char_t *rootfile);
-  void LookInsideRoad(AliL3TrackArray *tracks,Bool_t remove=(Bool_t)false,TH2F *hist=0);
+  void DefineGoodParticles(Char_t *rootfile,Double_t pet);
+  Bool_t LookInsideRoad(AliL3HoughTrack *track,Int_t eta_index,Bool_t remove=(Bool_t)kFALSE);
+  void LookInsideRawRoad(AliL3TrackArray *tracks,Int_t eta_index,Bool_t remove=(Bool_t)kFALSE);
+  void RemoveTrackFromImage(AliL3HoughTrack *track,Int_t eta_index);
+
   void DisplaySlice(TH2F *hist);
   void CompareMC(Char_t *rootfile,AliL3TrackArray *merged_tracks,Float_t *eta);
+  Int_t *GetMcTrackTable() {return fMcTrackTable;}
   
+  void SetNumOfPadsToLook(Int_t f) {fNumOfPadsToLook = f;}
+  void SetNumOfRowsToMiss(Int_t f) {fNumOfRowsToMiss = f;}
   void SetTransformer(AliL3HoughTransformer *t) {fHoughTransformer=t;}
+  
+
 
   ClassDef(AliL3HoughEval,1)