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