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