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 //    LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::WriteTracks","TRACKPARAMETER") <<ENDLOG;
 435 //    track->Rotate(0,kFALSE);
 436 //    track->Print();
 437
 438   }
 439   return size;
 440 }
 441
 442 UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
 443 {
 444   // use first and last point objects
 445   AliHLTTPCTrackSegmentData *tP = tr;
 446   UInt_t *pP;
 447   UInt_t size = 0;
 448   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
 449     AliHLTTPCConfMapTrack *track =(AliHLTTPCConfMapTrack *) GetCheckedTrack(i); //use only present tracks
 450     if(!track) continue;                           //use only present tracks
 451     AliHLTTPCConfMapPoint *hit = (AliHLTTPCConfMapPoint*)track->GetLastHit();
 452     AliHLTTPCConfMapPoint *lastHit = (AliHLTTPCConfMapPoint*)track->GetFirstHit();
 453     tP->fX = hit->GetX();
 454     tP->fY = hit->GetY();
 455     tP->fZ = hit->GetZ();
 456     tP->fLastX = lastHit->GetX();
 457     tP->fLastY = lastHit->GetY();
 458     tP->fLastZ = lastHit->GetZ();
 459
 460 //    tP->fX = track->GetFirstPointX();
 461 //    tP->fY = track->GetFirstPointY();
 462 //    tP->fZ = track->GetFirstPointZ();
 463     tP->fPt = track->GetPt();
 464     tP->fPterr = track->GetPterr();
 465 //    tP->fLastX = track->GetLastPointX();
 466 //    tP->fLastY = track->GetLastPointY();
 467 //    tP->fLastZ = track->GetLastPointZ();
 468     tP->fPsi = track->GetPsi();
 469     tP->fTgl = track->GetTgl();
 470     tP->fPsierr = track->GetPsierr();
 471     tP->fTglerr = track->GetTglerr();
 472     tP->fCharge = track->GetCharge();
 473 #ifdef INCLUDE_TPC_HOUGH
 474 #ifdef ROWHOUGHPARAMS
 475     tP->fTrackID = track->GetMCid();
 476     tP->fRowRange1 = track->GetFirstRow();
 477     tP->fRowRange2 = track->GetLastRow();
 478     tP->fSector = track->GetSector();
 479     tP->fPID = track->GetPID();
 480 #endif
 481 #endif // INCLUDE_TPC_HOUGH
 482     tP->fNPoints = track->GetNHits();
 483     pP = (UInt_t*)track->GetHitNumbers();
 484     for (UInt_t j=0;j<tP->fNPoints;j++){
 485       tP->fPointIDs[j] = pP[j];
 486     }
 487     Byte_t *tmpP = (Byte_t *)tP;
 488     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 489     size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 490     tP = (AliHLTTPCTrackSegmentData*)tmpP;
 491   }
 492   return size;
 493 }
 494
 495 void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
 496 {
 497   //add track to last position
 498   AliHLTTPCTrack *tpt = NextTrack();
 499   tpt->Copy(track);
 500
 501 }
 502
 503 void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
 504 {
 505   //add tracks
 506   if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
 507     {
 508       LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
 509         <<"Bad idea to add tracks of different types"<<ENDLOG;
 510       return;
 511     }
 512   if(fSize < fNTracks+newtrack->GetNPresent())
 513     SetSize(fSize+newtrack->GetSize());
 514   for(Int_t i =0;i<newtrack->GetNTracks();i++){
 515     AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
 516     if(!tpt) continue;
 517     if(remove_old)
 518       newtrack->Remove(i);
 519     AliHLTTPCTrack *track = NextTrack();
 520     track->Copy(tpt);
 521     if(slice>=0)
 522       track->Rotate(slice); //Rotate track to global coordinates
 523     /*
 524       AliHLTTPCTrack *track;
 525 #ifdef INCLUDE_TPC_HOUGH
 526       if(GetTrackType()=='h')
 527       track = (AliHLTTPCHoughTrack*)NextTrack();
 528       else
 529 #endif
 530       track = NextTrack();
 531       track->Copy(tpt);
 532     */
 533   }
 534 }
 535
 536 void AliHLTTPCTrackArray::Compress()
 537 {
 538   //compress array
 539   if(GetNPresent()==GetNTracks()) return;
 540   AliHLTTPCTrack **tmp =  new AliHLTTPCTrack *[fNTracks];
 541   Int_t present=0;
 542   Int_t absent=GetNPresent();
 543   for(Int_t i=0;i<GetNTracks();i++){
 544     if(fIsPresent[i]) tmp[present++] = fTrack[i];
 545     else tmp[absent++] = fTrack[i];
 546   }
 547   for(Int_t i=0;i<GetNTracks();i++)
 548     fIsPresent[i]=kTRUE;
 549
 550   //Copy pointers back
 551   for(Int_t i=0; i<GetNTracks();i++){
 552     fTrack[i]=tmp[i];
 553   }
 554
 555   delete[] tmp;
 556
 557   fNTracks = GetNPresent();
 558   fNAbsent = 0;
 559 }
 560
 561 void AliHLTTPCTrackArray::QSort()
 562 {
 563   // compress and sort
 564   Compress();
 565   QSort(fTrack,0,fNTracks);
 566 }
 567
 568 void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
 569 {
 570    // Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
 571    // Uses TrackCompare() to compare objects.
 572    // Thanks to Root!
 573
 574    static AliHLTTPCTrack *tmp;
 575    static int i;           // "static" to save stack space
 576    int j;
 577
 578    while (last - first > 1) {
 579       i = first;
 580       j = last;
 581       for (;;) {
 582         while (++i < last && TrackCompare(a[i], a[first]) < 0)
 583           ;
 584         while (--j > first && TrackCompare(a[j], a[first]) > 0)
 585           ;
 586          if (i >= j)
 587             break;
 588
 589          tmp  = a[i];
 590          a[i] = a[j];
 591          a[j] = tmp;
 592       }
 593       if (j == first) {
 594          ++first;
 595          continue;
 596       }
 597       tmp = a[first];
 598       a[first] = a[j];
 599       a[j] = tmp;
 600       if (j - first < last - (j + 1)) {
 601          QSort(a, first, j);
 602          first = j + 1;   // QSort(j + 1, last);
 603       } else {
 604          QSort(a, j + 1, last);
 605          last = j;        // QSort(first, j);
 606       }
 607    }
 608 }
 609
 610 Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack *a, AliHLTTPCTrack *b) const
 611 {
 612    // Compare the two tracks.
 613
 614   return b->Compare(a);
 615
 616   /*
 617 #ifdef INCLUDE_TPC_HOUGH
 618     if(fTrackType=='h')
 619     {
 620     AliHLTTPCHoughTrack *tra = (AliHLTTPCHoughTrack*)a;
 621     AliHLTTPCHoughTrack *trb = (AliHLTTPCHoughTrack*)b;
 622     if(tra->GetWeight() < trb->GetWeight()) return 1;
 623     if(tra->GetWeight() > trb->GetWeight()) return -1;
 624     }
 625     else
 626 #endif
 627     {
 628     if(a->GetNHits() < b->GetNHits()) return 1;
 629     if(a->GetNHits() > b->GetNHits()) return -1;
 630     }
 631
 632     return 0;
 633   */
 634 }
 635
 636 AliHLTTPCTrack* AliHLTTPCTrackArray::operator[](int index)
 637 {
 638   // access operator
 639   if (index<fNTracks) return fTrack[index];
 640   return NULL;
 641 }