HLT/src/AliL3MemHandler.cxx

   1 //Author:        Uli Frankenfeld
   2 //Last Modified: 17.12.2000
   3
   4 #include <math.h>
   5 #include <time.h>
   6 #include <iostream.h>
   7 #include <stdio.h>
   8
   9 #include "AliL3MemHandler.h"
  10 #include "AliL3Transform.h"
  11 #include "AliL3Logging.h"
  12
  13 #include "AliL3DigitData.h"
  14 #include "AliL3TrackSegmentData.h"
  15 #include "AliL3SpacePointData.h"
  16 #include "AliL3TrackArray.h"
  17 //_____________________________________________________________
  18 //
  19 // The L3 Binary File handler
  20 //
  21
  22 ClassImp(AliL3MemHandler)
  23
  24 AliL3MemHandler::AliL3MemHandler(){
  25   //Default constructor
  26   fPt = 0;
  27   fSize =0;
  28   fInBinary = 0;
  29   fOutBinary = 0;
  30   fNRandom = 0;
  31   Int_t r[2]={0,0};
  32   Init(0,0,r);
  33   IsRandom = kFALSE;
  34   fDigits = 0;
  35   fDPt =0;
  36   fNGenerate = 0;
  37   fNUsed = 0;
  38   fNDigits = 0;
  39
  40   Int_t row[2] = {0,173};
  41   Init(0,0,row);
  42   ResetROI();
  43 }
  44
  45
  46 AliL3MemHandler::~AliL3MemHandler(){
  47   //Destructor
  48   if(fPt) delete[] fPt;
  49   if(fDigits) delete [] fDigits;
  50   if(fDPt) delete [] fDPt;
  51 }
  52
  53 void AliL3MemHandler::ResetROI(){
  54     for(Int_t i=fRowMin; i<=fRowMax; i++)
  55       {
  56       fEtaMinTimeBin[i] = 0;
  57       fEtaMaxTimeBin[i] = 445;
  58       }
  59 }
  60
  61
  62 void AliL3MemHandler::SetROI(Float_t *eta,Int_t *slice){
  63  if(eta[1]==0)
  64      {
  65      LOG(AliL3Log::kWarning,"AliL3MemHandler::SetROI","Eta Values")
  66          <<"Bad ROI parameters. IDIOT! "<<ENDLOG;
  67      for(Int_t i=fRowMin; i<=fRowMax; i++)
  68          {
  69          fEtaMinTimeBin[i]=0;
  70          fEtaMaxTimeBin[i]=0;
  71          }
  72      return;
  73      }
  74
  75  for(Int_t i=fRowMin; i<=fRowMax; i++)
  76      {
  77      Int_t sector,row;
  78      Float_t xyz[3];
  79
  80      Float_t thetamax = 2*atan(exp(-1.*eta[1]));
  81
  82      xyz[0] = fTransformer->Row2X(i);
  83      xyz[1]=0;
  84      xyz[2] = xyz[0]/tan(thetamax);
  85      fTransformer->Slice2Sector(fSlice,i,sector,row);
  86      fTransformer->Local2Raw(xyz,sector,row);
  87
  88      fEtaMinTimeBin[i] = (Int_t)xyz[2];
  89
  90      if(eta[0]==0)
  91          fEtaMaxTimeBin[i] = 445;
  92      else
  93          {
  94          Float_t thetamin = 2*atan(exp(-1.*eta[0]));
  95          xyz[0] = fTransformer->Row2X(i);
  96          xyz[1] = fTransformer->GetMaxY(i);
  97          Float_t radii = sqrt(pow(xyz[0],2) + pow(xyz[1],2));
  98          xyz[2] = radii/tan(thetamin);
  99          fTransformer->Local2Raw(xyz,sector,row);
 100          fEtaMaxTimeBin[i] = (Int_t)xyz[2];
 101          }
 102      }
 103
 104 }
 105
 106 Bool_t AliL3MemHandler::SetBinaryInput(char *name){
 107   fInBinary = fopen(name,"r");
 108   if(!fInBinary){
 109     LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open")
 110     <<"Pointer to File = 0x0 "<<ENDLOG;
 111     return kFALSE;
 112   }
 113   return kTRUE;
 114 }
 115
 116 Bool_t AliL3MemHandler::SetBinaryInput(FILE *file){
 117   fInBinary = file;
 118   if(!fInBinary){
 119     LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open")
 120     <<"Pointer to File = 0x0 "<<ENDLOG;
 121     return kFALSE;
 122   }
 123   return kTRUE;
 124 }
 125
 126 void AliL3MemHandler::CloseBinaryInput(){
 127   if(!fInBinary){
 128     LOG(AliL3Log::kWarning,"AliL3MemHandler::CloseBinaryInput","File Close")
 129     <<"Nothing to Close"<<ENDLOG;
 130     return;
 131   }
 132   fclose(fInBinary);
 133   fInBinary =0;
 134 }
 135
 136 Bool_t AliL3MemHandler::SetBinaryOutput(char *name){
 137   fOutBinary = fopen(name,"w");
 138   if(!fOutBinary){
 139     LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryOutput","File Open")
 140     <<"Pointer to File = 0x0 "<<ENDLOG;
 141     return kFALSE;
 142   }
 143   return kTRUE;
 144 }
 145
 146 Bool_t AliL3MemHandler::SetBinaryOutput(FILE *file){
 147   fOutBinary = file;
 148   if(!fOutBinary){
 149     LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryOutput","File Open")
 150     <<"Pointer to File = 0x0 "<<ENDLOG;
 151     return kFALSE;
 152   }
 153   return kTRUE;
 154 }
 155
 156 void AliL3MemHandler::CloseBinaryOutput(){
 157   if(!fOutBinary){
 158     LOG(AliL3Log::kWarning,"AliL3MemHandler::CloseBinaryOutPut","File Close")
 159     <<"Nothing to Close"<<ENDLOG;
 160     return;
 161   }
 162   fclose(fOutBinary);
 163   fOutBinary =0;
 164 }
 165
 166
 167 UInt_t AliL3MemHandler::GetFileSize(){
 168   if(!fInBinary){
 169     LOG(AliL3Log::kWarning,"AliL3MemHandler::GetFileSize","File")
 170     <<"No Input File"<<ENDLOG;
 171     return 0;
 172   }
 173   fseek(fInBinary,0,SEEK_END);
 174   UInt_t size = (UInt_t) ftell(fInBinary);
 175   rewind(fInBinary);
 176   return size;
 177 }
 178
 179 Byte_t *AliL3MemHandler::Allocate(){
 180   return Allocate(GetFileSize());
 181 }
 182
 183 Byte_t *AliL3MemHandler::Allocate(AliL3TrackArray *array){
 184   if(!array){
 185     LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory")
 186     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
 187     return 0;
 188   }
 189   return Allocate(array->GetOutSize());
 190 }
 191
 192 Byte_t *AliL3MemHandler::Allocate(UInt_t size){
 193   if(fPt){
 194     LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory")
 195     <<"Delete Memory"<<ENDLOG;
 196     Free();
 197   }
 198   fPt = new Byte_t[size];
 199   fSize = size;
 200   LOG(AliL3Log::kDebug,"AliL3MemHandler::Allocate","Memory")
 201   <<AliL3Log::kDec<<"Allocate "<<size<<" Bytes of Memory"<<ENDLOG;
 202   return fPt;
 203 }
 204
 205 void AliL3MemHandler::Free(){
 206   if(!fPt){
 207     LOG(AliL3Log::kWarning,"AliL3MemHandler::Free","Memory")
 208     <<"No Memory allocated - can't Free"<<ENDLOG;
 209     return;
 210   }
 211   delete[] fPt;
 212   fPt = 0;
 213   fSize =0;
 214 }
 215
 216 ///////////////////////////////////////// Random
 217 void AliL3MemHandler::SetRandomSeed(){
 218   time_t *tp=0;
 219   SetRandomSeed(time(tp));
 220 }
 221
 222 void AliL3MemHandler::SetRandomCluster(Int_t maxnumber){
 223   IsRandom = kTRUE;
 224   fNRandom = maxnumber;
 225   fNDigits = 0;
 226   if(fDigits) delete [] fDigits;
 227   fDigits = new AliL3RandomDigitData[fNRandom*9];
 228   if(fDPt) delete [] fDPt;
 229   fDPt = (AliL3RandomDigitData **)new Int_t[fNRandom*9];
 230 }
 231
 232 void AliL3MemHandler::QSort(AliL3RandomDigitData **a, Int_t first, Int_t last){
 233
 234    // Sort array of AliL3RandomDigitData pointers using a quicksort algorithm.
 235    // Uses CompareDigits() to compare objects.
 236    // Thanks to Root!
 237
 238    static AliL3RandomDigitData *tmp;
 239    static int i;           // "static" to save stack space
 240    int j;
 241
 242    while (last - first > 1) {
 243       i = first;
 244       j = last;
 245       for (;;) {
 246          while (++i < last && CompareDigits(a[i], a[first]) < 0)
 247             ;
 248          while (--j > first && CompareDigits(a[j], a[first]) > 0)
 249             ;
 250          if (i >= j)
 251             break;
 252
 253          tmp  = a[i];
 254          a[i] = a[j];
 255          a[j] = tmp;
 256       }
 257       if (j == first) {
 258          ++first;
 259          continue;
 260       }
 261       tmp = a[first];
 262       a[first] = a[j];
 263       a[j] = tmp;
 264       if (j - first < last - (j + 1)) {
 265          QSort(a, first, j);
 266          first = j + 1;   // QSort(j + 1, last);
 267       } else {
 268          QSort(a, j + 1, last);
 269          last = j;        // QSort(first, j);
 270       }
 271    }
 272 }
 273
 274 UInt_t AliL3MemHandler::GetRandomSize(){
 275   Int_t nrandom = 0;
 276   for(Int_t r=fRowMin;r<=fRowMax;r++){
 277     Int_t npad=fTransformer->GetNPads(r);
 278     nrandom  += Int_t (fNGenerate * ((Double_t) npad/141.));
 279   }
 280   return 9 * nrandom * sizeof(AliL3DigitData);
 281 }
 282
 283 void AliL3MemHandler::Generate(Int_t row){
 284   if(!IsRandom) return;
 285   ResetRandom();
 286   fNDigits = 0;
 287   Int_t npad=fTransformer->GetNPads(row);
 288   Int_t ntime = fEtaMaxTimeBin[row] - fEtaMinTimeBin[row];
 289   Int_t nrandom  = Int_t (fNGenerate * ((Double_t) npad/141.) *
 290                    (Double_t) ntime/(Double_t) fTransformer->GetNTimeBins() );
 291
 292   for(Int_t n=0;n<nrandom;n++){
 293     Int_t pad = (int)((float)rand()/RAND_MAX*npad);
 294     Int_t time =(int)((float)rand()/RAND_MAX*ntime+fEtaMinTimeBin[row] );
 295     Int_t charge = (int)((float)rand()/RAND_MAX*1023);
 296     DigitizePoint(row,pad,time,charge);
 297   }
 298   QSort(fDPt,0,fNDigits);
 299 //  for(Int_t d=0;d<fNDigits;d++)
 300 //    fprintf(stderr,"%d %d %d %d\n",fDPt[d]->fRow,fDPt[d]->fPad,
 301 //                             fDPt[d]->fTime,fDPt[d]->fCharge);
 302 }
 303
 304
 305 void AliL3MemHandler::DigitizePoint(Int_t row, Int_t pad,
 306                                        Int_t time,Int_t charge){
 307   for(Int_t j=-1;j<2;j++){
 308     for(Int_t k=-1;k<2;k++){
 309       Int_t dcharge = charge;
 310       if(j) dcharge /=2;
 311       if(k) dcharge /=2;
 312       if(dcharge<10) continue;
 313       Int_t dpad  = j + pad;
 314       Int_t dtime = k + time;
 315
 316       if(dpad<0||dpad>=fTransformer->GetNPads(row))  continue;
 317       if(dtime<0||dtime>=fTransformer->GetNTimeBins()) continue;
 318
 319       fDigits[fNDigits].fCharge = dcharge;
 320       fDigits[fNDigits].fRow = row;
 321       fDigits[fNDigits].fPad = dpad;
 322       fDigits[fNDigits].fTime = dtime;
 323       fDPt[fNDigits] = &fDigits[fNDigits];
 324       fNDigits++;
 325     }
 326   }
 327 }
 328
 329 ///////////////////////////////////////// Digit IO
 330 Bool_t AliL3MemHandler::Memory2Binary(UInt_t nrow,AliL3DigitRowData *data){
 331   if(!fOutBinary){
 332     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
 333     <<"No Output File"<<ENDLOG;
 334     return kFALSE;
 335   }
 336   if(!data){
 337     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
 338     <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
 339     return kFALSE;
 340   }
 341
 342   AliL3DigitRowData *row_pt = data;
 343   Int_t outsize = 0;
 344   for(UInt_t i=0;i<nrow;i++){
 345     Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit
 346                                        + sizeof(AliL3DigitRowData);
 347     outsize += size;
 348     fwrite(row_pt,size,1,fOutBinary);
 349     Byte_t  *byte_pt =(Byte_t *) row_pt;
 350     byte_pt += size;
 351     row_pt = (AliL3DigitRowData *) byte_pt;
 352   }
 353   LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","Memory")
 354   <<AliL3Log::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
 355   <<nrow<<" Rows)"<<ENDLOG;
 356   return kTRUE;
 357 }
 358
 359 Bool_t AliL3MemHandler::Binary2Memory(UInt_t & nrow,AliL3DigitRowData *data){
 360   if(!fInBinary){
 361     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
 362     <<"No Input File"<<ENDLOG;
 363     return kFALSE;
 364   }
 365   if(!data){
 366     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
 367     <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
 368     return kFALSE;
 369   }
 370   rewind(fInBinary);
 371   AliL3DigitRowData *row_pt = data;
 372   UInt_t rowcount = 0;
 373   Int_t outsize =0;
 374   while(!feof(fInBinary)){
 375     Byte_t  *byte_pt =(Byte_t *) row_pt;
 376
 377     if(fread(row_pt,sizeof(AliL3DigitRowData),1,fInBinary)!=1) break;
 378     byte_pt += sizeof(AliL3DigitRowData);
 379     outsize += sizeof(AliL3DigitRowData);
 380
 381     Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit;
 382
 383     if(fread(byte_pt,size,1,fInBinary)!=1) break;
 384     byte_pt += size;
 385     outsize += size;
 386
 387     row_pt = (AliL3DigitRowData *) byte_pt;
 388     rowcount++;
 389   }
 390   nrow= rowcount;
 391     LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","Memory")
 392     <<AliL3Log::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
 393     <<rowcount<<" Rows)"<<ENDLOG;
 394   return kTRUE;
 395 }
 396
 397 void AliL3MemHandler::AddData(AliL3DigitData *data,UInt_t & ndata,
 398                    UInt_t row,UShort_t pad,UShort_t time,UShort_t charge){
 399   data[ndata].fPad = pad;
 400   data[ndata].fTime = time;
 401   data[ndata].fCharge = charge;
 402   ndata++;
 403 }
 404
 405 void AliL3MemHandler::AddRandom(AliL3DigitData *data, UInt_t & ndata){
 406   data[ndata].fPad = fDPt[fNUsed]->fPad;
 407   data[ndata].fTime = fDPt[fNUsed]->fTime;
 408   data[ndata].fCharge = fDPt[fNUsed]->fCharge;
 409   ndata++;
 410   fNUsed++;
 411 }
 412
 413 void AliL3MemHandler::MergeDataRandom(AliL3DigitData *data, UInt_t & ndata,
 414                    UInt_t row, UShort_t pad, UShort_t time, UShort_t charge){
 415 //  AddData(data,ndata,row,pad,time,charge);
 416   data[ndata].fPad = pad;
 417   data[ndata].fTime = time;
 418   data[ndata].fCharge = charge;
 419   while(ComparePoints(row,pad,time)==0){
 420     Int_t ch = data[ndata].fCharge + fDPt[fNUsed]->fCharge;
 421     if(charge>1023) ch = 1023;
 422     data[ndata].fCharge = ch;
 423     fNUsed++;
 424   }
 425   ndata++;
 426 }
 427
 428 void AliL3MemHandler::AddDataRandom(AliL3DigitData *data, UInt_t & ndata,
 429                    UInt_t row, UShort_t pad, UShort_t time, UShort_t charge){
 430   Int_t action;
 431   while((action=ComparePoints(row,pad,time))==1){
 432     AddRandom(data,ndata);
 433   }
 434   if(action==0){
 435     MergeDataRandom(data,ndata,row,pad,time,charge);
 436   }
 437   if(action<0){
 438     AddData(data,ndata,row,pad,time,charge);
 439   }
 440 }
 441
 442 void AliL3MemHandler::Write(UInt_t *comp, UInt_t & index,
 443                                     UInt_t & subindex, UShort_t value){
 444   UInt_t shift[3] = {0,10,20};
 445   comp[index] |= (value&0x03ff)<<shift[subindex];
 446   if(subindex == 2){
 447     subindex = 0;
 448     index++;
 449   }
 450   else subindex++;
 451 }
 452
 453 UShort_t AliL3MemHandler::Read(UInt_t *comp, UInt_t & index, UInt_t & subindex){
 454   UInt_t shift[3] = {0,10,20};
 455   UShort_t value = (comp[index]>>shift[subindex])&0x03ff;
 456   if(subindex == 2){
 457     subindex = 0;
 458     index++;
 459   }
 460   else subindex++;
 461
 462   return value;
 463 }
 464
 465 UShort_t AliL3MemHandler::Test(UInt_t *comp,
 466                          UInt_t index, UInt_t  subindex){
 467   UInt_t shift[3] = {0,10,20};
 468   return (comp[index]>>shift[subindex])&0x03ff;
 469 }
 470
 471 Int_t AliL3MemHandler::Memory2CompMemory(UInt_t nrow,
 472                                   AliL3DigitRowData *data,UInt_t *comp){
 473   if(!comp){
 474     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2CompMemory","Memory")
 475     <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 476     return 0;
 477   }
 478   if(!data){
 479     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2CompMemory","Memory")
 480     <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
 481     return 0;
 482   }
 483   AliL3DigitRowData *row_pt = data;
 484   UInt_t index=0;
 485   UInt_t subindex=0;
 486
 487   for(UInt_t i=0;i<nrow;i++){
 488     UShort_t value = row_pt->fRow;
 489     Write(comp,index,subindex,value);
 490     UShort_t maxpad=0;
 491     UShort_t npad=0;
 492     Int_t ddd[1000];
 493     for(Int_t d=0;d<200;d++) ddd[d]=0;
 494     for(UInt_t dig=0;dig<row_pt->fNDigit;dig++){
 495       if(row_pt->fDigitData[dig].fPad <200){
 496         ddd[row_pt->fDigitData[dig].fPad]++;
 497       }
 498     }
 499     for(Int_t d=0;d<200;d++){
 500       if(ddd[d]){
 501         npad++;
 502         maxpad =d;
 503       }
 504     }
 505     Write(comp,index,subindex,npad);
 506     UInt_t digit=0;
 507     for(UShort_t pad=0;pad <= maxpad;pad++){
 508       if(digit>=row_pt->fNDigit || row_pt->fDigitData[digit].fPad !=  pad)
 509         continue;
 510       Write(comp,index,subindex,pad);
 511 //    write zero if time != 0
 512       if(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
 513         if(row_pt->fDigitData[digit].fTime>0){
 514           Write(comp,index,subindex,0);
 515           Write(comp,index,subindex,row_pt->fDigitData[digit].fTime);
 516         }
 517       }
 518       while(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
 519         UShort_t charge = row_pt->fDigitData[digit].fCharge;
 520         if(charge>=1024){
 521           charge=1023;
 522         }
 523         Write(comp,index,subindex,charge);
 524         if(digit+1<row_pt->fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){
 525           if(row_pt->fDigitData[digit].fTime +1 !=
 526                      row_pt->fDigitData[digit+1].fTime){
 527             Write(comp,index,subindex,0);
 528             UShort_t nzero = row_pt->fDigitData[digit+1].fTime -
 529                              (row_pt->fDigitData[digit].fTime +1);
 530             Write(comp,index,subindex,nzero);
 531           }
 532         }
 533         digit++;
 534       }
 535       Write(comp,index,subindex,0);
 536       Write(comp,index,subindex,0);
 537     }
 538
 539     Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
 540                                             sizeof(AliL3DigitRowData);
 541     Byte_t  *byte_pt =(Byte_t *) row_pt;
 542     byte_pt += size;
 543     row_pt = (AliL3DigitRowData *) byte_pt;
 544   }
 545   while(subindex)
 546     Write(comp,index,subindex,0);
 547   return index * sizeof(UInt_t);
 548 }
 549
 550 Int_t AliL3MemHandler::CompMemory2Memory(UInt_t  nrow,
 551                                    AliL3DigitRowData *data,UInt_t *comp){
 552   if(!comp){
 553     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2Memory","Memory")
 554     <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 555     return 0;
 556   }
 557   if(!data){
 558     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2Memory","Memory")
 559     <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
 560     return 0;
 561   }
 562   Int_t outsize=0;
 563
 564   AliL3DigitRowData *row_pt = data;
 565   UInt_t index=0;
 566   UInt_t subindex=0;
 567
 568   for(UInt_t i=0;i<nrow;i++){
 569     UInt_t ndigit=0;
 570     UInt_t row =Read(comp,index,subindex);
 571     row_pt->fRow=row;
 572     Generate(row);
 573     UShort_t npad = Read(comp,index,subindex);
 574     for(UShort_t p=0;p<npad;p++){
 575       UShort_t charge;
 576       UShort_t time =0;
 577       UShort_t pad = Read(comp,index,subindex);
 578       if(Test(comp,index,subindex)==0){
 579         Read(comp,index,subindex);
 580         if( (time = Read(comp,index,subindex)) == 0 ){
 581           continue;
 582         }
 583       }
 584       for(;;){
 585         while( (charge=Read(comp,index,subindex)) != 0){
 586           if(time>=fEtaMinTimeBin[row]&&time<=fEtaMaxTimeBin[row])
 587 //          AddData(row_pt->fDigitData,ndigit,row,pad,time,charge);
 588             AddDataRandom(row_pt->fDigitData,ndigit,row,pad,time,charge);
 589           time++;
 590         }
 591         UShort_t tshift = Read(comp,index,subindex);
 592         if(tshift ==0) break;
 593         time += tshift;
 594       }
 595     }
 596     row_pt->fNDigit = ndigit;
 597     Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
 598                                         sizeof(AliL3DigitRowData);
 599     Byte_t  *byte_pt =(Byte_t *) row_pt;
 600     byte_pt += size;
 601     outsize += size;
 602     row_pt = (AliL3DigitRowData *) byte_pt;
 603   }
 604   return outsize;
 605 }
 606
 607 UInt_t AliL3MemHandler::GetCompMemorySize(UInt_t nrow,AliL3DigitRowData *data){
 608   if(!data){
 609     LOG(AliL3Log::kWarning,"AliL3MemHandler::GetCompMemorySize","Memory")
 610     <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
 611     return 0;
 612   }
 613   AliL3DigitRowData *row_pt = data;
 614   UInt_t index=0;
 615
 616   for(UInt_t i=0;i<nrow;i++){
 617     index++;
 618     UShort_t maxpad=0;
 619     UShort_t npad=0;
 620     Int_t ddd[1000];
 621     for(Int_t d=0;d<200;d++) ddd[d]=0;
 622     for(UInt_t dig=0;dig<row_pt->fNDigit;dig++){
 623       if(row_pt->fDigitData[dig].fPad <200){
 624         ddd[row_pt->fDigitData[dig].fPad]++;
 625       }
 626     }
 627     for(Int_t d=0;d<200;d++){
 628       if(ddd[d]){
 629         npad++;
 630         maxpad =d;
 631       }
 632     }
 633     index++;
 634     UInt_t digit=0;
 635     for(UShort_t pad=0;pad <= maxpad;pad++){
 636       if(digit>=row_pt->fNDigit || row_pt->fDigitData[digit].fPad !=  pad)
 637         continue;
 638       index++;
 639 //    write zero if time != 0
 640       if(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
 641         if(row_pt->fDigitData[digit].fTime>0){
 642           index++;
 643           index++;
 644         }
 645       }
 646       while(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
 647         index++;
 648         if(digit+1<row_pt->fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){
 649           if(row_pt->fDigitData[digit].fTime +1 !=
 650                      row_pt->fDigitData[digit+1].fTime){
 651             index++;
 652             index++;
 653           }
 654         }
 655         digit++;
 656       }
 657       index++;
 658       index++;
 659     }
 660
 661     Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
 662                                             sizeof(AliL3DigitRowData);
 663     Byte_t  *byte_pt =(Byte_t *) row_pt;
 664     byte_pt += size;
 665     row_pt = (AliL3DigitRowData *) byte_pt;
 666   }
 667   while(index%3)
 668     index++;
 669   return (index/3) * sizeof(UInt_t);
 670 }
 671
 672 UInt_t AliL3MemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp){
 673   if(!comp){
 674     LOG(AliL3Log::kWarning,"AliL3MemHandler::GetMemorySize","Memory")
 675     <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 676     return 0;
 677   }
 678   Int_t outsize=0;
 679
 680   UInt_t index=0;
 681   UInt_t subindex=0;
 682
 683   for(UInt_t i=0;i<nrow;i++){
 684     UInt_t ndigit=0;
 685     Read(comp,index,subindex);
 686     UShort_t npad = Read(comp,index,subindex);
 687     for(UShort_t p=0;p<npad;p++){
 688       Read(comp,index,subindex);
 689       if(Test(comp,index,subindex)==0){
 690         Read(comp,index,subindex);
 691         if(Read(comp,index,subindex)== 0) continue;
 692       }
 693       for(;;){
 694         while(Read(comp,index,subindex)!=0) ndigit++;
 695         if(Read(comp,index,subindex)==0) break;
 696       }
 697     }
 698     Int_t size = sizeof(AliL3DigitData) * ndigit+
 699                                         sizeof(AliL3DigitRowData);
 700     outsize += size;
 701   }
 702
 703   return outsize;
 704 }
 705
 706 UInt_t AliL3MemHandler::GetNRow(UInt_t *comp,UInt_t size){
 707   if(!comp){
 708     LOG(AliL3Log::kWarning,"AliL3MemHandler::GetNRow","Memory")
 709     <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 710     return 0;
 711   }
 712   size = size /4;
 713   UInt_t nrow=0;
 714   UInt_t index=0;
 715   UInt_t subindex=0;
 716   while(index+1<size){
 717     nrow++;
 718     UInt_t ndigit=0;
 719     Read(comp,index,subindex);
 720     UShort_t npad = Read(comp,index,subindex);
 721     for(UShort_t p=0;p<npad;p++){
 722       Read(comp,index,subindex);
 723       if(Test(comp,index,subindex)==0){
 724         Read(comp,index,subindex);
 725         if(Read(comp,index,subindex)==0)continue;
 726       }
 727       for(;;){
 728         while(Read(comp,index,subindex)!=0) ndigit++;
 729         if(Read(comp,index,subindex)==0) break;
 730       }
 731     }
 732   }
 733   if(index+1==size)
 734   if(subindex<2)
 735   if(Read(comp,index,subindex)!=0) nrow++;
 736
 737   return nrow;
 738 }
 739
 740 Bool_t AliL3MemHandler::CompMemory2CompBinary(UInt_t nrow,UInt_t *comp,
 741                                                                UInt_t size){
 742   if(!fOutBinary){
 743     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","File")
 744     <<"No Output File"<<ENDLOG;
 745     return kFALSE;
 746   }
 747   if(!comp){
 748     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","Memory")
 749     <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 750     return kFALSE;
 751   }
 752   if(size==0)
 753     size=GetMemorySize(nrow,comp);
 754   if(!size){
 755     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","Memory")
 756     <<"Memory size = 0 "<<ENDLOG;
 757     return kFALSE;
 758   }
 759   UInt_t length = size/sizeof(UInt_t);
 760   fwrite(&length,sizeof(UInt_t),1,fOutBinary);
 761   fwrite(comp,size,1,fOutBinary);
 762   return kTRUE;
 763 }
 764
 765 Bool_t AliL3MemHandler::CompBinary2CompMemory(UInt_t & nrow,UInt_t *comp){
 766   if(!fInBinary){
 767     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompBinary2CompMemory","File")
 768     <<"No Output File"<<ENDLOG;
 769     return kFALSE;
 770   }
 771   if(!comp){
 772     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompBinary2CompMemory","Memory")
 773     <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 774     return kFALSE;
 775   }
 776   rewind(fInBinary);
 777   UInt_t length;
 778   if(fread(&length,sizeof(UInt_t),1,fInBinary)!=1) return kFALSE;
 779   UInt_t size = length*sizeof(UInt_t);
 780   if(fread(comp,size,1,fInBinary)!=1) return kFALSE;
 781   // now find the number of dig
 782   nrow =  GetNRow(comp,size);
 783   return kTRUE;
 784 }
 785
 786 AliL3DigitRowData *AliL3MemHandler::CompBinary2Memory(UInt_t & nrow){
 787   AliL3MemHandler * handler = new AliL3MemHandler();
 788   handler->SetBinaryInput(fInBinary);
 789   UInt_t *comp =(UInt_t *)handler->Allocate();
 790   handler->CompBinary2CompMemory(nrow,comp);
 791   UInt_t size = GetMemorySize(nrow,comp);
 792   AliL3DigitRowData *data = (AliL3DigitRowData *)Allocate(size);
 793   CompMemory2Memory(nrow,data,comp);
 794   handler->Free();
 795   delete handler;
 796   return data;
 797 }
 798
 799 Bool_t AliL3MemHandler::Memory2CompBinary(UInt_t nrow,AliL3DigitRowData *data){
 800   Bool_t out = kTRUE;
 801   AliL3MemHandler * handler = new AliL3MemHandler();
 802   UInt_t size = GetCompMemorySize(nrow,data);
 803   UInt_t *comp =(UInt_t *)handler->Allocate(size);
 804   Memory2CompMemory(nrow,data,comp);
 805   CompMemory2CompBinary(nrow,comp,size);
 806   handler->Free();
 807   delete handler;
 808   return out;
 809 }
 810
 811
 812 ///////////////////////////////////////// Point IO
 813 Bool_t AliL3MemHandler::Memory2Binary(UInt_t npoint,AliL3SpacePointData *data){
 814   if(!fOutBinary){
 815     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
 816     <<"No Output File"<<ENDLOG;
 817     return kFALSE;
 818   }
 819   if(!data){
 820     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
 821     <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
 822     return kFALSE;
 823   }
 824   UInt_t size = npoint*sizeof(AliL3SpacePointData);
 825   fwrite(data,size,1,fOutBinary);
 826
 827   return kTRUE;
 828 }
 829
 830 Bool_t AliL3MemHandler::Transform(UInt_t npoint,AliL3SpacePointData *data,
 831                                  Int_t slice, AliL3Transform* trans){
 832   if(!data){
 833     LOG(AliL3Log::kWarning,"AliL3MemHandler::Transform","Memory")
 834     <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
 835     return kFALSE;
 836   }
 837   if(!trans){
 838     LOG(AliL3Log::kWarning,"AliL3MemHandler::Transform","Object")
 839     <<"Pointer to AliL3Transform = 0x0 "<<ENDLOG;
 840     return kFALSE;
 841   }
 842   for(UInt_t i=0;i<npoint;i++){
 843     Float_t xyz[3];
 844     xyz[0] = data[i].fX;
 845     xyz[1] = data[i].fY;
 846     xyz[2] = data[i].fZ;
 847     trans->Local2Global(xyz,slice);
 848     data[i].fX = xyz[0];
 849     data[i].fY = xyz[1];
 850     data[i].fZ = xyz[2];
 851   }
 852   return kTRUE;
 853 }
 854
 855 Bool_t AliL3MemHandler::Binary2Memory(UInt_t & npoint,AliL3SpacePointData *data){
 856   if(!fInBinary){
 857     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
 858     <<"No Input File"<<ENDLOG;
 859     return kFALSE;
 860   }
 861   if(!data){
 862     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
 863     <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
 864     return kFALSE;
 865   }
 866
 867   Int_t size = GetFileSize();
 868 /*
 869   UInt_t  size,slice,patch,row[2];
 870   AliL3EventDataTypeRoot datatype;
 871   UInt_t node;
 872   if(fread(&datatype,sizeof(AliL3EventDataTypeRoot),1,fInBinary)!=1){
 873     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 874     <<"File Read Error "<<ENDLOG;
 875     return kFALSE;
 876   }
 877   if(fread(&node,sizeof(UInt_t),1,fInBinary)!=1){
 878     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 879     <<"File Read Error "<<ENDLOG;
 880     return kFALSE;
 881   }
 882   if(fread(&size,sizeof(UInt_t),1,fInBinary)!=1){
 883     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 884     <<"File Read Error "<<ENDLOG;
 885     return kFALSE;
 886   }
 887   if(fread(&slice,sizeof(UInt_t),1,fInBinary)!=1){
 888     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 889     <<"File Read Error "<<ENDLOG;
 890     return kFALSE;
 891   }
 892   if(fread(&patch,sizeof(UInt_t),1,fInBinary)!=1){
 893     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 894     <<"File Read Error "<<ENDLOG;
 895     return kFALSE;
 896   }
 897   if(fread(row,2*sizeof(UInt_t),1,fInBinary)!=1){
 898     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 899     <<"File Read Error "<<ENDLOG;
 900     return kFALSE;
 901   }
 902 */
 903   npoint = size/sizeof(AliL3SpacePointData);
 904   if(fread(data,size,1,fInBinary)!=1){
 905     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 906     <<"File Read Error "<<ENDLOG;
 907     return kFALSE;
 908   }
 909   if(size%sizeof(AliL3SpacePointData)){
 910     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File Size")
 911     <<"File Size wrong "<<ENDLOG;
 912     return kFALSE;
 913   }
 914   LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","File")
 915   <<AliL3Log::kDec<<"Wrote  "<<size<<" Bytes to Memory"<<ENDLOG;
 916   return kTRUE;
 917 }
 918
 919 ///////////////////////////////////////// Track IO
 920 Bool_t AliL3MemHandler::Memory2Binary(UInt_t ntrack,AliL3TrackSegmentData *data){
 921   if(!fOutBinary){
 922     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
 923     <<"No Output File"<<ENDLOG;
 924     return kFALSE;
 925   }
 926   if(!data){
 927     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
 928     <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
 929     return kFALSE;
 930   }
 931   AliL3TrackSegmentData *track_pt = data;
 932   for(UInt_t i=0;i<ntrack;i++){
 933     Int_t size=sizeof(AliL3TrackSegmentData)+track_pt->fNPoints*sizeof(UInt_t);
 934     fwrite(track_pt,size,1,fOutBinary);
 935     Byte_t *byte_pt = (Byte_t*) track_pt;
 936     byte_pt += size;
 937     track_pt = (AliL3TrackSegmentData*) byte_pt;
 938   }
 939   LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","File")
 940   <<AliL3Log::kDec<<"Wrote  "<<ntrack<<" Tracks to File"<<ENDLOG;
 941
 942   return kTRUE;
 943 }
 944
 945 Bool_t AliL3MemHandler::Binary2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data){
 946   if(!fInBinary){
 947     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
 948     <<"No Input File"<<ENDLOG;
 949     return kFALSE;
 950   }
 951   if(!data){
 952     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
 953     <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
 954     return kFALSE;
 955   }
 956
 957   ntrack=0;
 958   AliL3TrackSegmentData *track_pt = data;
 959   rewind(fInBinary);
 960 /*
 961   UInt_t  size,slice,patch,row[2];
 962   AliL3EventDataTypeRoot datatype;
 963   UInt_t node;
 964   if(fread(&datatype,sizeof(AliL3EventDataTypeRoot),1,fInBinary)!=1){
 965     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 966     <<"File Read Error "<<ENDLOG;
 967     return kFALSE;
 968   }
 969   if(fread(&node,sizeof(UInt_t),1,fInBinary)!=1){
 970     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 971     <<"File Read Error "<<ENDLOG;
 972     return kFALSE;
 973   }
 974   if(fread(&size,sizeof(UInt_t),1,fInBinary)!=1){
 975     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 976     <<"File Read Error "<<ENDLOG;
 977     return kFALSE;
 978   }
 979   if(fread(&slice,sizeof(UInt_t),1,fInBinary)!=1){
 980     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 981     <<"File Read Error "<<ENDLOG;
 982     return kFALSE;
 983   }
 984   if(fread(&patch,sizeof(UInt_t),1,fInBinary)!=1){
 985     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 986     <<"File Read Error "<<ENDLOG;
 987     return kFALSE;
 988   }
 989   if(fread(row,2*sizeof(UInt_t),1,fInBinary)!=1){
 990     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
 991     <<"File Read Error "<<ENDLOG;
 992     return kFALSE;
 993   }
 994 */
 995   while(!feof(fInBinary)){
 996     if(fread(track_pt,sizeof(AliL3TrackSegmentData),1,fInBinary)!=1) break;
 997     Int_t size=track_pt->fNPoints*sizeof(UInt_t);
 998     if(fread(track_pt->fPointIDs,size,1,fInBinary)!=1) break;
 999     Byte_t *byte_pt = (Byte_t*) track_pt;
1000     byte_pt += sizeof(AliL3TrackSegmentData)+size;
1001     track_pt = (AliL3TrackSegmentData*) byte_pt;
1002     ntrack++;
1003   }
1004   LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","File")
1005   <<AliL3Log::kDec<<"Wrote  "<<ntrack<<" Tracks to Memory"<<ENDLOG;
1006   return kTRUE;
1007 }
1008
1009 Bool_t AliL3MemHandler::TrackArray2Binary(AliL3TrackArray *array){
1010   if(!fOutBinary){
1011     LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Binary","File")
1012     <<"No Output File"<<ENDLOG;
1013     return kFALSE;
1014   }
1015   if(!array){
1016     LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Binary","Memory")
1017     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1018     return kFALSE;
1019   }
1020   AliL3TrackSegmentData *data = (AliL3TrackSegmentData *)Allocate(array);
1021   UInt_t ntrack;
1022   TrackArray2Memory(ntrack,data,array);
1023   Memory2Binary(ntrack,data);
1024   Free();
1025   return kTRUE;
1026 }
1027
1028 Bool_t AliL3MemHandler::Binary2TrackArray(AliL3TrackArray *array){
1029   if(!fInBinary){
1030     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2TrackArray","File")
1031     <<"No Input File"<<ENDLOG;
1032     return kFALSE;
1033   }
1034   if(!array){
1035     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2TrackArray","Memory")
1036     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1037     return kFALSE;
1038   }
1039   AliL3TrackSegmentData *data = (AliL3TrackSegmentData *)Allocate();
1040   UInt_t ntrack;
1041   Binary2Memory(ntrack,data);
1042   Memory2TrackArray(ntrack,data,array);
1043   Free();
1044   return kTRUE;
1045 }
1046
1047 Bool_t AliL3MemHandler::TrackArray2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array){
1048   if(!data){
1049     LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Memory","Memory")
1050     <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1051     return kFALSE;
1052   }
1053   if(!array){
1054     LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Memory","Memory")
1055     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1056     return kFALSE;
1057   }
1058   array->WriteTracks(ntrack,data);
1059   return kTRUE;
1060 }
1061
1062 Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array){
1063   if(!data){
1064     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1065     <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1066     return kFALSE;
1067   }
1068   if(!array){
1069     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1070     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1071     return kFALSE;
1072   }
1073   array->FillTracks(ntrack,data);
1074   return kTRUE;
1075 }
1076
1077 Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array,Int_t slice, AliL3Transform* trans){
1078   if(!data){
1079     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1080     <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1081     return kFALSE;
1082   }
1083   if(!array){
1084     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1085     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1086     return kFALSE;
1087   }
1088   if(!trans){
1089     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Object")
1090     <<"Pointer to AliL3Transform = 0x0 "<<ENDLOG;
1091     return kFALSE;
1092   }
1093   array->FillTracks(ntrack,data,slice,trans);
1094   return kTRUE;
1095 }
1096