HLT/src/AliL3TrackArray.cxx

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