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     UChar_t *tmpP = (UChar_t*)trs;
 203     tmpP += sizeof(AliL3TrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
 204     trs = (AliL3TrackSegmentData*)tmpP;
 205   }
 206 }
 207
 208 void AliL3TrackArray::FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr,Int_t slice){
 209   //Read tracks from shared memory (or memory)
 210   AliL3TrackSegmentData *trs = tr;
 211   for(Int_t i=0; i<ntracks; i++){
 212     AliL3Track *track = NextTrack();
 213     track->SetPt(trs->fPt);
 214     Float_t psi[1];
 215     psi[0]=trs->fPsi;
 216     AliL3Transform::Local2GlobalAngle(psi,slice);
 217     track->SetPsi(psi[0]);
 218     track->SetTgl(trs->fTgl);
 219     track->SetNHits(trs->fNPoints);
 220     track->SetCharge(trs->fCharge);
 221     Float_t first[3];
 222     first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
 223     AliL3Transform::Local2Global(first,slice);
 224     track->SetFirstPoint(first[0],first[1],first[2]);
 225     Float_t last[3];
 226     last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
 227     AliL3Transform::Local2Global(last,slice);
 228     track->SetLastPoint(last[0],last[1],last[2]);
 229     track->SetHits( trs->fNPoints, trs->fPointIDs );
 230     UChar_t *tmpP = (UChar_t*)trs;
 231     tmpP += sizeof(AliL3TrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
 232     trs = (AliL3TrackSegmentData*)tmpP;
 233   }
 234 }
 235
 236 UInt_t AliL3TrackArray::GetOutSize(){
 237   UInt_t count = GetOutCount();   //use only present tracks
 238   UInt_t tHits = 0;
 239   for(Int_t i=0;i<fNTracks;i++){  //loop over all tracks
 240     AliL3Track *track = GetCheckedTrack(i);  //use only present tracks
 241     if(track)                                       //use only present tracks
 242       tHits += track->GetNHits();
 243   }
 244
 245   //calculate size of track
 246   return count*sizeof(AliL3TrackSegmentData)+sizeof(UInt_t)*tHits;
 247 }
 248
 249 UInt_t AliL3TrackArray::WriteTracks(UInt_t & ntracks,AliL3TrackSegmentData* tr){
 250   ntracks = GetOutCount();
 251   return WriteTracks(tr);
 252 }
 253
 254 UInt_t AliL3TrackArray::WriteTracks(AliL3TrackSegmentData* tr){
 255   //if(GetTrackType()=='c') return WriteConfMapTracks(tr);
 256   AliL3TrackSegmentData *tP = tr;
 257   UInt_t *pP;
 258   UInt_t size = 0;
 259   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
 260     AliL3Track *track = GetCheckedTrack(i); //use only present tracks
 261     if(!track) continue;                           //use only present tracks
 262     tP->fX = track->GetFirstPointX();
 263     tP->fY = track->GetFirstPointY();
 264     tP->fZ = track->GetFirstPointZ();
 265     tP->fPt = track->GetPt();
 266     tP->fLastX = track->GetLastPointX();
 267     tP->fLastY = track->GetLastPointY();
 268     tP->fLastZ = track->GetLastPointZ();
 269     tP->fPsi = track->GetPsi();
 270     tP->fTgl = track->GetTgl();
 271     tP->fCharge = track->GetCharge();
 272     tP->fNPoints = track->GetNHits();
 273
 274     pP = (UInt_t*)track->GetHitNumbers();
 275     for (UInt_t j=0;j<tP->fNPoints;j++){
 276       tP->fPointIDs[j] = pP[j];
 277     }
 278     Byte_t *tmpP = (Byte_t *)tP;
 279     tmpP += sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 280     size += sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 281     tP = (AliL3TrackSegmentData*)tmpP;
 282   }
 283   return size;
 284 }
 285
 286 UInt_t AliL3TrackArray::WriteConfMapTracks(AliL3TrackSegmentData* tr){
 287   // use first and last point objects
 288   AliL3TrackSegmentData *tP = tr;
 289   UInt_t *pP;
 290   UInt_t size = 0;
 291   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
 292     AliL3ConfMapTrack *track =(AliL3ConfMapTrack *) GetCheckedTrack(i); //use only present tracks
 293     if(!track) continue;                           //use only present tracks
 294     AliL3ConfMapPoint *hit = (AliL3ConfMapPoint*)track->lastHit;
 295     AliL3ConfMapPoint *lastHit = (AliL3ConfMapPoint*)track->firstHit;
 296     tP->fX = hit->GetX();
 297     tP->fY = hit->GetY();
 298     tP->fZ = hit->GetZ();
 299     tP->fLastX = lastHit->GetX();
 300     tP->fLastY = lastHit->GetY();
 301     tP->fLastZ = lastHit->GetZ();
 302
 303 //    tP->fX = track->GetFirstPointX();
 304 //    tP->fY = track->GetFirstPointY();
 305 //    tP->fZ = track->GetFirstPointZ();
 306     tP->fPt = track->GetPt();
 307 //    tP->fLastX = track->GetLastPointX();
 308 //    tP->fLastY = track->GetLastPointY();
 309 //    tP->fLastZ = track->GetLastPointZ();
 310     tP->fPsi = track->GetPsi();
 311     tP->fTgl = track->GetTgl();
 312     tP->fCharge = track->GetCharge();
 313     tP->fNPoints = track->GetNHits();
 314     pP = (UInt_t*)track->GetHitNumbers();
 315     for (UInt_t j=0;j<tP->fNPoints;j++){
 316       tP->fPointIDs[j] = pP[j];
 317     }
 318     Byte_t *tmpP = (Byte_t *)tP;
 319     tmpP += sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 320     size +=sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
 321     tP = (AliL3TrackSegmentData*)tmpP;
 322   }
 323   return size;
 324 }
 325
 326 void AliL3TrackArray::AddLast(AliL3Track *track)
 327 {
 328   AliL3Track *tpt = NextTrack();
 329   tpt->Set(track);
 330
 331 }
 332
 333 void AliL3TrackArray::AddTracks(AliL3TrackArray *newtrack,Bool_t remove_old,Int_t slice)
 334 {
 335   if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
 336     {
 337       LOG(AliL3Log::kError,"AliL3TrackArray::AddTracks","Track types")
 338         <<"Bad idea to add tracks of different types"<<ENDLOG;
 339       return;
 340     }
 341   if(fSize < fNTracks+newtrack->GetNPresent())
 342     SetSize(fSize+newtrack->GetSize());
 343   for(Int_t i =0;i<newtrack->GetNTracks();i++){
 344     AliL3Track *tpt = newtrack->GetCheckedTrack(i);
 345     if(!tpt) continue;
 346     if(remove_old)
 347       newtrack->Remove(i);
 348     AliL3Track *track = NextTrack();
 349     track->Set(tpt);
 350     if(slice>=0)
 351       track->Rotate(slice); //Rotate track to global coordinates
 352     /*
 353       AliL3Track *track;
 354       if(GetTrackType()=='h')
 355       track = (AliL3HoughTrack*)NextTrack();
 356       else
 357       track = NextTrack();
 358       track->Set(tpt);
 359     */
 360   }
 361 }
 362
 363
 364 void AliL3TrackArray::Compress(){
 365   if(GetNPresent()==GetNTracks()) return;
 366   AliL3Track **tmp =  new AliL3Track *[fNTracks];
 367   Int_t present=0;
 368   Int_t absent=GetNPresent();
 369   for(Int_t i=0;i<GetNTracks();i++){
 370     if(fIsPresent[i]) tmp[present++] = fTrack[i];
 371     else tmp[absent++] = fTrack[i];
 372   }
 373   for(Int_t i=0;i<GetNTracks();i++)
 374     fIsPresent[i]=kTRUE;
 375
 376   //Copy pointers back
 377   for(Int_t i=0; i<GetNTracks();i++){
 378     fTrack[i]=tmp[i];
 379   }
 380
 381   delete[] tmp;
 382
 383   fNTracks = GetNPresent();
 384   fNAbsent = 0;
 385 }
 386
 387 void AliL3TrackArray::QSort(){
 388   // compress an sort
 389   Compress();
 390   QSort(fTrack,0,fNTracks);
 391 }
 392
 393 void AliL3TrackArray::QSort( AliL3Track **a, Int_t first, Int_t last){
 394
 395    // Sort array of AliL3Track pointers using a quicksort algorithm.
 396    // Uses TrackCompare() to compare objects.
 397    // Thanks to Root!
 398
 399    static AliL3Track *tmp;
 400    static int i;           // "static" to save stack space
 401    int j;
 402
 403    while (last - first > 1) {
 404       i = first;
 405       j = last;
 406       for (;;) {
 407         while (++i < last && TrackCompare(a[i], a[first]) < 0)
 408           ;
 409         while (--j > first && TrackCompare(a[j], a[first]) > 0)
 410           ;
 411          if (i >= j)
 412             break;
 413
 414          tmp  = a[i];
 415          a[i] = a[j];
 416          a[j] = tmp;
 417       }
 418       if (j == first) {
 419          ++first;
 420          continue;
 421       }
 422       tmp = a[first];
 423       a[first] = a[j];
 424       a[j] = tmp;
 425       if (j - first < last - (j + 1)) {
 426          QSort(a, first, j);
 427          first = j + 1;   // QSort(j + 1, last);
 428       } else {
 429          QSort(a, j + 1, last);
 430          last = j;        // QSort(first, j);
 431       }
 432    }
 433 }
 434
 435 Int_t AliL3TrackArray::TrackCompare(AliL3Track *a, AliL3Track *b){
 436    // Compare the two tracks.
 437
 438   return b->Compare(a);
 439
 440   /*
 441     if(fTrackType=='h')
 442     {
 443     AliL3HoughTrack *tra = (AliL3HoughTrack*)a;
 444     AliL3HoughTrack *trb = (AliL3HoughTrack*)b;
 445     if(tra->GetWeight() < trb->GetWeight()) return 1;
 446     if(tra->GetWeight() > trb->GetWeight()) return -1;
 447     }
 448     else
 449     {
 450     if(a->GetNHits() < b->GetNHits()) return 1;
 451     if(a->GetNHits() > b->GetNHits()) return -1;
 452     }
 453
 454     return 0;
 455   */
 456 }
 457
 458