HLT/TPCLib/AliHLTTPCTrackArray.cxx

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