86992a5215c6676c251b6a524b2d469e3f479c13
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCTrackArray.cxx
1 // @(#) $Id$
2 // Original: AliHLTTrackArray.cxx,v 1.21 2005/06/14 10:55:21 cvetan 
3
4 /**************************************************************************
5  * This file is property of and copyright by the ALICE HLT Project        * 
6  * ALICE Experiment at CERN, All rights reserved.                         *
7  *                                                                        *
8  * Primary Authors: Uli Frankenfeld, maintained by                          *
9  *                  Matthias Richter <Matthias.Richter@ift.uib.no>        *
10  *                  for The ALICE HLT Project.                            *
11  *                                                                        *
12  * Permission to use, copy, modify and distribute this software and its   *
13  * documentation strictly for non-commercial purposes is hereby granted   *
14  * without fee, provided that the above copyright notice appears in all   *
15  * copies and that both the copyright notice and this permission notice   *
16  * appear in the supporting documentation. The authors make no claims     *
17  * about the suitability of this software for any purpose. It is          *
18  * provided "as is" without express or implied warranty.                  *
19  **************************************************************************/
20
21 /** @file   AliHLTTPCTrackArray.cxx
22     @author Uli Frankenfeld, maintained by Matthias Richter
23     @date   
24     @brief  Array of AliHLTTPCTracks */
25
26 #include "AliLog.h"
27 #include "TClass.h"
28 #include "AliHLTTPCLogging.h"
29 #include "AliHLTTPCTrackArray.h"
30 #define INCLUDE_TPC_HOUGH
31 #ifdef INCLUDE_TPC_HOUGH
32 #include "AliHLTTPCHoughTrack.h"
33 #endif
34 #include "AliHLTTPCModelTrack.h"
35 #include "AliHLTTPCConfMapTrack.h"
36 #include "AliHLTTPCTrackSegmentData.h"
37 #include "AliHLTTPCTransform.h"
38 #include "AliHLTTPCConfMapPoint.h"
39
40 #if __GNUC__ >= 3
41 using namespace std;
42 #endif
43
44 ClassImp(AliHLTTPCTrackArray)
45
46 AliHLTTPCTrackArray::AliHLTTPCTrackArray()
47   :
48   fTrackType('t'),
49   fSize(0),
50   fIsPresent(NULL),
51   fNAbsent(0),
52   fTrack(NULL),
53   fNTracks(0)
54 {
55   //Default constructor
56   SetSize();
57 }
58
59
60 AliHLTTPCTrackArray::AliHLTTPCTrackArray(const AliHLTTPCTrackArray&)
61   :
62   fTrackType('t'),
63   fSize(0),
64   fIsPresent(NULL),
65   fNAbsent(0),
66   fTrack(NULL),
67   fNTracks(0)
68 {
69   //constructor
70   SetSize();
71 }
72
73 AliHLTTPCTrackArray& AliHLTTPCTrackArray::operator=(const AliHLTTPCTrackArray&)
74 {
75   //assignment
76   fSize=0;
77   fNTracks=0;
78   fNAbsent=0;
79   fTrackType='t';
80   SetSize();
81   return *this;
82 }
83
84 AliHLTTPCTrackArray::AliHLTTPCTrackArray(Int_t ntrack)
85   :
86   fTrackType('t'),
87   fSize(0),
88   fIsPresent(NULL),
89   fNAbsent(0),
90   fTrack(NULL),
91   fNTracks(0)
92 {
93   //Constructor.
94   SetSize(ntrack);
95 }
96
97 AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype,Int_t ntrack)
98   :
99   fTrackType('t'),
100   fSize(0),
101   fIsPresent(NULL),
102   fNAbsent(0),
103   fTrack(NULL),
104   fNTracks(0)
105 {
106   //Constructor.
107   if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
108   if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
109 #ifdef INCLUDE_TPC_HOUGH
110   if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
111 #endif
112   if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
113   SetSize(ntrack);
114 }
115
116 AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype)
117   :
118   fTrackType('t'),
119   fSize(0),
120   fIsPresent(NULL),
121   fNAbsent(0),
122   fTrack(NULL),
123   fNTracks(0)
124 {
125   //Constructor.
126   if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
127   if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
128 #ifdef INCLUDE_TPC_HOUGH
129   if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
130 #endif
131   if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
132   SetSize();
133 }
134
135 AliHLTTPCTrackArray::~AliHLTTPCTrackArray()
136 {
137   //Destructor
138   DeleteArray();
139 }
140
141
142 AliHLTTPCTrack *AliHLTTPCTrackArray::NextTrack()
143 {
144   //next track in array
145   if(fNTracks<fSize) return fTrack[fNTracks++];
146   SetSize(fSize+100);
147    return fTrack[fNTracks++]; 
148 }
149
150 void AliHLTTPCTrackArray::DeleteArray()
151 {
152   //delete array
153   for(Int_t i=0; i<fSize;i++)
154     delete fTrack[i];
155   delete[] fIsPresent;
156   delete[] fTrack;
157 }
158
159 Bool_t AliHLTTPCTrackArray::SetSize(Int_t newsize)
160 {
161   //set size
162   if(newsize<=fSize) return kFALSE; //shrink comes later!! 
163   if(!fSize){
164     fSize = newsize;
165     fTrack = new AliHLTTPCTrack*[fSize];
166     fIsPresent = new Bool_t[fSize];
167     switch(fTrackType){
168       case 't':
169         for(Int_t i=0;i<fSize;i++){
170           fTrack[i]   = new AliHLTTPCTrack();
171           fIsPresent[i] = kTRUE;
172         }
173         break;
174       case 'c':  
175         for(Int_t i=0;i<fSize;i++){
176           fTrack[i]   = new AliHLTTPCConfMapTrack();
177           fIsPresent[i] = kTRUE;
178         }
179         break;
180 #ifdef INCLUDE_TPC_HOUGH
181       case 'h':
182         for(Int_t i=0;i<fSize;i++){
183           fTrack[i]   = new AliHLTTPCHoughTrack();
184           fIsPresent[i] = kTRUE;
185         }
186         break;
187 #endif
188        case 'm':
189         for(Int_t i=0;i<fSize;i++){
190           fTrack[i]   = new AliHLTTPCModelTrack();
191           fIsPresent[i] = kTRUE;
192         }
193         break;
194       default: 
195         return kFALSE;
196     }
197     return kTRUE;
198   }
199   AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[fSize];
200   Bool_t *pre = new Bool_t[fSize];
201   for(Int_t i=0; i<fSize;i++){
202     tmp[i] = fTrack[i];
203     pre[i] = fIsPresent[i];
204   }
205   delete[]  fTrack;
206   delete[] fIsPresent;
207   fTrack =  new AliHLTTPCTrack*[newsize];
208   fIsPresent = new Bool_t[newsize];
209   for(Int_t i=0; i<fSize;i++){
210     fTrack[i]   = tmp[i];
211     fIsPresent[i] = pre[i];
212   }
213   delete[] tmp;
214   delete[] pre;
215   switch(fTrackType){
216     case 't':
217       for(Int_t i=fSize;i<newsize;i++){
218         fTrack[i]   = new AliHLTTPCTrack();
219         fIsPresent[i] = kTRUE;
220       }
221       break;
222     case 'c':  
223       for(Int_t i=fSize;i<newsize;i++){
224         fTrack[i]   = new AliHLTTPCConfMapTrack();
225         fIsPresent[i] = kTRUE;
226       }
227       break;
228 #ifdef INCLUDE_TPC_HOUGH
229     case 'h':
230       for(Int_t i=fSize;i<newsize;i++){
231         fTrack[i]   = new AliHLTTPCHoughTrack();
232         fIsPresent[i] = kTRUE;
233       }
234       break;
235 #endif
236     case 'm':
237       for(Int_t i=fSize;i<newsize;i++){
238         fTrack[i]   = new AliHLTTPCModelTrack();
239         fIsPresent[i] = kTRUE;
240       }
241       break;
242     default: 
243       return kFALSE;
244   }
245   fSize = newsize;
246   return kTRUE;
247 }
248
249 void AliHLTTPCTrackArray::Reset()
250 {
251   //reset
252   fNTracks=0;
253   fNAbsent=0;
254   for(Int_t i=0; i<fSize;i++)
255     fIsPresent[i] = kTRUE; 
256 }
257
258 void AliHLTTPCTrackArray::Remove(Int_t track)
259 {
260   //remove track
261   if(fIsPresent[track]){
262     fIsPresent[track]=kFALSE;
263     fNAbsent++;
264   }
265 }
266
267 void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr,Int_t slice, Int_t bTransform)
268 {
269   //Read tracks from shared memory (or memory)
270   AliHLTTPCTrackSegmentData *trs = tr;
271   for(Int_t i=0; i<ntracks; i++){
272     AliHLTTPCTrack *track = NextTrack(); 
273     track->SetPt(trs->fPt);
274     track->SetPterr(trs->fPterr);
275     Float_t psi[1];
276     psi[0]=trs->fPsi;
277     if (slice>=0 && bTransform!=0)  {
278       AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
279     }
280     //cout << "psi " << psi[0] << endl;
281     track->SetPsi(psi[0]);
282     track->SetTgl(trs->fTgl);
283     track->SetPsierr(trs->fPsierr);
284     track->SetTglerr(trs->fTglerr);
285     track->SetNHits(trs->fNPoints);
286     track->SetCharge(trs->fCharge);
287     Float_t first[3];
288     first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
289     if (slice>=0 && bTransform!=0)  {
290       AliHLTTPCTransform::Local2Global(first,slice);
291     }
292     //cout << "first point: " << first[0] << " " << first[1] << " " << first[3] << endl;
293     track->SetFirstPoint(first[0],first[1],first[2]);
294     Float_t last[3];
295     last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
296     if (slice>=0 && bTransform!=0)  {
297       AliHLTTPCTransform::Local2Global(last,slice);
298     }
299     //cout << "last point: " << last[0] << " " << last[1] << " " << last[3] << endl;
300     track->SetLastPoint(last[0],last[1],last[2]);
301     track->SetHits( trs->fNPoints, trs->fPointIDs );
302
303     //if (slice>=0 && bTransform!=0)  {
304       // Matthias Feb07: as everything is now in global coordinates, sector should
305       // be set to 0. But as the display does a check on the sector, we have to set
306       // it to the slice no. I suspect, that the transformation is done twice.
307       //track->SetSector(0);
308       track->SetSector(slice);
309     //} else {
310       // the parameters are in local coordinates, set the sector no
311       //#ifndef INCLUDE_TPC_HOUGH
312       //if (slice<0) track->SetSector(0);
313       //else track->SetSector(slice);
314       //#else 
315       // Matthias Feb 2007: this is some kind of legacy ...
316       // the INCLUDE_TPC_HOUGH has never been switched on in the new TPCLib
317       // and this line was below in the corresponding block. As the slice
318       // parameter is very useful but not available if the define is off
319       // we distinguish the two cases here. Should be cleaned up.
320       // Matthias April 2007: update, try to integrate Cvetans Hough tracker
321       // so we need the support for the AliHLTTPCHoughTrack. I dont have the
322       // full control of this code (should we use slice or trs->fSector?)
323       // But the FillTracks method is never called from the hough code, so we
324       // take 'slice'
325       if (GetTrackType()=='h') {
326         AliErrorClassStream() << "FillTracks was never used with AliHLTTPCHoughTrack:" 
327                            << " CHECK THIS CODE!!!" << endl;
328       }
329       //track->SetSector(trs->fSector);
330       //#endif // INCLUDE_TPC_HOUGH
331       //}
332
333     // this is currently a quick hack for straight lines of the first version 
334     // of the CA tracker.
335     // we have to think about a more general way of treating straight and curved
336     // tracks
337     if ( trs->fPt == -9876.0 ||  trs->fPt == -1.0) {
338       track->SetPhi0(atan2(first[1],first[0]));
339       track->SetKappa(1.0);
340       track->SetRadius(999999.0);
341     } else {
342       // Matthias Feb07: just tried to take this away, but this causes the tracks
343       // in the display not to be drawn. But we still have to tink about this.
344       track->CalculateHelix();
345     }
346
347 #ifdef INCLUDE_TPC_HOUGH
348 #ifdef ROWHOUGHPARAMS
349     if(GetTrackType()=='h') {
350       ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
351       ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
352     }
353     track->SetMCid(trs->fTrackID);
354     track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
355     track->SetPID(trs->fPID);
356 #endif
357 #endif // INCLUDE_TPC_HOUGH
358     UChar_t *tmpP = (UChar_t*)trs;
359     tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
360     trs = (AliHLTTPCTrackSegmentData*)tmpP;
361   }
362 }
363
364 UInt_t AliHLTTPCTrackArray::GetOutSize()
365 {
366   //get size for IO
367   UInt_t count = GetOutCount();   //use only present tracks
368   UInt_t tHits = 0;
369   for(Int_t i=0;i<fNTracks;i++){  //loop over all tracks
370     AliHLTTPCTrack *track = GetCheckedTrack(i);  //use only present tracks
371     if(track)                                       //use only present tracks
372       tHits += track->GetNHits();
373   }
374
375   //calculate size of track
376   return count*sizeof(AliHLTTPCTrackSegmentData)+sizeof(UInt_t)*tHits;
377 }
378
379 UInt_t AliHLTTPCTrackArray::WriteTracks(UInt_t & ntracks,AliHLTTPCTrackSegmentData* tr)
380 {
381   //write tracks
382   ntracks = GetOutCount();
383   return WriteTracks(tr);
384 }
385
386 UInt_t AliHLTTPCTrackArray::WriteTracks(AliHLTTPCTrackSegmentData* tr)
387 {
388   //if(GetTrackType()=='c') return WriteConfMapTracks(tr);
389   AliHLTTPCTrackSegmentData *tP = tr;
390   UInt_t *pP;
391   UInt_t size = 0;
392   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
393     AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
394     if(!track) continue;                           //use only present tracks
395     tP->fX = track->GetFirstPointX();
396     tP->fY = track->GetFirstPointY();
397     tP->fZ = track->GetFirstPointZ();
398     tP->fPt = track->GetPt();
399     tP->fPterr = track->GetPterr();
400     tP->fLastX = track->GetLastPointX();
401     tP->fLastY = track->GetLastPointY();
402     tP->fLastZ = track->GetLastPointZ();
403     tP->fPsi = track->GetPsi();
404     tP->fTgl = track->GetTgl();
405     tP->fPsierr = track->GetPsierr();
406     tP->fTglerr = track->GetTglerr();
407     tP->fCharge = track->GetCharge();
408     tP->fNPoints = track->GetNHits();
409 #ifdef INCLUDE_TPC_HOUGH
410 #ifdef ROWHOUGHPARAMS
411     if(GetTrackType()=='h') {
412       tP->fWeight = ((AliHLTTPCHoughTrack *)track)->GetWeight();
413       tP->fBinX = ((AliHLTTPCHoughTrack *)track)->GetBinX();
414       tP->fBinY = ((AliHLTTPCHoughTrack *)track)->GetBinY();
415       tP->fBinXSize = ((AliHLTTPCHoughTrack *)track)->GetSizeX();
416       tP->fBinYSize = ((AliHLTTPCHoughTrack *)track)->GetSizeY();
417     }
418     tP->fTrackID = track->GetMCid();
419     tP->fRowRange1 = track->GetFirstRow();
420     tP->fRowRange2 = track->GetLastRow();
421     tP->fSector = track->GetSector();
422     tP->fPID = track->GetPID();
423 #endif
424 #endif // INCLUDE_TPC_HOUGH
425     pP = (UInt_t*)track->GetHitNumbers();
426     for (UInt_t j=0;j<tP->fNPoints;j++){
427       tP->fPointIDs[j] = pP[j];
428     }
429     Byte_t *tmpP = (Byte_t *)tP;
430     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
431     size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
432     tP = (AliHLTTPCTrackSegmentData*)tmpP;
433
434 // BEGINN ############################################## MODIFIY JMT
435 //    LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::WriteTracks","TRACKPARAMETER") <<ENDLOG;
436 //    track->Rotate(0,kFALSE);
437 //    track->Print();
438 // END ################################################# MODIFIY JMT
439
440   }
441   return size;
442 }
443
444 UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
445 {
446   // use first and last point objects
447   AliHLTTPCTrackSegmentData *tP = tr;
448   UInt_t *pP;
449   UInt_t size = 0;
450   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
451     AliHLTTPCConfMapTrack *track =(AliHLTTPCConfMapTrack *) GetCheckedTrack(i); //use only present tracks
452     if(!track) continue;                           //use only present tracks
453     AliHLTTPCConfMapPoint *hit = (AliHLTTPCConfMapPoint*)track->GetLastHit();
454     AliHLTTPCConfMapPoint *lastHit = (AliHLTTPCConfMapPoint*)track->GetFirstHit();
455     tP->fX = hit->GetX();
456     tP->fY = hit->GetY();
457     tP->fZ = hit->GetZ();
458     tP->fLastX = lastHit->GetX();
459     tP->fLastY = lastHit->GetY();
460     tP->fLastZ = lastHit->GetZ();
461    
462 //    tP->fX = track->GetFirstPointX();
463 //    tP->fY = track->GetFirstPointY();
464 //    tP->fZ = track->GetFirstPointZ();
465     tP->fPt = track->GetPt();
466     tP->fPterr = track->GetPterr();
467 //    tP->fLastX = track->GetLastPointX();
468 //    tP->fLastY = track->GetLastPointY();
469 //    tP->fLastZ = track->GetLastPointZ();
470     tP->fPsi = track->GetPsi();
471     tP->fTgl = track->GetTgl();
472     tP->fPsierr = track->GetPsierr();
473     tP->fTglerr = track->GetTglerr();
474     tP->fCharge = track->GetCharge();
475 #ifdef INCLUDE_TPC_HOUGH
476 #ifdef ROWHOUGHPARAMS
477     tP->fTrackID = track->GetMCid();
478     tP->fRowRange1 = track->GetFirstRow();
479     tP->fRowRange2 = track->GetLastRow();
480     tP->fSector = track->GetSector();
481     tP->fPID = track->GetPID();
482 #endif
483 #endif // INCLUDE_TPC_HOUGH
484     tP->fNPoints = track->GetNHits();
485     pP = (UInt_t*)track->GetHitNumbers();
486     for (UInt_t j=0;j<tP->fNPoints;j++){
487       tP->fPointIDs[j] = pP[j];
488     }
489     Byte_t *tmpP = (Byte_t *)tP;
490     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
491     size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
492     tP = (AliHLTTPCTrackSegmentData*)tmpP;
493   }
494   return size;
495 }
496
497 void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
498 {
499   //add track to last position
500   AliHLTTPCTrack *tpt = NextTrack();
501   tpt->Copy(track);
502   
503 }
504
505 void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
506 {
507   //add tracks
508   if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
509     {
510       LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
511         <<"Bad idea to add tracks of different types"<<ENDLOG;
512       return;
513     }
514   if(fSize < fNTracks+newtrack->GetNPresent())
515     SetSize(fSize+newtrack->GetSize());
516   for(Int_t i =0;i<newtrack->GetNTracks();i++){
517     AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
518     if(!tpt) continue;
519     if(remove_old)
520       newtrack->Remove(i);
521     AliHLTTPCTrack *track = NextTrack();
522     track->Copy(tpt);
523     if(slice>=0)
524       track->Rotate(slice); //Rotate track to global coordinates
525     /*
526       AliHLTTPCTrack *track;
527 #ifdef INCLUDE_TPC_HOUGH
528       if(GetTrackType()=='h')
529       track = (AliHLTTPCHoughTrack*)NextTrack();
530       else
531 #endif
532       track = NextTrack();
533       track->Copy(tpt);
534     */
535   }
536 }
537
538 void AliHLTTPCTrackArray::Compress()
539 {
540   //compress array
541   if(GetNPresent()==GetNTracks()) return;
542   AliHLTTPCTrack **tmp =  new AliHLTTPCTrack *[fNTracks];
543   Int_t present=0;
544   Int_t absent=GetNPresent();
545   for(Int_t i=0;i<GetNTracks();i++){
546     if(fIsPresent[i]) tmp[present++] = fTrack[i];
547     else tmp[absent++] = fTrack[i];
548   }
549   for(Int_t i=0;i<GetNTracks();i++)
550     fIsPresent[i]=kTRUE;
551
552   //Copy pointers back
553   for(Int_t i=0; i<GetNTracks();i++){
554     fTrack[i]=tmp[i];
555   }
556
557   delete[] tmp;
558
559   fNTracks = GetNPresent();
560   fNAbsent = 0;
561 }
562
563 void AliHLTTPCTrackArray::QSort()
564 {
565   // compress and sort
566   Compress();
567   QSort(fTrack,0,fNTracks);
568 }
569
570 void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
571 {
572    // Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
573    // Uses TrackCompare() to compare objects.
574    // Thanks to Root! 
575
576    static AliHLTTPCTrack *tmp;
577    static int i;           // "static" to save stack space
578    int j;
579
580    while (last - first > 1) {
581       i = first;
582       j = last;
583       for (;;) {
584         while (++i < last && TrackCompare(a[i], a[first]) < 0)
585           ;
586         while (--j > first && TrackCompare(a[j], a[first]) > 0)
587           ;
588          if (i >= j)
589             break;
590
591          tmp  = a[i];
592          a[i] = a[j];
593          a[j] = tmp;
594       }
595       if (j == first) {
596          ++first;
597          continue;
598       }
599       tmp = a[first];
600       a[first] = a[j];
601       a[j] = tmp;
602       if (j - first < last - (j + 1)) {
603          QSort(a, first, j);
604          first = j + 1;   // QSort(j + 1, last);
605       } else {
606          QSort(a, j + 1, last);
607          last = j;        // QSort(first, j);
608       }
609    }
610 }
611
612 Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack *a, AliHLTTPCTrack *b) const
613 {
614    // Compare the two tracks.
615   
616   return b->Compare(a);
617   
618   /*
619 #ifdef INCLUDE_TPC_HOUGH
620     if(fTrackType=='h')
621     {
622     AliHLTTPCHoughTrack *tra = (AliHLTTPCHoughTrack*)a;
623     AliHLTTPCHoughTrack *trb = (AliHLTTPCHoughTrack*)b;
624     if(tra->GetWeight() < trb->GetWeight()) return 1;
625     if(tra->GetWeight() > trb->GetWeight()) return -1;
626     }
627     else
628 #endif
629     {
630     if(a->GetNHits() < b->GetNHits()) return 1;
631     if(a->GetNHits() > b->GetNHits()) return -1;
632     }
633     
634     return 0;
635   */
636 }
637
638 AliHLTTPCTrack* AliHLTTPCTrackArray::operator[](int index)
639 {
640   // access operator
641   if (index<fNTracks) return fTrack[index];
642   return NULL;
643 }