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