HLT/src/AliL3TrackArray.cxx

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