HLT/hough/AliL3Hough.cxx

   1 //$Id$
   2
   3 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
   4 //*-- Copyright &copy ASV
   5
   6
   7 #include <string.h>
   8
   9 #include "AliL3HoughMerger.h"
  10 #include "AliL3HoughIntMerger.h"
  11 #include "AliL3HoughGlobalMerger.h"
  12 #include "AliL3Logging.h"
  13 #include "AliL3Histogram.h"
  14 #include "AliL3Hough.h"
  15 #include "AliL3HoughTransformer.h"
  16 #include "AliL3HoughMaxFinder.h"
  17 #ifdef use_aliroot
  18 #include "AliL3FileHandler.h"
  19 #else
  20 #include "AliL3MemHandler.h"
  21 #endif
  22 #include "AliL3DataHandler.h"
  23 #include "AliL3DigitData.h"
  24 #include "AliL3HoughEval.h"
  25 #include "AliL3Transform.h"
  26 #include "AliL3TrackArray.h"
  27 #include "AliL3HoughTrack.h"
  28
  29
  30 //_____________________________________________________________
  31 // AliL3Hough
  32 //
  33 // Interface class for the Hough transform
  34 //
  35 // Example how to use:
  36 //
  37 // AliL3Hough *hough = new AliL3Hough(path,kTRUE,NumberOfEtaSegments);
  38 // hough->ReadData(slice);
  39 // hough->Transform();
  40 // hough->FindTrackCandidates();
  41 //
  42 // AliL3TrackArray *tracks = hough->GetTracks(patch);
  43
  44 ClassImp(AliL3Hough)
  45
  46 AliL3Hough::AliL3Hough()
  47 {
  48   //Constructor
  49
  50   fBinary = kFALSE;
  51   fNEtaSegments = 0;
  52   fAddHistograms = kFALSE;
  53   fDoIterative = kFALSE;
  54   fWriteDigits=kFALSE;
  55   fNPatches=0;
  56   fMemHandler = 0;
  57   fHoughTransformer = 0;
  58   fEval = 0;
  59   fPeakFinder = 0;
  60   fTracks = 0;
  61   fMerger = 0;
  62   fInterMerger = 0;
  63   fGlobalMerger = 0;
  64 }
  65
  66
  67 AliL3Hough::~AliL3Hough()
  68 {
  69   //dtor
  70
  71   CleanUp();
  72   if(fMerger)
  73     delete fMerger;
  74   if(fInterMerger)
  75     delete fInterMerger;
  76   if(fPeakFinder)
  77     delete fPeakFinder;
  78   if(fGlobalMerger)
  79     delete fGlobalMerger;
  80 }
  81
  82 void AliL3Hough::CleanUp()
  83 {
  84   //Cleanup memory
  85
  86   for(Int_t i=0; i<fNPatches; i++)
  87     {
  88       if(fTracks[i]) delete fTracks[i];
  89       if(fEval[i]) delete fEval[i];
  90       if(fHoughTransformer[i]) delete fHoughTransformer[i];
  91       if(fMemHandler[i]) delete fMemHandler[i];
  92     }
  93
  94   /*
  95   if(fTracks) delete [] fTracks;
  96   if(fEval) delete [] fEval;
  97   if(fHoughTransformer) delete [] fHoughTransformer;
  98   if(fMemHandler) delete [] fMemHandler;
  99   */
 100 }
 101
 102 void AliL3Hough::Init(Char_t *path,Bool_t binary,Int_t n_eta_segments,Bool_t bit8=kFALSE)
 103 {
 104   fBinary = binary;
 105   strcpy(fPath,path);
 106   fNEtaSegments = n_eta_segments;
 107   fAddHistograms = kFALSE;
 108   fDoIterative = kFALSE;
 109   fWriteDigits = kFALSE;
 110   fUse8bits = bit8;
 111
 112   AliL3Transform::Init(fPath);
 113   fNPatches = AliL3Transform::GetNPatches();
 114   fHoughTransformer = new AliL3HoughBaseTransformer*[fNPatches];
 115   fMemHandler = new AliL3MemHandler*[fNPatches];
 116   fTracks = new AliL3TrackArray*[fNPatches];
 117   fEval = new AliL3HoughEval*[fNPatches];
 118   for(Int_t i=0; i<fNPatches; i++)
 119     {
 120       fHoughTransformer[i] = new AliL3HoughTransformer(0,i,fNEtaSegments);
 121       fHoughTransformer[i]->CreateHistograms(64,0.1,64,-30,30);
 122       fHoughTransformer[i]->SetThreshold(3);
 123       fEval[i] = new AliL3HoughEval();
 124       fTracks[i] = new AliL3TrackArray("AliL3HoughTrack");
 125       if(fUse8bits)
 126         fMemHandler[i] = new AliL3DataHandler();
 127       else
 128 #ifdef use_aliroot
 129         {
 130           fMemHandler[i] = new AliL3FileHandler();
 131           if(!fBinary)
 132             fMemHandler[i]->SetAliInput(fPath);
 133         }
 134 #else
 135       fMemHandler[i] = new AliL3MemHandler();
 136 #endif
 137     }
 138   fPeakFinder = new AliL3HoughMaxFinder("KappaPhi",100);
 139   fMerger = new AliL3HoughMerger(fNPatches);
 140   fInterMerger = new AliL3HoughIntMerger();
 141   fGlobalMerger = 0;
 142 }
 143
 144 void AliL3Hough::Process(Int_t minslice,Int_t maxslice)
 145 {
 146   //Process all slices [minslice,maxslice].
 147   fGlobalMerger = new AliL3HoughGlobalMerger(minslice,maxslice);
 148
 149   for(Int_t i=minslice; i<=maxslice; i++)
 150     {
 151       ReadData(i);
 152       Transform();
 153       if(fAddHistograms)
 154         AddAllHistograms();
 155       FindTrackCandidates();
 156       Evaluate();
 157       fGlobalMerger->FillTracks(fTracks[0],i);
 158     }
 159
 160
 161 }
 162
 163 void AliL3Hough::ReadData(Int_t slice,Int_t eventnr=0)
 164 {
 165   //Read data from files, binary or root.
 166
 167   for(Int_t i=0; i<fNPatches; i++)
 168     {
 169       fMemHandler[i]->Free();
 170       UInt_t ndigits=0;
 171       AliL3DigitRowData *digits =0;
 172       Char_t name[256];
 173       fMemHandler[i]->Init(slice,i);
 174       if(fBinary)//take input data from binary files
 175         {
 176           if(fUse8bits)
 177             sprintf(name,"%sdigits_c8_%d_%d.raw",fPath,slice,i);
 178           else
 179             sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,i);
 180           fMemHandler[i]->SetBinaryInput(name);
 181           digits = (AliL3DigitRowData *)fMemHandler[i]->CompBinary2Memory(ndigits);
 182           fMemHandler[i]->CloseBinaryInput();
 183         }
 184       else //read data from root file
 185         {
 186 #ifdef use_aliroot
 187           digits=(AliL3DigitRowData *)fMemHandler[i]->AliDigits2Memory(ndigits,eventnr);
 188           fMemHandler[i]->FreeDigitsTree();
 189 #else
 190           cerr<<"You cannot read from rootfile now"<<endl;
 191 #endif
 192         }
 193       fHoughTransformer[i]->SetInputData(ndigits,digits);
 194     }
 195 }
 196
 197 void AliL3Hough::Transform(Int_t row_range)
 198 {
 199   //Transform all data given to the transformer within the given slice
 200   //(after ReadData(slice))
 201
 202   for(Int_t i=0; i<fNPatches; i++)
 203     {
 204       fHoughTransformer[i]->Reset();//Reset the histograms
 205       if(row_range < 0)
 206         fHoughTransformer[i]->TransformCircle();
 207       else
 208         fHoughTransformer[i]->TransformCircleC(row_range);
 209     }
 210 }
 211
 212 void AliL3Hough::MergePatches()
 213 {
 214   if(fAddHistograms) //Nothing to merge here
 215     return;
 216   fMerger->MergePatches(kTRUE);
 217 }
 218
 219 void AliL3Hough::MergeInternally()
 220 {
 221   if(fAddHistograms)
 222     fInterMerger->FillTracks(fTracks[0]);
 223   else
 224     fInterMerger->FillTracks(fMerger->GetOutTracks());
 225
 226   fInterMerger->MMerge();
 227 }
 228
 229 void AliL3Hough::ProcessSliceIter()
 230 {
 231   //Process current slice (after ReadData(slice)) iteratively.
 232
 233   for(Int_t i=0; i<fNPatches; i++)
 234     {
 235       ProcessPatchIter(i);
 236       fMerger->FillTracks(fTracks[i],i); //Copy tracks to merger
 237     }
 238
 239 }
 240
 241 void AliL3Hough::ProcessPatchIter(Int_t patch)
 242 {
 243   //Process patch in a iterative way.
 244   //transform + peakfinding + evaluation + transform +...
 245
 246   Int_t num_of_tries = 10;
 247   AliL3HoughBaseTransformer *tr = fHoughTransformer[patch];
 248   AliL3TrackArray *tracks = fTracks[patch];
 249   tracks->Reset();
 250   AliL3HoughEval *ev = fEval[patch];
 251   ev->InitTransformer(tr);
 252   ev->RemoveFoundTracks();
 253   ev->SetNumOfRowsToMiss(2);
 254   ev->SetNumOfPadsToLook(2);
 255   AliL3Histogram *hist;
 256   for(Int_t t=0; t<num_of_tries; t++)
 257     {
 258       tr->Reset();
 259       tr->TransformCircle();
 260       for(Int_t i=0; i<fNEtaSegments; i++)
 261         {
 262           hist = tr->GetHistogram(i);
 263           if(hist->GetNEntries()==0) continue;
 264           fPeakFinder->SetHistogram(hist);
 265           //Int_t n=1;
 266           Float_t x,y;
 267           //fPeakFinder->FindAbsMaxima(*x,*y);
 268           fPeakFinder->FindPeak(3,0.95,5,x,y);
 269           AliL3HoughTrack *track = (AliL3HoughTrack*)tracks->NextTrack();
 270           track->SetTrackParameters(x,y,1);
 271           if(!ev->LookInsideRoad(track,i))
 272             {
 273               tracks->Remove(tracks->GetNTracks()-1);
 274               tracks->Compress();
 275             }
 276         }
 277     }
 278   LOG(AliL3Log::kInformational,"AliL3Hough::ProcessPatch","NTracks")
 279     <<AliL3Log::kDec<<"Found "<<tracks->GetNTracks()<<" tracks in patch "<<patch<<ENDLOG;
 280 }
 281
 282
 283 void AliL3Hough::AddAllHistograms()
 284 {
 285   //Add the histograms within one etaslice.
 286   //Resulting histogram are in patch=0.
 287
 288   for(Int_t i=0; i<fNEtaSegments; i++)
 289     {
 290       AliL3Histogram *hist0 = fHoughTransformer[0]->GetHistogram(i);
 291       for(Int_t j=1; j<fNPatches; j++)
 292         {
 293           AliL3Histogram *hist = fHoughTransformer[j]->GetHistogram(i);
 294           hist0->Add(hist);
 295         }
 296     }
 297   fAddHistograms = kTRUE;
 298 }
 299
 300 void AliL3Hough::FindTrackCandidates()
 301 {
 302   //Look for peaks in histograms, and find the track candidates
 303
 304   Int_t n_patches;
 305   if(fAddHistograms)
 306     n_patches = 1; //Histograms has been added.
 307   else
 308     n_patches = fNPatches;
 309
 310
 311   for(Int_t i=0; i<n_patches; i++)
 312     {
 313       AliL3HoughBaseTransformer *tr = fHoughTransformer[i];
 314       Double_t eta_slice = (tr->GetEtaMax()-tr->GetEtaMin())/tr->GetNEtaSegments();
 315       fTracks[i]->Reset();
 316       for(Int_t j=0; j<fNEtaSegments; j++)
 317         {
 318           AliL3Histogram *hist = tr->GetHistogram(j);
 319           if(hist->GetNEntries()==0) continue;
 320           fPeakFinder->Reset();
 321           fPeakFinder->SetHistogram(hist);
 322           fPeakFinder->FindMaxima(0,0); //Simple maxima finder
 323           //fPeakFinder->FindAbsMaxima();
 324           cout<<"Found "<<fPeakFinder->GetEntries()<<endl;
 325           for(Int_t k=0; k<fPeakFinder->GetEntries(); k++)
 326             {
 327               if(fPeakFinder->GetWeight(k) == 0) continue;
 328               AliL3HoughTrack *track = (AliL3HoughTrack*)fTracks[i]->NextTrack();
 329               track->SetTrackParameters(fPeakFinder->GetXPeak(k),fPeakFinder->GetYPeak(k),fPeakFinder->GetWeight(k));
 330               track->SetEtaIndex(j);
 331               track->SetEta((Double_t)(j*eta_slice));
 332               track->SetRowRange(AliL3Transform::GetFirstRow(0),AliL3Transform::GetLastRow(5));
 333             }
 334         }
 335       fTracks[i]->QSort();
 336     }
 337 }
 338
 339 void AliL3Hough::InitEvaluate()
 340 {
 341   //Pass the transformer objects to the AliL3HoughEval objects:
 342   //This will provide the evaluation objects with all the necessary
 343   //data and parameters it needs.
 344
 345   for(Int_t i=0; i<fNPatches; i++)
 346     fEval[i]->InitTransformer(fHoughTransformer[i]);
 347 }
 348
 349 void AliL3Hough::Evaluate(Int_t road_width)
 350 {
 351   //Evaluate the tracks, by looking along the road in the raw data.
 352   //If track does not cross all padrows - rows2miss, it is removed from the arrray.
 353
 354   if(!fTracks[0])
 355     {
 356       LOG(AliL3Log::kError,"AliL3Hough::Evaluate","Track Array")
 357         <<"No tracks to work with..."<<ENDLOG;
 358       return;
 359     }
 360
 361   InitEvaluate();
 362
 363   AliL3TrackArray *tracks;
 364   for(Int_t i=0; i<fNPatches; i++)
 365     {
 366       fEval[i]->SetNumOfRowsToMiss(2);
 367       fEval[i]->SetNumOfPadsToLook(road_width);
 368       if(fAddHistograms)
 369         tracks = fTracks[0];
 370       else
 371         tracks = fTracks[i];
 372       for(Int_t j=0; j<tracks->GetNTracks(); j++)
 373         {
 374           AliL3HoughTrack *track = (AliL3HoughTrack*)tracks->GetCheckedTrack(j);
 375           if(!track)
 376             {
 377               LOG(AliL3Log::kWarning,"AliL3Hough::Evaluate","Track array")
 378                 <<"Track object missing!"<<ENDLOG;
 379               continue;
 380             }
 381
 382           if(!fEval[i]->LookInsideRoad(track,track->GetEtaIndex()))
 383             tracks->Remove(j);
 384           if(fAddHistograms)
 385             track->SetRowRange(AliL3Transform::GetFirstRow(0),AliL3Transform::GetLastRow(5));//All rows included
 386         }
 387       tracks->Compress();
 388       tracks->QSort(); //Sort the tracks according to weight
 389
 390       if(!fAddHistograms)
 391         fMerger->FillTracks(tracks,i); //Copy tracks to the track merger
 392     }
 393
 394 }
 395
 396 void AliL3Hough::EvaluateWithEta()
 397 {
 398
 399
 400   if(!fTracks[0])
 401     {
 402       printf("AliL3Hough::EvaluateWithEta: NO TRACKS\n");
 403       return;
 404     }
 405   printf("Number of tracks before evaluation %d\n",fTracks[0]->GetNTracks());
 406
 407   for(Int_t i=0; i<fNPatches; i++)
 408     {
 409       fEval[i]->InitTransformer(fHoughTransformer[i]);
 410       fEval[i]->FindEta(fTracks[0]);
 411     }
 412   fMerger->FillTracks(fTracks[0],0);
 413 }
 414
 415 void AliL3Hough::WriteTracks(Int_t slice,Char_t *path)
 416 {
 417   //Write the tracks in slice
 418
 419   AliL3MemHandler *mem = new AliL3MemHandler();
 420   Char_t fname[100];
 421   if(fAddHistograms)
 422     {
 423       sprintf(fname,"%s/tracks_ho_%d.raw",path,slice);
 424       mem->SetBinaryOutput(fname);
 425       mem->TrackArray2Binary(fTracks[0]);
 426       mem->CloseBinaryOutput();
 427     }
 428   else
 429     {
 430       for(Int_t i=0; i<fNPatches; i++)
 431         {
 432           sprintf(fname,"%s/tracks_ho_%d_%d.raw",path,slice,i);
 433           mem->SetBinaryOutput(fname);
 434           mem->TrackArray2Binary(fTracks[i]);
 435           mem->CloseBinaryOutput();
 436         }
 437     }
 438   delete mem;
 439
 440 }
 441
 442 void AliL3Hough::WriteDigits(Char_t *outfile)
 443 {
 444 #ifdef use_aliroot
 445   //Write the current data to a new rootfile.
 446
 447   for(Int_t i=0; i<fNPatches; i++)
 448     {
 449       AliL3DigitRowData *tempPt = (AliL3DigitRowData*)fHoughTransformer[i]->GetDataPointer();
 450       fMemHandler[i]->AliDigits2RootFile(tempPt,outfile);
 451     }
 452 #else
 453   cerr<<"AliL3Hough::WriteDigits : You need to compile with AliROOT!"<<endl;
 454   return;
 455 #endif
 456 }
 457