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 // BEGINN ############################################## MODIFIY JMT
 279     track->SetSector(slice);
 280     track->CalculateHelix();
 281 // END ################################################# MODIFIY JMT
 282 #ifdef INCLUDE_TPC_HOUGH
 283 #ifdef ROWHOUGHPARAMS
 284     if(GetTrackType()=='h') {
 285       ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
 286       ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
 287     }
 288     track->SetMCid(trs->fTrackID);
 289     track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
 290     track->SetSector(slice);
 291     track->SetPID(trs->fPID);
 292 #endif
 293 #endif // INCLUDE_TPC_HOUGH
 294     UChar_t *tmpP = (UChar_t*)trs;
 295     tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
 296     trs = (AliHLTTPCTrackSegmentData*)tmpP;
 297   }
 298 }
 299
 300 UInt_t AliHLTTPCTrackArray::GetOutSize()
 301 {
 302   //get size for IO
 303   UInt_t count = GetOutCount();   //use only present tracks
 304   UInt_t tHits = 0;
 305   for(Int_t i=0;i<fNTracks;i++){  //loop over all tracks
 306     AliHLTTPCTrack *track = GetCheckedTrack(i);  //use only present tracks
 307     if(track)                                       //use only present tracks
 308       tHits += track->GetNHits();
 309   }
 310
 311   //calculate size of track
 312   return count*sizeof(AliHLTTPCTrackSegmentData)+sizeof(UInt_t)*tHits;
 313 }
 314
 315 UInt_t AliHLTTPCTrackArray::WriteTracks(UInt_t & ntracks,AliHLTTPCTrackSegmentData* tr)
 316 {
 317   //write tracks
 318   ntracks = GetOutCount();
 319   return WriteTracks(tr);
 320 }
 321
 322 UInt_t AliHLTTPCTrackArray::WriteTracks(AliHLTTPCTrackSegmentData* tr)
 323 {
 324   //if(GetTrackType()=='c') return WriteConfMapTracks(tr);
 325   AliHLTTPCTrackSegmentData *tP = tr;
 326   UInt_t *pP;
 327   UInt_t size = 0;
 328   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
 329     AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
 330     if(!track) continue;                           //use only present tracks
 331     tP->fX = track->GetFirstPointX();
 332     tP->fY = track->GetFirstPointY();
 333     tP->fZ = track->GetFirstPointZ();
 334     tP->fPt = track->GetPt();
 335     tP->fPterr = track->GetPterr();
 336     tP->fLastX = track->GetLastPointX();
 337     tP->fLastY = track->GetLastPointY();
 338     tP->fLastZ = track->GetLastPointZ();
 339     tP->fPsi = track->GetPsi();
 340     tP->fTgl = track->GetTgl();
 341     tP->fPsierr = track->GetPsierr();
 342     tP->fTglerr = track->GetTglerr();
 343     tP->fCharge = track->GetCharge();
 344     tP->fNPoints = track->GetNHits();
 345 #ifdef INCLUDE_TPC_HOUGH
 346 #ifdef ROWHOUGHPARAMS
 347     if(GetTrackType()=='h') {
 348       tP->fWeight = ((AliHLTTPCHoughTrack *)track)->GetWeight();
 349       tP->fBinX = ((AliHLTTPCHoughTrack *)track)->GetBinX();
 350       tP->fBinY = ((AliHLTTPCHoughTrack *)track)->GetBinY();
 351       tP->fBinXSize = ((AliHLTTPCHoughTrack *)track)->GetSizeX();
 352       tP->fBinYSize = ((AliHLTTPCHoughTrack *)track)->GetSizeY();
 353     }
 354     tP->fTrackID = track->GetMCid();
 355     tP->fRowRange1 = track->GetFirstRow();
 356     tP->fRowRange2 = track->GetLastRow();
 357     tP->fSector = track->GetSector();
 358     tP->fPID = track->GetPID();
 359 #endif
 360 #endif // INCLUDE_TPC_HOUGH
 361     pP = (UInt_t*)track->GetHitNumbers();
 362     for (UInt_t j=0;j<tP->fNPoints;j++){
 363       tP->fPointIDs[j] = pP[j];
 364     }
 365     Byte_t *tmpP = (Byte_t *)tP;
 366     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 367     size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 368     tP = (AliHLTTPCTrackSegmentData*)tmpP;
 369
 370 // BEGINN ############################################## MODIFIY JMT
 371     LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::WriteTracks","TRACKPARAMETER") <<ENDLOG;
 372     track->Rotate(0,kFALSE);
 373     track->Print();
 374 // END ################################################# MODIFIY JMT
 375
 376   }
 377   return size;
 378 }
 379
 380 UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
 381 {
 382   // use first and last point objects
 383   AliHLTTPCTrackSegmentData *tP = tr;
 384   UInt_t *pP;
 385   UInt_t size = 0;
 386   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
 387     AliHLTTPCConfMapTrack *track =(AliHLTTPCConfMapTrack *) GetCheckedTrack(i); //use only present tracks
 388     if(!track) continue;                           //use only present tracks
 389     AliHLTTPCConfMapPoint *hit = (AliHLTTPCConfMapPoint*)track->GetLastHit();
 390     AliHLTTPCConfMapPoint *lastHit = (AliHLTTPCConfMapPoint*)track->GetFirstHit();
 391     tP->fX = hit->GetX();
 392     tP->fY = hit->GetY();
 393     tP->fZ = hit->GetZ();
 394     tP->fLastX = lastHit->GetX();
 395     tP->fLastY = lastHit->GetY();
 396     tP->fLastZ = lastHit->GetZ();
 397
 398 //    tP->fX = track->GetFirstPointX();
 399 //    tP->fY = track->GetFirstPointY();
 400 //    tP->fZ = track->GetFirstPointZ();
 401     tP->fPt = track->GetPt();
 402     tP->fPterr = track->GetPterr();
 403 //    tP->fLastX = track->GetLastPointX();
 404 //    tP->fLastY = track->GetLastPointY();
 405 //    tP->fLastZ = track->GetLastPointZ();
 406     tP->fPsi = track->GetPsi();
 407     tP->fTgl = track->GetTgl();
 408     tP->fPsierr = track->GetPsierr();
 409     tP->fTglerr = track->GetTglerr();
 410     tP->fCharge = track->GetCharge();
 411 #ifdef INCLUDE_TPC_HOUGH
 412 #ifdef ROWHOUGHPARAMS
 413     tP->fTrackID = track->GetMCid();
 414     tP->fRowRange1 = track->GetFirstRow();
 415     tP->fRowRange2 = track->GetLastRow();
 416     tP->fSector = track->GetSector();
 417     tP->fPID = track->GetPID();
 418 #endif
 419 #endif // INCLUDE_TPC_HOUGH
 420     tP->fNPoints = track->GetNHits();
 421     pP = (UInt_t*)track->GetHitNumbers();
 422     for (UInt_t j=0;j<tP->fNPoints;j++){
 423       tP->fPointIDs[j] = pP[j];
 424     }
 425     Byte_t *tmpP = (Byte_t *)tP;
 426     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 427     size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 428     tP = (AliHLTTPCTrackSegmentData*)tmpP;
 429   }
 430   return size;
 431 }
 432
 433 void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
 434 {
 435   //add track to last position
 436   AliHLTTPCTrack *tpt = NextTrack();
 437   tpt->Set(track);
 438
 439 }
 440
 441 void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
 442 {
 443   //add tracks
 444   if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
 445     {
 446       LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
 447         <<"Bad idea to add tracks of different types"<<ENDLOG;
 448       return;
 449     }
 450   if(fSize < fNTracks+newtrack->GetNPresent())
 451     SetSize(fSize+newtrack->GetSize());
 452   for(Int_t i =0;i<newtrack->GetNTracks();i++){
 453     AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
 454     if(!tpt) continue;
 455     if(remove_old)
 456       newtrack->Remove(i);
 457     AliHLTTPCTrack *track = NextTrack();
 458     track->Set(tpt);
 459     if(slice>=0)
 460       track->Rotate(slice); //Rotate track to global coordinates
 461     /*
 462       AliHLTTPCTrack *track;
 463 #ifdef INCLUDE_TPC_HOUGH
 464       if(GetTrackType()=='h')
 465       track = (AliHLTTPCHoughTrack*)NextTrack();
 466       else
 467 #endif
 468       track = NextTrack();
 469       track->Set(tpt);
 470     */
 471   }
 472 }
 473
 474 void AliHLTTPCTrackArray::Compress()
 475 {
 476   //compress array
 477   if(GetNPresent()==GetNTracks()) return;
 478   AliHLTTPCTrack **tmp =  new AliHLTTPCTrack *[fNTracks];
 479   Int_t present=0;
 480   Int_t absent=GetNPresent();
 481   for(Int_t i=0;i<GetNTracks();i++){
 482     if(fIsPresent[i]) tmp[present++] = fTrack[i];
 483     else tmp[absent++] = fTrack[i];
 484   }
 485   for(Int_t i=0;i<GetNTracks();i++)
 486     fIsPresent[i]=kTRUE;
 487
 488   //Copy pointers back
 489   for(Int_t i=0; i<GetNTracks();i++){
 490     fTrack[i]=tmp[i];
 491   }
 492
 493   delete[] tmp;
 494
 495   fNTracks = GetNPresent();
 496   fNAbsent = 0;
 497 }
 498
 499 void AliHLTTPCTrackArray::QSort()
 500 {
 501   // compress and sort
 502   Compress();
 503   QSort(fTrack,0,fNTracks);
 504 }
 505
 506 void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
 507 {
 508    // Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
 509    // Uses TrackCompare() to compare objects.
 510    // Thanks to Root!
 511
 512    static AliHLTTPCTrack *tmp;
 513    static int i;           // "static" to save stack space
 514    int j;
 515
 516    while (last - first > 1) {
 517       i = first;
 518       j = last;
 519       for (;;) {
 520         while (++i < last && TrackCompare(a[i], a[first]) < 0)
 521           ;
 522         while (--j > first && TrackCompare(a[j], a[first]) > 0)
 523           ;
 524          if (i >= j)
 525             break;
 526
 527          tmp  = a[i];
 528          a[i] = a[j];
 529          a[j] = tmp;
 530       }
 531       if (j == first) {
 532          ++first;
 533          continue;
 534       }
 535       tmp = a[first];
 536       a[first] = a[j];
 537       a[j] = tmp;
 538       if (j - first < last - (j + 1)) {
 539          QSort(a, first, j);
 540          first = j + 1;   // QSort(j + 1, last);
 541       } else {
 542          QSort(a, j + 1, last);
 543          last = j;        // QSort(first, j);
 544       }
 545    }
 546 }
 547
 548 Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack *a, AliHLTTPCTrack *b) const
 549 {
 550    // Compare the two tracks.
 551
 552   return b->Compare(a);
 553
 554   /*
 555 #ifdef INCLUDE_TPC_HOUGH
 556     if(fTrackType=='h')
 557     {
 558     AliHLTTPCHoughTrack *tra = (AliHLTTPCHoughTrack*)a;
 559     AliHLTTPCHoughTrack *trb = (AliHLTTPCHoughTrack*)b;
 560     if(tra->GetWeight() < trb->GetWeight()) return 1;
 561     if(tra->GetWeight() > trb->GetWeight()) return -1;
 562     }
 563     else
 564 #endif
 565     {
 566     if(a->GetNHits() < b->GetNHits()) return 1;
 567     if(a->GetNHits() > b->GetNHits()) return -1;
 568     }
 569
 570     return 0;
 571   */
 572 }
 573
 574