3 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
4 //*-- Copyright © ALICE HLT Group
6 #include "AliL3StandardIncludes.h"
9 #include "AliL3Logging.h"
10 #include "AliL3HoughMerger.h"
11 #include "AliL3HoughIntMerger.h"
12 #include "AliL3HoughGlobalMerger.h"
13 #include "AliL3Histogram.h"
14 #include "AliL3Hough.h"
15 #include "AliL3HoughTransformer.h"
16 #include "AliL3HoughClusterTransformer.h"
17 #include "AliL3HoughTransformerLUT.h"
18 #include "AliL3HoughTransformerVhdl.h"
19 #include "AliL3HoughTransformerRow.h"
20 #include "AliL3HoughMaxFinder.h"
21 #include "AliL3Benchmark.h"
23 #include "AliL3FileHandler.h"
25 #include "AliL3MemHandler.h"
27 #include "AliL3DataHandler.h"
28 #include "AliL3DigitData.h"
29 #include "AliL3HoughEval.h"
30 #include "AliL3Transform.h"
31 #include "AliL3TrackArray.h"
32 #include "AliL3HoughTrack.h"
33 #include "AliL3DDLDataFileHandler.h"
41 //_____________________________________________________________
44 // Interface class for the Hough transform
46 // Example how to use:
48 // AliL3Hough *hough = new AliL3Hough(path,kTRUE,NumberOfEtaSegments);
49 // hough->ReadData(slice);
50 // hough->Transform();
51 // hough->FindTrackCandidates();
53 // AliL3TrackArray *tracks = hough->GetTracks(patch);
60 AliL3Hough::AliL3Hough()
65 fAddHistograms = kFALSE;
66 fDoIterative = kFALSE;
67 fWriteDigits = kFALSE;
71 fHoughTransformer = 0;
92 SetTransformerParams();
97 //just be sure that index is empty for new event
98 AliL3FileHandler::CleanStaticIndex();
102 AliL3Hough::AliL3Hough(Char_t *path,Bool_t binary,Int_t n_eta_segments,Bool_t bit8,Int_t tv,Char_t *infile,Char_t *ptr)
106 fNEtaSegments = n_eta_segments;
107 fAddHistograms = kFALSE;
108 fDoIterative = kFALSE;
109 fWriteDigits = kFALSE;
129 //just be sure that index is empty for new event
130 AliL3FileHandler::CleanStaticIndex();
134 AliL3Hough::~AliL3Hough()
141 //cout << "Cleaned class merger " << endl;
144 //cout << "Cleaned class inter " << endl;
147 //cout << "Cleaned class peak " << endl;
149 delete fGlobalMerger;
150 //cout << "Cleaned class global " << endl;
153 //cout << "Cleaned class bench " << endl;
155 delete fGlobalTracks;
156 //cout << "Cleaned class globaltracks " << endl;
159 void AliL3Hough::CleanUp()
163 for(Int_t i=0; i<fNPatches; i++)
165 if(fTracks[i]) delete fTracks[i];
166 //cout << "Cleaned tracks " << i << endl;
167 if(fEval[i]) delete fEval[i];
168 //cout << "Cleaned eval " << i << endl;
169 if(fHoughTransformer[i]) delete fHoughTransformer[i];
170 //cout << "Cleaned traf " << i << endl;
171 if(fMemHandler[i]) delete fMemHandler[i];
172 //cout << "Cleaned mem " << i << endl;
175 if(fTracks) delete [] fTracks;
176 //cout << "Cleaned class tracks " << endl;
177 if(fEval) delete [] fEval;
178 //cout << "Cleaned class eval " << endl;
179 if(fHoughTransformer) delete [] fHoughTransformer;
180 //cout << "Cleaned cleass trafo " << endl;
181 if(fMemHandler) delete [] fMemHandler;
182 //cout << "Cleaned class mem " << endl;
185 void AliL3Hough::Init(Char_t *path,Bool_t binary,Int_t n_eta_segments,Bool_t bit8,Int_t tv,Char_t *infile,Char_t *ptr,Float_t zvertex)
189 fNEtaSegments = n_eta_segments;
190 fWriteDigits = kFALSE;
209 Init(); //do the rest
212 void AliL3Hough::Init(Bool_t doit, Bool_t addhists)
215 fAddHistograms = addhists;
217 fNPatches = AliL3Transform::GetNPatches();
219 fHoughTransformer = new AliL3HoughBaseTransformer*[fNPatches];
220 fMemHandler = new AliL3MemHandler*[fNPatches];
222 fTracks = new AliL3TrackArray*[fNPatches];
223 fEval = new AliL3HoughEval*[fNPatches];
225 fGlobalTracks = new AliL3TrackArray("AliL3HoughTrack");
227 for(Int_t i=0; i<fNPatches; i++)
229 switch (fVersion){ //choose Transformer
231 fHoughTransformer[i] = new AliL3HoughTransformerLUT(0,i,fNEtaSegments);
234 fHoughTransformer[i] = new AliL3HoughClusterTransformer(0,i,fNEtaSegments);
237 fHoughTransformer[i] = new AliL3HoughTransformerVhdl(0,i,fNEtaSegments,fNSaveIterations);
240 fHoughTransformer[i] = new AliL3HoughTransformerRow(0,i,fNEtaSegments,kFALSE,fZVertex);
243 fHoughTransformer[i] = new AliL3HoughTransformer(0,i,fNEtaSegments,kFALSE,kFALSE);
246 fHoughTransformer[i]->CreateHistograms(fNBinX[i],fLowPt[i],fNBinY[i],-fPhi[i],fPhi[i]);
247 //fHoughTransformer[i]->CreateHistograms(fLowPt[i],fUpperPt[i],fPtRes[i],fNBinY[i],fPhi[i]);
249 fHoughTransformer[i]->SetLowerThreshold(fThreshold[i]);
250 fHoughTransformer[i]->SetUpperThreshold(100);
252 LOG(AliL3Log::kInformational,"AliL3Hough::Init","Version")
253 <<"Initializing Hough transformer version "<<fVersion<<ENDLOG;
255 fEval[i] = new AliL3HoughEval();
256 fTracks[i] = new AliL3TrackArray("AliL3HoughTrack");
258 fMemHandler[i] = new AliL3DataHandler();
264 /* In case of reading digits file */
265 fMemHandler[i] = new AliL3FileHandler(kTRUE); //use static index
267 Char_t filename[1024];
268 sprintf(filename,"%s/digitfile.root",fPath);
269 fMemHandler[i]->SetAliInput(filename);
273 /* In case of reading from DATE */
274 fMemHandler[i] = new AliL3DDLDataFileHandler();
275 fMemHandler[i]->SetReaderInput(fInputPtr,-1);
279 /* In case of reading rawdata from ROOT file */
280 fMemHandler[i] = new AliL3DDLDataFileHandler();
281 fMemHandler[i]->SetReaderInput(fInputFile);
285 fMemHandler[i] = new AliL3MemHandler();
289 fPeakFinder = new AliL3HoughMaxFinder("KappaPhi",1000);
290 fMerger = new AliL3HoughMerger(fNPatches);
291 fInterMerger = new AliL3HoughIntMerger();
293 fBenchmark = new AliL3Benchmark();
296 void AliL3Hough::SetTransformerParams(Float_t ptres,Float_t ptmin,Float_t ptmax,Int_t ny,Int_t patch)
304 mrow = AliL3Transform::GetLastRow(patch);
307 Double_t lineradius = sqrt(pow(AliL3Transform::Row2X(mrow),2) + pow(AliL3Transform::GetMaxY(mrow),2));
308 Double_t kappa = -1*AliL3Transform::GetBField()*AliL3Transform::GetBFact()/ptmin;
309 psi = AliL3Transform::Deg2Rad(10) - asin(lineradius*kappa/2);
310 cout<<"Calculated psi range "<<psi<<" in patch "<<patch<<endl;
329 fPtRes[patch] = ptres;
330 fLowPt[patch] = ptmin;
331 fUpperPt[patch] = ptmax;
336 void AliL3Hough::SetTransformerParams(Int_t nx,Int_t ny,Float_t ptmin,Int_t patch)
340 Double_t lineradius = sqrt(pow(AliL3Transform::Row2X(mrow),2) + pow(AliL3Transform::GetMaxY(mrow),2));
341 Double_t kappa = -1*AliL3Transform::GetBField()*AliL3Transform::GetBFact()/ptmin;
342 Double_t psi = AliL3Transform::Deg2Rad(10) - asin(lineradius*kappa/2);
343 cout<<"Calculated psi range "<<psi<<" in patch "<<patch<<endl;
356 void AliL3Hough::SetTransformerParams(Int_t nx,Int_t ny,Float_t lpt,Float_t phi)
369 void AliL3Hough::SetThreshold(Int_t t3,Int_t patch)
378 fThreshold[patch]=t3;
381 void AliL3Hough::SetPeakThreshold(Int_t threshold,Int_t patch)
387 fPeakThreshold[i++]=threshold;
390 fPeakThreshold[patch]=threshold;
393 void AliL3Hough::DoBench(Char_t *name)
395 fBenchmark->Analyze(name);
398 void AliL3Hough::Process(Int_t minslice,Int_t maxslice)
400 //Process all slices [minslice,maxslice].
401 fGlobalMerger = new AliL3HoughGlobalMerger(minslice,maxslice);
403 for(Int_t i=minslice; i<=maxslice; i++)
411 AddAllHistogramsRows();
413 FindTrackCandidates();
415 //fGlobalMerger->FillTracks(fTracks[0],i);
419 void AliL3Hough::ReadData(Int_t slice,Int_t eventnr)
421 //Read data from files, binary or root.
424 if(fEvent!=eventnr) //just be sure that index is empty for new event
425 AliL3FileHandler::CleanStaticIndex();
427 fCurrentSlice = slice;
429 for(Int_t i=0; i<fNPatches; i++)
431 fMemHandler[i]->Free();
433 AliL3DigitRowData *digits =0;
435 fMemHandler[i]->Init(slice,i);
436 if(fBinary)//take input data from binary files
439 sprintf(name,"%s/binaries/digits_c8_%d_%d_%d.raw",fPath,eventnr,slice,i);
441 sprintf(name,"%s/binaries/digits_%d_%d_%d.raw",fPath,eventnr,slice,i);
443 fMemHandler[i]->SetBinaryInput(name);
444 digits = (AliL3DigitRowData *)fMemHandler[i]->CompBinary2Memory(ndigits);
445 fMemHandler[i]->CloseBinaryInput();
447 else //read data from root file
451 fMemHandler[i]->FreeDigitsTree();//or else the new event is not loaded
452 digits=(AliL3DigitRowData *)fMemHandler[i]->AliAltroDigits2Memory(ndigits,eventnr);
454 cerr<<"You cannot read from rootfile now"<<endl;
458 //set input data and init transformer
459 fHoughTransformer[i]->SetInputData(ndigits,digits);
460 fHoughTransformer[i]->Init(slice,i,fNEtaSegments);
466 void AliL3Hough::Transform(Int_t *row_range)
468 //Transform all data given to the transformer within the given slice
469 //(after ReadData(slice))
471 Double_t initTime,cpuTime;
472 initTime = GetCpuTime();
473 for(Int_t i=0; i<fNPatches; i++)
475 // In case of Row transformer reset the arrays only once
476 if((fVersion != 4) || (i == 0))
477 fHoughTransformer[i]->Reset();//Reset the histograms
478 fBenchmark->Start("Hough Transform");
480 fHoughTransformer[i]->TransformCircle();
482 fHoughTransformer[i]->TransformCircleC(row_range,1);
483 fBenchmark->Stop("Hough Transform");
485 cpuTime = GetCpuTime() - initTime;
486 LOG(AliL3Log::kInformational,"AliL3Hough::Transform()","Timing")
487 <<"Transform done in average per patch of "<<cpuTime*1000/fNPatches<<" ms"<<ENDLOG;
490 void AliL3Hough::MergePatches()
492 if(fAddHistograms) //Nothing to merge here
494 fMerger->MergePatches(kTRUE);
497 void AliL3Hough::MergeInternally()
500 fInterMerger->FillTracks(fTracks[0]);
502 fInterMerger->FillTracks(fMerger->GetOutTracks());
504 fInterMerger->MMerge();
507 void AliL3Hough::ProcessSliceIter()
509 //Process current slice (after ReadData(slice)) iteratively.
513 for(Int_t i=0; i<fNPatches; i++)
516 fMerger->FillTracks(fTracks[i],i); //Copy tracks to merger
521 for(Int_t i=0; i<10; i++)
526 AliL3HoughBaseTransformer *tr = fHoughTransformer[0];
527 for(Int_t j=0; j<fNEtaSegments; j++)
529 AliL3Histogram *hist = tr->GetHistogram(j);
530 if(hist->GetNEntries()==0) continue;
531 fPeakFinder->Reset();
532 fPeakFinder->SetHistogram(hist);
533 fPeakFinder->FindAbsMaxima();
534 AliL3HoughTrack *track = (AliL3HoughTrack*)fTracks[0]->NextTrack();
535 track->SetTrackParameters(fPeakFinder->GetXPeak(0),fPeakFinder->GetYPeak(0),fPeakFinder->GetWeight(0));
536 track->SetEtaIndex(j);
537 track->SetEta(tr->GetEta(j,fCurrentSlice));
538 for(Int_t k=0; k<fNPatches; k++)
540 fEval[i]->SetNumOfPadsToLook(2);
541 fEval[i]->SetNumOfRowsToMiss(2);
542 fEval[i]->RemoveFoundTracks();
545 if(!fEval[i]->LookInsideRoad(track,nrows))
547 fTracks[0]->Remove(fTracks[0]->GetNTracks()-1);
548 fTracks[0]->Compress();
559 void AliL3Hough::ProcessPatchIter(Int_t patch)
561 //Process patch in a iterative way.
562 //transform + peakfinding + evaluation + transform +...
564 Int_t num_of_tries = 5;
565 AliL3HoughBaseTransformer *tr = fHoughTransformer[patch];
566 AliL3TrackArray *tracks = fTracks[patch];
568 AliL3HoughEval *ev = fEval[patch];
569 ev->InitTransformer(tr);
570 //ev->RemoveFoundTracks();
571 ev->SetNumOfRowsToMiss(3);
572 ev->SetNumOfPadsToLook(2);
573 AliL3Histogram *hist;
574 for(Int_t t=0; t<num_of_tries; t++)
577 tr->TransformCircle();
578 for(Int_t i=0; i<fNEtaSegments; i++)
580 hist = tr->GetHistogram(i);
581 if(hist->GetNEntries()==0) continue;
582 fPeakFinder->Reset();
583 fPeakFinder->SetHistogram(hist);
584 fPeakFinder->FindAbsMaxima();
585 //fPeakFinder->FindPeak1();
586 AliL3HoughTrack *track = (AliL3HoughTrack*)tracks->NextTrack();
587 track->SetTrackParameters(fPeakFinder->GetXPeak(0),fPeakFinder->GetYPeak(0),fPeakFinder->GetWeight(0));
588 track->SetEtaIndex(i);
589 track->SetEta(tr->GetEta(i,fCurrentSlice));
592 if(!ev->LookInsideRoad(track,nrows))
594 tracks->Remove(tracks->GetNTracks()-1);
601 LOG(AliL3Log::kInformational,"AliL3Hough::ProcessPatch","NTracks")
602 <<AliL3Log::kDec<<"Found "<<tracks->GetNTracks()<<" tracks in patch "<<patch<<ENDLOG;
605 void AliL3Hough::AddAllHistograms()
607 //Add the histograms within one etaslice.
608 //Resulting histogram are in patch=0.
610 Double_t initTime,cpuTime;
611 initTime = GetCpuTime();
612 fBenchmark->Start("Add Histograms");
613 for(Int_t i=0; i<fNEtaSegments; i++)
615 AliL3Histogram *hist0 = fHoughTransformer[0]->GetHistogram(i);
616 for(Int_t j=1; j<fNPatches; j++)
618 AliL3Histogram *hist = fHoughTransformer[j]->GetHistogram(i);
622 fBenchmark->Stop("Add Histograms");
623 fAddHistograms = kTRUE;
624 cpuTime = GetCpuTime() - initTime;
625 LOG(AliL3Log::kInformational,"AliL3Hough::AddAllHistograms()","Timing")
626 <<"Adding histograms in "<<cpuTime*1000<<" ms"<<ENDLOG;
629 void AliL3Hough::AddAllHistogramsRows()
631 //Add the histograms within one etaslice.
632 //Resulting histogram are in patch=0.
634 Double_t initTime,cpuTime;
635 initTime = GetCpuTime();
636 fBenchmark->Start("Add HistogramsRows");
638 for(Int_t i=0; i<fNEtaSegments; i++)
640 UChar_t *rowcount = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetRowCount(i);
641 UChar_t *gapcount = ((AliL3HoughTransformerRow *)fHoughTransformer[0])->GetGapCount(i);
643 AliL3Histogram *hist = fHoughTransformer[0]->GetHistogram(i);
644 Int_t xmin = hist->GetFirstXbin();
645 Int_t xmax = hist->GetLastXbin();
646 Int_t ymin = hist->GetFirstYbin();
647 Int_t ymax = hist->GetLastYbin();
649 for(Int_t ybin=ymin; ybin<=ymax; ybin++)
651 for(Int_t xbin=xmin; xbin<=xmax; xbin++)
653 Int_t bin = hist->GetBin(xbin,ybin);
654 if(gapcount[bin] < 3)
655 // hist->AddBinContent(bin,rowcount[bin]);
656 hist->AddBinContent(bin,rowcount[bin]/gapcount[bin]);
661 fBenchmark->Stop("Add HistogramsRows");
662 fAddHistograms = kTRUE;
663 cpuTime = GetCpuTime() - initTime;
664 LOG(AliL3Log::kInformational,"AliL3Hough::AddAllHistogramsRows()","Timing")
665 <<"Adding histograms in "<<cpuTime*1000<<" ms"<<ENDLOG;
668 void AliL3Hough::AddTracks()
672 cerr<<"AliL3Hough::AddTracks : No tracks"<<endl;
675 AliL3TrackArray *tracks = fTracks[0];
676 for(Int_t i=0; i<tracks->GetNTracks(); i++)
678 AliL3Track *track = tracks->GetCheckedTrack(i);
680 if(track->GetNHits()!=1) cerr<<"NHITS "<<track->GetNHits()<<endl;
681 UInt_t *ids = track->GetHitNumbers();
682 ids[0] = (fCurrentSlice&0x7f)<<25;
685 fGlobalTracks->AddTracks(fTracks[0],0,fCurrentSlice);
688 void AliL3Hough::FindTrackCandidates()
690 //Look for peaks in histograms, and find the track candidates
694 n_patches = 1; //Histograms have been added.
696 n_patches = fNPatches;
698 Double_t initTime,cpuTime;
699 initTime = GetCpuTime();
700 fBenchmark->Start("Find Maxima");
701 for(Int_t i=0; i<n_patches; i++)
703 AliL3HoughBaseTransformer *tr = fHoughTransformer[i];
706 for(Int_t j=0; j<fNEtaSegments; j++)
708 AliL3Histogram *hist = tr->GetHistogram(j);
709 if(hist->GetNEntries()==0) continue;
710 fPeakFinder->Reset();
711 fPeakFinder->SetHistogram(hist);
713 fPeakFinder->SetThreshold(fPeakThreshold[i]);
715 fPeakFinder->FindAdaptedPeaks(fKappaSpread,fPeakRatio);
716 //fPeakFinder->FindMaxima(fPeakThreshold[i]); //Simple maxima finder
718 else /* row transformer needs different peak finder method */
719 fPeakFinder->FindAdaptedRowPeaks(1,2,0);
721 for(Int_t k=0; k<fPeakFinder->GetEntries(); k++)
723 AliL3HoughTrack *track = (AliL3HoughTrack*)fTracks[i]->NextTrack();
724 track->SetTrackParameters(fPeakFinder->GetXPeak(k),fPeakFinder->GetYPeak(k),fPeakFinder->GetWeight(k));
725 track->SetEtaIndex(j);
726 track->SetEta(tr->GetEta(j,fCurrentSlice));
727 track->SetRowRange(AliL3Transform::GetFirstRow(0),AliL3Transform::GetLastRow(5));
729 Int_t label = tr->GetTrackID(j,fPeakFinder->GetXPeak(k),fPeakFinder->GetYPeak(k));
730 track->SetMCid(label);
731 cout<<"Track found with label "<<label<<" at "<<fPeakFinder->GetXPeak(k)<<" "<<fPeakFinder->GetYPeak(k)<<" with weight "<<fPeakFinder->GetWeight(k)<<endl;
735 cout<<"Found "<<fTracks[i]->GetNTracks()<<" tracks in patch "<<i<<endl;
738 fBenchmark->Stop("Find Maxima");
739 cpuTime = GetCpuTime() - initTime;
740 LOG(AliL3Log::kInformational,"AliL3Hough::FindTrackCandidates()","Timing")
741 <<"Maxima finding done in "<<cpuTime*1000<<" ms"<<ENDLOG;
744 void AliL3Hough::InitEvaluate()
746 //Pass the transformer objects to the AliL3HoughEval objects:
747 //This will provide the evaluation objects with all the necessary
748 //data and parameters it needs.
750 for(Int_t i=0; i<fNPatches; i++)
751 fEval[i]->InitTransformer(fHoughTransformer[i]);
754 Int_t AliL3Hough::Evaluate(Int_t road_width,Int_t nrowstomiss)
756 //Evaluate the tracks, by looking along the road in the raw data.
757 //If track does not cross all padrows - rows2miss, it is removed from the arrray.
758 //If histograms were not added, the check is done locally in patch,
759 //meaning that nrowstomiss is the number of padrows the road can miss with respect
760 //to the number of rows in the patch.
761 //If the histograms were added, the comparison is done globally in the _slice_,
762 //meaing that nrowstomiss is the number of padrows the road can miss with
763 //respect to the total number of padrows in the slice.
765 //Return value = number of tracks which were removed (only in case of fAddHistograms)
769 LOG(AliL3Log::kError,"AliL3Hough::Evaluate","Track Array")
770 <<"No tracks to work with..."<<ENDLOG;
774 Int_t removed_tracks=0;
775 AliL3TrackArray *tracks=0;
780 for(Int_t i=0; i<tracks->GetNTracks(); i++)
782 AliL3Track *track = tracks->GetCheckedTrack(i);
788 for(Int_t i=0; i<fNPatches; i++)
789 EvaluatePatch(i,road_width,nrowstomiss);
791 //Here we check the tracks globally;
792 //how many good rows (padrows with signal)
793 //did it cross in the slice
796 for(Int_t j=0; j<tracks->GetNTracks(); j++)
798 AliL3HoughTrack *track = (AliL3HoughTrack*)tracks->GetCheckedTrack(j);
800 if(track->GetNHits() < AliL3Transform::GetNRows() - nrowstomiss)
810 return removed_tracks;
813 void AliL3Hough::EvaluatePatch(Int_t i,Int_t road_width,Int_t nrowstomiss)
817 fEval[i]->InitTransformer(fHoughTransformer[i]);
818 fEval[i]->SetNumOfPadsToLook(road_width);
819 fEval[i]->SetNumOfRowsToMiss(nrowstomiss);
820 //fEval[i]->RemoveFoundTracks();
822 AliL3TrackArray *tracks=0;
830 for(Int_t j=0; j<tracks->GetNTracks(); j++)
832 AliL3HoughTrack *track = (AliL3HoughTrack*)tracks->GetCheckedTrack(j);
835 LOG(AliL3Log::kWarning,"AliL3Hough::EvaluatePatch","Track array")
836 <<"Track object missing!"<<ENDLOG;
840 Int_t rowrange[2] = {AliL3Transform::GetFirstRow(i),AliL3Transform::GetLastRow(i)};
841 Bool_t result = fEval[i]->LookInsideRoad(track,nrows,rowrange);
844 Int_t pre=track->GetNHits();
845 track->SetNHits(pre+nrows);
847 else//the track crossed too few good padrows (padrows with signal) in the patch, so remove it
858 void AliL3Hough::MergeEtaSlices()
860 //Merge tracks found in neighbouring eta slices.
861 //Removes the track with the lower weight.
863 fBenchmark->Start("Merge Eta-slices");
864 AliL3TrackArray *tracks = fTracks[0];
867 cerr<<"AliL3Hough::MergeEtaSlices : No tracks "<<endl;
870 for(Int_t j=0; j<tracks->GetNTracks(); j++)
872 AliL3HoughTrack *track1 = (AliL3HoughTrack*)tracks->GetCheckedTrack(j);
873 if(!track1) continue;
874 for(Int_t k=j+1; k<tracks->GetNTracks(); k++)
876 AliL3HoughTrack *track2 = (AliL3HoughTrack*)tracks->GetCheckedTrack(k);
877 if(!track2) continue;
878 if(abs(track1->GetEtaIndex() - track2->GetEtaIndex()) != 1) continue;
879 if(fabs(track1->GetKappa()-track2->GetKappa()) < 0.006 &&
880 fabs(track1->GetPsi()- track2->GetPsi()) < 0.1)
882 //cout<<"Merging track in slices "<<track1->GetEtaIndex()<<" "<<track2->GetEtaIndex()<<endl;
883 if(track1->GetWeight() > track2->GetWeight())
890 fBenchmark->Stop("Merge Eta-slices");
894 void AliL3Hough::WriteTracks(Char_t *path)
896 //cout<<"AliL3Hough::WriteTracks : Sorting the tracsk"<<endl;
897 //fGlobalTracks->QSort();
899 Char_t filename[1024];
900 sprintf(filename,"%s/tracks_%d.raw",path,fEvent);
902 mem.SetBinaryOutput(filename);
903 mem.TrackArray2Binary(fGlobalTracks);
904 mem.CloseBinaryOutput();
905 fGlobalTracks->Reset();
908 void AliL3Hough::WriteTracks(Int_t slice,Char_t *path)
915 sprintf(fname,"%s/tracks_ho_%d_%d.raw",path,fEvent,slice);
916 mem.SetBinaryOutput(fname);
917 mem.TrackArray2Binary(fTracks[0]);
918 mem.CloseBinaryOutput();
922 for(Int_t i=0; i<fNPatches; i++)
924 sprintf(fname,"%s/tracks_ho_%d_%d_%d.raw",path,fEvent,slice,i);
925 mem.SetBinaryOutput(fname);
926 mem.TrackArray2Binary(fTracks[i]);
927 mem.CloseBinaryOutput();
932 void AliL3Hough::WriteDigits(Char_t *outfile)
935 //Write the current data to a new rootfile.
937 for(Int_t i=0; i<fNPatches; i++)
939 AliL3DigitRowData *tempPt = (AliL3DigitRowData*)fHoughTransformer[i]->GetDataPointer();
940 fMemHandler[i]->AliDigits2RootFile(tempPt,outfile);
943 cerr<<"AliL3Hough::WriteDigits : You need to compile with AliROOT!"<<endl;
948 Double_t AliL3Hough::GetCpuTime()
950 //Return the Cputime in seconds.
952 gettimeofday( &tv, NULL );
953 return tv.tv_sec+(((Double_t)tv.tv_usec)/1000000.);