HLT/TPCLib/AliHLTTPCTrackArray.cxx

   1 // @(#) $Id$
   2
   3 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
   4 //*-- Copyright &copy ALICE HLT Group
   5
   6 #include "AliHLTTPCStandardIncludes.h"
   7
   8 #include "AliHLTTPCLogging.h"
   9 #include "AliHLTTPCTrackArray.h"
  10 #ifdef INCLUDE_TPC_HOUGH
  11 #include "AliHLTTPCHoughTrack.h"
  12 #endif
  13 #include "AliHLTTPCModelTrack.h"
  14 #include "AliHLTTPCConfMapTrack.h"
  15 #include "AliHLTTPCTrackSegmentData.h"
  16 #include "AliHLTTPCTransform.h"
  17 #include "AliHLTTPCConfMapPoint.h"
  18
  19 /** \class AliHLTTPCTrackArray
  20 <pre>
  21 //_____________________________________________________________
  22 // AliHLTTPCTrackArray
  23 //
  24 // Track array class
  25 //
  26 </pre>
  27 */
  28
  29 #if __GNUC__ >= 3
  30 using namespace std;
  31 #endif
  32
  33 ClassImp(AliHLTTPCTrackArray)
  34
  35 AliHLTTPCTrackArray::AliHLTTPCTrackArray()
  36 {
  37   //Default constructor
  38   fSize = 0;
  39   fNTracks=0;
  40   fNAbsent=0;
  41   fTrackType='t';
  42   SetSize();
  43 }
  44
  45
  46 AliHLTTPCTrackArray::AliHLTTPCTrackArray(Int_t ntrack)
  47 {
  48   //Constructor.
  49   fSize = 0;
  50   fNTracks=0;
  51   fNAbsent=0;
  52   fTrackType='t';
  53   SetSize(ntrack);
  54 }
  55
  56 AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype,Int_t ntrack)
  57 {
  58   //Constructor.
  59   fSize = 0;
  60   fNTracks=0;
  61   fNAbsent=0;
  62   if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
  63   if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
  64 #ifdef INCLUDE_TPC_HOUGH
  65   if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
  66 #endif
  67   if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
  68   SetSize(ntrack);
  69 }
  70
  71 AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype)
  72 {
  73   //Constructor.
  74   fSize = 0;
  75   fNTracks=0;
  76   fNAbsent=0;
  77   if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
  78   if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
  79 #ifdef INCLUDE_TPC_HOUGH
  80   if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
  81 #endif
  82   if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
  83   SetSize();
  84 }
  85
  86 AliHLTTPCTrackArray::~AliHLTTPCTrackArray()
  87 {
  88   //Destructor
  89   DeleteArray();
  90 }
  91
  92
  93 AliHLTTPCTrack *AliHLTTPCTrackArray::NextTrack()
  94 {
  95   //next track in array
  96   if(fNTracks<fSize) return fTrack[fNTracks++];
  97   SetSize(fSize+100);
  98    return fTrack[fNTracks++];
  99 }
 100
 101 void AliHLTTPCTrackArray::DeleteArray()
 102 {
 103   //delete array
 104   for(Int_t i=0; i<fSize;i++)
 105     delete fTrack[i];
 106   delete[] fIsPresent;
 107   delete[] fTrack;
 108 }
 109
 110 Bool_t AliHLTTPCTrackArray::SetSize(Int_t newsize)
 111 {
 112   //set size
 113   if(newsize<=fSize) return kFALSE; //shrink comes later!!
 114   if(!fSize){
 115     fSize = newsize;
 116     fTrack = new AliHLTTPCTrack*[fSize];
 117     fIsPresent = new Bool_t[fSize];
 118     switch(fTrackType){
 119       case 't':
 120         for(Int_t i=0;i<fSize;i++){
 121           fTrack[i]   = new AliHLTTPCTrack();
 122           fIsPresent[i] = kTRUE;
 123         }
 124         break;
 125       case 'c':
 126         for(Int_t i=0;i<fSize;i++){
 127           fTrack[i]   = new AliHLTTPCConfMapTrack();
 128           fIsPresent[i] = kTRUE;
 129         }
 130         break;
 131 #ifdef INCLUDE_TPC_HOUGH
 132       case 'h':
 133         for(Int_t i=0;i<fSize;i++){
 134           fTrack[i]   = new AliHLTTPCHoughTrack();
 135           fIsPresent[i] = kTRUE;
 136         }
 137         break;
 138 #endif
 139        case 'm':
 140         for(Int_t i=0;i<fSize;i++){
 141           fTrack[i]   = new AliHLTTPCModelTrack();
 142           fIsPresent[i] = kTRUE;
 143         }
 144         break;
 145       default:
 146         return kFALSE;
 147     }
 148     return kTRUE;
 149   }
 150   AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[fSize];
 151   Bool_t *pre = new Bool_t[fSize];
 152   for(Int_t i=0; i<fSize;i++){
 153     tmp[i] = fTrack[i];
 154     pre[i] = fIsPresent[i];
 155   }
 156   delete[]  fTrack;
 157   delete[] fIsPresent;
 158   fTrack =  new AliHLTTPCTrack*[newsize];
 159   fIsPresent = new Bool_t[newsize];
 160   for(Int_t i=0; i<fSize;i++){
 161     fTrack[i]   = tmp[i];
 162     fIsPresent[i] = pre[i];
 163   }
 164   delete[] tmp;
 165   delete[] pre;
 166   switch(fTrackType){
 167     case 't':
 168       for(Int_t i=fSize;i<newsize;i++){
 169         fTrack[i]   = new AliHLTTPCTrack();
 170         fIsPresent[i] = kTRUE;
 171       }
 172       break;
 173     case 'c':
 174       for(Int_t i=fSize;i<newsize;i++){
 175         fTrack[i]   = new AliHLTTPCConfMapTrack();
 176         fIsPresent[i] = kTRUE;
 177       }
 178       break;
 179 #ifdef INCLUDE_TPC_HOUGH
 180     case 'h':
 181       for(Int_t i=fSize;i<newsize;i++){
 182         fTrack[i]   = new AliHLTTPCHoughTrack();
 183         fIsPresent[i] = kTRUE;
 184       }
 185       break;
 186 #endif
 187     case 'm':
 188       for(Int_t i=fSize;i<newsize;i++){
 189         fTrack[i]   = new AliHLTTPCModelTrack();
 190         fIsPresent[i] = kTRUE;
 191       }
 192       break;
 193     default:
 194       return kFALSE;
 195   }
 196   fSize = newsize;
 197   return kTRUE;
 198 }
 199
 200 void AliHLTTPCTrackArray::Reset()
 201 {
 202   //reset
 203   fNTracks=0;
 204   fNAbsent=0;
 205   for(Int_t i=0; i<fSize;i++)
 206     fIsPresent[i] = kTRUE;
 207 }
 208
 209 void AliHLTTPCTrackArray::Remove(Int_t track)
 210 {
 211   //remove track
 212   if(fIsPresent[track]){
 213     fIsPresent[track]=kFALSE;
 214     fNAbsent++;
 215   }
 216 }
 217
 218 void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr){
 219   //Read tracks from shared memory (or memory)
 220   AliHLTTPCTrackSegmentData *trs = tr;
 221    for(Int_t i=0; i<ntracks; i++){
 222     AliHLTTPCTrack *track = NextTrack();
 223     track->SetPt(trs->fPt);
 224     track->SetPsi(trs->fPsi);
 225     track->SetTgl(trs->fTgl);
 226     track->SetPterr(trs->fPterr);
 227     track->SetPsierr(trs->fPsierr);
 228     track->SetTglerr(trs->fTglerr);
 229     track->SetNHits(trs->fNPoints);
 230     track->SetCharge(trs->fCharge);
 231     track->SetFirstPoint(trs->fX,trs->fY,trs->fZ);
 232     track->SetLastPoint(trs->fLastX,trs->fLastY,trs->fLastZ);
 233     track->SetHits( trs->fNPoints, trs->fPointIDs );
 234 #ifdef INCLUDE_TPC_HOUGH
 235 #ifdef ROWHOUGHPARAMS
 236     if(GetTrackType()=='h') {
 237       ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
 238       ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
 239     }
 240     track->SetMCid(trs->fTrackID);
 241     track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
 242     track->SetSector(trs->fSector);
 243     track->SetPID(trs->fPID);
 244 #endif
 245 #endif // INCLUDE_TPC_HOUGH
 246     UChar_t *tmpP = (UChar_t*)trs;
 247     tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
 248     trs = (AliHLTTPCTrackSegmentData*)tmpP;
 249   }
 250 }
 251
 252 void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr,Int_t slice)
 253 {
 254   //Read tracks from shared memory (or memory)
 255   AliHLTTPCTrackSegmentData *trs = tr;
 256   for(Int_t i=0; i<ntracks; i++){
 257     AliHLTTPCTrack *track = NextTrack();
 258     track->SetPt(trs->fPt);
 259     track->SetPterr(trs->fPterr);
 260     Float_t psi[1];
 261     psi[0]=trs->fPsi;
 262     AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
 263     track->SetPsi(psi[0]);
 264     track->SetTgl(trs->fTgl);
 265     track->SetPsierr(trs->fPsierr);
 266     track->SetTglerr(trs->fTglerr);
 267     track->SetNHits(trs->fNPoints);
 268     track->SetCharge(trs->fCharge);
 269     Float_t first[3];
 270     first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
 271     AliHLTTPCTransform::Local2Global(first,slice);
 272     track->SetFirstPoint(first[0],first[1],first[2]);
 273     Float_t last[3];
 274     last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
 275     AliHLTTPCTransform::Local2Global(last,slice);
 276     track->SetLastPoint(last[0],last[1],last[2]);
 277     track->SetHits( trs->fNPoints, trs->fPointIDs );
 278 #ifdef INCLUDE_TPC_HOUGH
 279 #ifdef ROWHOUGHPARAMS
 280     if(GetTrackType()=='h') {
 281       ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
 282       ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
 283     }
 284     track->SetMCid(trs->fTrackID);
 285     track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
 286     track->SetSector(slice);
 287     track->SetPID(trs->fPID);
 288 #endif
 289 #endif // INCLUDE_TPC_HOUGH
 290     UChar_t *tmpP = (UChar_t*)trs;
 291     tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
 292     trs = (AliHLTTPCTrackSegmentData*)tmpP;
 293   }
 294 }
 295
 296 UInt_t AliHLTTPCTrackArray::GetOutSize()
 297 {
 298   //get size for IO
 299   UInt_t count = GetOutCount();   //use only present tracks
 300   UInt_t tHits = 0;
 301   for(Int_t i=0;i<fNTracks;i++){  //loop over all tracks
 302     AliHLTTPCTrack *track = GetCheckedTrack(i);  //use only present tracks
 303     if(track)                                       //use only present tracks
 304       tHits += track->GetNHits();
 305   }
 306
 307   //calculate size of track
 308   return count*sizeof(AliHLTTPCTrackSegmentData)+sizeof(UInt_t)*tHits;
 309 }
 310
 311 UInt_t AliHLTTPCTrackArray::WriteTracks(UInt_t & ntracks,AliHLTTPCTrackSegmentData* tr)
 312 {
 313   //write tracks
 314   ntracks = GetOutCount();
 315   return WriteTracks(tr);
 316 }
 317
 318 UInt_t AliHLTTPCTrackArray::WriteTracks(AliHLTTPCTrackSegmentData* tr)
 319 {
 320   //if(GetTrackType()=='c') return WriteConfMapTracks(tr);
 321   AliHLTTPCTrackSegmentData *tP = tr;
 322   UInt_t *pP;
 323   UInt_t size = 0;
 324   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
 325     AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
 326     if(!track) continue;                           //use only present tracks
 327     tP->fX = track->GetFirstPointX();
 328     tP->fY = track->GetFirstPointY();
 329     tP->fZ = track->GetFirstPointZ();
 330     tP->fPt = track->GetPt();
 331     tP->fPterr = track->GetPterr();
 332     tP->fLastX = track->GetLastPointX();
 333     tP->fLastY = track->GetLastPointY();
 334     tP->fLastZ = track->GetLastPointZ();
 335     tP->fPsi = track->GetPsi();
 336     tP->fTgl = track->GetTgl();
 337     tP->fPsierr = track->GetPsierr();
 338     tP->fTglerr = track->GetTglerr();
 339     tP->fCharge = track->GetCharge();
 340     tP->fNPoints = track->GetNHits();
 341 #ifdef INCLUDE_TPC_HOUGH
 342 #ifdef ROWHOUGHPARAMS
 343     if(GetTrackType()=='h') {
 344       tP->fWeight = ((AliHLTTPCHoughTrack *)track)->GetWeight();
 345       tP->fBinX = ((AliHLTTPCHoughTrack *)track)->GetBinX();
 346       tP->fBinY = ((AliHLTTPCHoughTrack *)track)->GetBinY();
 347       tP->fBinXSize = ((AliHLTTPCHoughTrack *)track)->GetSizeX();
 348       tP->fBinYSize = ((AliHLTTPCHoughTrack *)track)->GetSizeY();
 349     }
 350     tP->fTrackID = track->GetMCid();
 351     tP->fRowRange1 = track->GetFirstRow();
 352     tP->fRowRange2 = track->GetLastRow();
 353     tP->fSector = track->GetSector();
 354     tP->fPID = track->GetPID();
 355 #endif
 356 #endif // INCLUDE_TPC_HOUGH
 357     pP = (UInt_t*)track->GetHitNumbers();
 358     for (UInt_t j=0;j<tP->fNPoints;j++){
 359       tP->fPointIDs[j] = pP[j];
 360     }
 361     Byte_t *tmpP = (Byte_t *)tP;
 362     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 363     size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 364     tP = (AliHLTTPCTrackSegmentData*)tmpP;
 365   }
 366   return size;
 367 }
 368
 369 UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
 370 {
 371   // use first and last point objects
 372   AliHLTTPCTrackSegmentData *tP = tr;
 373   UInt_t *pP;
 374   UInt_t size = 0;
 375   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
 376     AliHLTTPCConfMapTrack *track =(AliHLTTPCConfMapTrack *) GetCheckedTrack(i); //use only present tracks
 377     if(!track) continue;                           //use only present tracks
 378     AliHLTTPCConfMapPoint *hit = (AliHLTTPCConfMapPoint*)track->GetLastHit();
 379     AliHLTTPCConfMapPoint *lastHit = (AliHLTTPCConfMapPoint*)track->GetFirstHit();
 380     tP->fX = hit->GetX();
 381     tP->fY = hit->GetY();
 382     tP->fZ = hit->GetZ();
 383     tP->fLastX = lastHit->GetX();
 384     tP->fLastY = lastHit->GetY();
 385     tP->fLastZ = lastHit->GetZ();
 386
 387 //    tP->fX = track->GetFirstPointX();
 388 //    tP->fY = track->GetFirstPointY();
 389 //    tP->fZ = track->GetFirstPointZ();
 390     tP->fPt = track->GetPt();
 391     tP->fPterr = track->GetPterr();
 392 //    tP->fLastX = track->GetLastPointX();
 393 //    tP->fLastY = track->GetLastPointY();
 394 //    tP->fLastZ = track->GetLastPointZ();
 395     tP->fPsi = track->GetPsi();
 396     tP->fTgl = track->GetTgl();
 397     tP->fPsierr = track->GetPsierr();
 398     tP->fTglerr = track->GetTglerr();
 399     tP->fCharge = track->GetCharge();
 400 #ifdef INCLUDE_TPC_HOUGH
 401 #ifdef ROWHOUGHPARAMS
 402     tP->fTrackID = track->GetMCid();
 403     tP->fRowRange1 = track->GetFirstRow();
 404     tP->fRowRange2 = track->GetLastRow();
 405     tP->fSector = track->GetSector();
 406     tP->fPID = track->GetPID();
 407 #endif
 408 #endif // INCLUDE_TPC_HOUGH
 409     tP->fNPoints = track->GetNHits();
 410     pP = (UInt_t*)track->GetHitNumbers();
 411     for (UInt_t j=0;j<tP->fNPoints;j++){
 412       tP->fPointIDs[j] = pP[j];
 413     }
 414     Byte_t *tmpP = (Byte_t *)tP;
 415     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 416     size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 417     tP = (AliHLTTPCTrackSegmentData*)tmpP;
 418   }
 419   return size;
 420 }
 421
 422 void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
 423 {
 424   //add track to last position
 425   AliHLTTPCTrack *tpt = NextTrack();
 426   tpt->Set(track);
 427
 428 }
 429
 430 void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
 431 {
 432   //add tracks
 433   if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
 434     {
 435       LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
 436         <<"Bad idea to add tracks of different types"<<ENDLOG;
 437       return;
 438     }
 439   if(fSize < fNTracks+newtrack->GetNPresent())
 440     SetSize(fSize+newtrack->GetSize());
 441   for(Int_t i =0;i<newtrack->GetNTracks();i++){
 442     AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
 443     if(!tpt) continue;
 444     if(remove_old)
 445       newtrack->Remove(i);
 446     AliHLTTPCTrack *track = NextTrack();
 447     track->Set(tpt);
 448     if(slice>=0)
 449       track->Rotate(slice); //Rotate track to global coordinates
 450     /*
 451       AliHLTTPCTrack *track;
 452 #ifdef INCLUDE_TPC_HOUGH
 453       if(GetTrackType()=='h')
 454       track = (AliHLTTPCHoughTrack*)NextTrack();
 455       else
 456 #endif
 457       track = NextTrack();
 458       track->Set(tpt);
 459     */
 460   }
 461 }
 462
 463 void AliHLTTPCTrackArray::Compress()
 464 {
 465   //compress array
 466   if(GetNPresent()==GetNTracks()) return;
 467   AliHLTTPCTrack **tmp =  new AliHLTTPCTrack *[fNTracks];
 468   Int_t present=0;
 469   Int_t absent=GetNPresent();
 470   for(Int_t i=0;i<GetNTracks();i++){
 471     if(fIsPresent[i]) tmp[present++] = fTrack[i];
 472     else tmp[absent++] = fTrack[i];
 473   }
 474   for(Int_t i=0;i<GetNTracks();i++)
 475     fIsPresent[i]=kTRUE;
 476
 477   //Copy pointers back
 478   for(Int_t i=0; i<GetNTracks();i++){
 479     fTrack[i]=tmp[i];
 480   }
 481
 482   delete[] tmp;
 483
 484   fNTracks = GetNPresent();
 485   fNAbsent = 0;
 486 }
 487
 488 void AliHLTTPCTrackArray::QSort()
 489 {
 490   // compress and sort
 491   Compress();
 492   QSort(fTrack,0,fNTracks);
 493 }
 494
 495 void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
 496 {
 497    // Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
 498    // Uses TrackCompare() to compare objects.
 499    // Thanks to Root!
 500
 501    static AliHLTTPCTrack *tmp;
 502    static int i;           // "static" to save stack space
 503    int j;
 504
 505    while (last - first > 1) {
 506       i = first;
 507       j = last;
 508       for (;;) {
 509         while (++i < last && TrackCompare(a[i], a[first]) < 0)
 510           ;
 511         while (--j > first && TrackCompare(a[j], a[first]) > 0)
 512           ;
 513          if (i >= j)
 514             break;
 515
 516          tmp  = a[i];
 517          a[i] = a[j];
 518          a[j] = tmp;
 519       }
 520       if (j == first) {
 521          ++first;
 522          continue;
 523       }
 524       tmp = a[first];
 525       a[first] = a[j];
 526       a[j] = tmp;
 527       if (j - first < last - (j + 1)) {
 528          QSort(a, first, j);
 529          first = j + 1;   // QSort(j + 1, last);
 530       } else {
 531          QSort(a, j + 1, last);
 532          last = j;        // QSort(first, j);
 533       }
 534    }
 535 }
 536
 537 Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack *a, AliHLTTPCTrack *b) const
 538 {
 539    // Compare the two tracks.
 540
 541   return b->Compare(a);
 542
 543   /*
 544 #ifdef INCLUDE_TPC_HOUGH
 545     if(fTrackType=='h')
 546     {
 547     AliHLTTPCHoughTrack *tra = (AliHLTTPCHoughTrack*)a;
 548     AliHLTTPCHoughTrack *trb = (AliHLTTPCHoughTrack*)b;
 549     if(tra->GetWeight() < trb->GetWeight()) return 1;
 550     if(tra->GetWeight() > trb->GetWeight()) return -1;
 551     }
 552     else
 553 #endif
 554     {
 555     if(a->GetNHits() < b->GetNHits()) return 1;
 556     if(a->GetNHits() > b->GetNHits()) return -1;
 557     }
 558
 559     return 0;
 560   */
 561 }
 562
 563