HLT/src/AliHLTTrackArray.cxx

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