3 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
4 //*-- Copyright © ASV
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"
18 #include "AliL3FileHandler.h"
20 #include "AliL3MemHandler.h"
22 #include "AliL3DataHandler.h"
23 #include "AliL3DigitData.h"
24 #include "AliL3HoughEval.h"
25 #include "AliL3Transform.h"
26 #include "AliL3TrackArray.h"
27 #include "AliL3HoughTrack.h"
30 //_____________________________________________________________
33 // Interface class for the Hough transform
35 // Example how to use:
37 // AliL3Hough *hough = new AliL3Hough(path,kTRUE,NumberOfEtaSegments);
38 // hough->ReadData(slice);
39 // hough->Transform();
40 // hough->FindTrackCandidates();
42 // AliL3TrackArray *tracks = hough->GetTracks(patch);
46 AliL3Hough::AliL3Hough()
52 fAddHistograms = kFALSE;
53 fDoIterative = kFALSE;
57 fHoughTransformer = 0;
67 AliL3Hough::~AliL3Hough()
82 void AliL3Hough::CleanUp()
86 for(Int_t i=0; i<fNPatches; i++)
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];
95 if(fTracks) delete [] fTracks;
96 if(fEval) delete [] fEval;
97 if(fHoughTransformer) delete [] fHoughTransformer;
98 if(fMemHandler) delete [] fMemHandler;
102 void AliL3Hough::Init(Char_t *path,Bool_t binary,Int_t n_eta_segments,Bool_t bit8=kFALSE)
106 fNEtaSegments = n_eta_segments;
107 fAddHistograms = kFALSE;
108 fDoIterative = kFALSE;
109 fWriteDigits = kFALSE;
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++)
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");
126 fMemHandler[i] = new AliL3DataHandler();
130 fMemHandler[i] = new AliL3FileHandler();
132 fMemHandler[i]->SetAliInput(fPath);
135 fMemHandler[i] = new AliL3MemHandler();
138 fPeakFinder = new AliL3HoughMaxFinder("KappaPhi",100);
139 fMerger = new AliL3HoughMerger(fNPatches);
140 fInterMerger = new AliL3HoughIntMerger();
144 void AliL3Hough::Process(Int_t minslice,Int_t maxslice)
146 //Process all slices [minslice,maxslice].
147 fGlobalMerger = new AliL3HoughGlobalMerger(minslice,maxslice);
149 for(Int_t i=minslice; i<=maxslice; i++)
155 FindTrackCandidates();
157 fGlobalMerger->FillTracks(fTracks[0],i);
163 void AliL3Hough::ReadData(Int_t slice,Int_t eventnr=0)
165 //Read data from files, binary or root.
167 for(Int_t i=0; i<fNPatches; i++)
169 fMemHandler[i]->Free();
171 AliL3DigitRowData *digits =0;
173 fMemHandler[i]->Init(slice,i);
174 if(fBinary)//take input data from binary files
177 sprintf(name,"%sdigits_c8_%d_%d.raw",fPath,slice,i);
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();
184 else //read data from root file
187 digits=(AliL3DigitRowData *)fMemHandler[i]->AliDigits2Memory(ndigits,eventnr);
188 fMemHandler[i]->FreeDigitsTree();
190 cerr<<"You cannot read from rootfile now"<<endl;
193 fHoughTransformer[i]->SetInputData(ndigits,digits);
197 void AliL3Hough::Transform(Int_t row_range)
199 //Transform all data given to the transformer within the given slice
200 //(after ReadData(slice))
202 for(Int_t i=0; i<fNPatches; i++)
204 fHoughTransformer[i]->Reset();//Reset the histograms
206 fHoughTransformer[i]->TransformCircle();
208 fHoughTransformer[i]->TransformCircleC(row_range);
212 void AliL3Hough::MergePatches()
214 if(fAddHistograms) //Nothing to merge here
216 fMerger->MergePatches(kTRUE);
219 void AliL3Hough::MergeInternally()
222 fInterMerger->FillTracks(fTracks[0]);
224 fInterMerger->FillTracks(fMerger->GetOutTracks());
226 fInterMerger->MMerge();
229 void AliL3Hough::ProcessSliceIter()
231 //Process current slice (after ReadData(slice)) iteratively.
233 for(Int_t i=0; i<fNPatches; i++)
236 fMerger->FillTracks(fTracks[i],i); //Copy tracks to merger
241 void AliL3Hough::ProcessPatchIter(Int_t patch)
243 //Process patch in a iterative way.
244 //transform + peakfinding + evaluation + transform +...
246 Int_t num_of_tries = 10;
247 AliL3HoughBaseTransformer *tr = fHoughTransformer[patch];
248 AliL3TrackArray *tracks = fTracks[patch];
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++)
259 tr->TransformCircle();
260 for(Int_t i=0; i<fNEtaSegments; i++)
262 hist = tr->GetHistogram(i);
263 if(hist->GetNEntries()==0) continue;
264 fPeakFinder->SetHistogram(hist);
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))
273 tracks->Remove(tracks->GetNTracks()-1);
278 LOG(AliL3Log::kInformational,"AliL3Hough::ProcessPatch","NTracks")
279 <<AliL3Log::kDec<<"Found "<<tracks->GetNTracks()<<" tracks in patch "<<patch<<ENDLOG;
283 void AliL3Hough::AddAllHistograms()
285 //Add the histograms within one etaslice.
286 //Resulting histogram are in patch=0.
288 for(Int_t i=0; i<fNEtaSegments; i++)
290 AliL3Histogram *hist0 = fHoughTransformer[0]->GetHistogram(i);
291 for(Int_t j=1; j<fNPatches; j++)
293 AliL3Histogram *hist = fHoughTransformer[j]->GetHistogram(i);
297 fAddHistograms = kTRUE;
300 void AliL3Hough::FindTrackCandidates()
302 //Look for peaks in histograms, and find the track candidates
306 n_patches = 1; //Histograms has been added.
308 n_patches = fNPatches;
311 for(Int_t i=0; i<n_patches; i++)
313 AliL3HoughBaseTransformer *tr = fHoughTransformer[i];
314 Double_t eta_slice = (tr->GetEtaMax()-tr->GetEtaMin())/tr->GetNEtaSegments();
316 for(Int_t j=0; j<fNEtaSegments; j++)
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++)
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));
339 void AliL3Hough::InitEvaluate()
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.
345 for(Int_t i=0; i<fNPatches; i++)
346 fEval[i]->InitTransformer(fHoughTransformer[i]);
349 void AliL3Hough::Evaluate(Int_t road_width)
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.
356 LOG(AliL3Log::kError,"AliL3Hough::Evaluate","Track Array")
357 <<"No tracks to work with..."<<ENDLOG;
363 AliL3TrackArray *tracks;
364 for(Int_t i=0; i<fNPatches; i++)
366 fEval[i]->SetNumOfRowsToMiss(2);
367 fEval[i]->SetNumOfPadsToLook(road_width);
372 for(Int_t j=0; j<tracks->GetNTracks(); j++)
374 AliL3HoughTrack *track = (AliL3HoughTrack*)tracks->GetCheckedTrack(j);
377 LOG(AliL3Log::kWarning,"AliL3Hough::Evaluate","Track array")
378 <<"Track object missing!"<<ENDLOG;
382 if(!fEval[i]->LookInsideRoad(track,track->GetEtaIndex()))
385 track->SetRowRange(AliL3Transform::GetFirstRow(0),AliL3Transform::GetLastRow(5));//All rows included
388 tracks->QSort(); //Sort the tracks according to weight
391 fMerger->FillTracks(tracks,i); //Copy tracks to the track merger
396 void AliL3Hough::EvaluateWithEta()
402 printf("AliL3Hough::EvaluateWithEta: NO TRACKS\n");
405 printf("Number of tracks before evaluation %d\n",fTracks[0]->GetNTracks());
407 for(Int_t i=0; i<fNPatches; i++)
409 fEval[i]->InitTransformer(fHoughTransformer[i]);
410 fEval[i]->FindEta(fTracks[0]);
412 fMerger->FillTracks(fTracks[0],0);
415 void AliL3Hough::WriteTracks(Int_t slice,Char_t *path)
417 //Write the tracks in slice
419 AliL3MemHandler *mem = new AliL3MemHandler();
423 sprintf(fname,"%s/tracks_ho_%d.raw",path,slice);
424 mem->SetBinaryOutput(fname);
425 mem->TrackArray2Binary(fTracks[0]);
426 mem->CloseBinaryOutput();
430 for(Int_t i=0; i<fNPatches; i++)
432 sprintf(fname,"%s/tracks_ho_%d_%d.raw",path,slice,i);
433 mem->SetBinaryOutput(fname);
434 mem->TrackArray2Binary(fTracks[i]);
435 mem->CloseBinaryOutput();
442 void AliL3Hough::WriteDigits(Char_t *outfile)
445 //Write the current data to a new rootfile.
447 for(Int_t i=0; i<fNPatches; i++)
449 AliL3DigitRowData *tempPt = (AliL3DigitRowData*)fHoughTransformer[i]->GetDataPointer();
450 fMemHandler[i]->AliDigits2RootFile(tempPt,outfile);
453 cerr<<"AliL3Hough::WriteDigits : You need to compile with AliROOT!"<<endl;