HLT/src/AliL3MemHandler.cxx

   1 /* $Id$
   2 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
   3 // -- Copyright &copy Uli
   4 // changes done by Constantin Loizides <mailto:loizides@ikf.physik.uni-frankfurt.de>
   5 */
   6
   7 #include <math.h>
   8 #include <time.h>
   9 #include <iostream.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12
  13 #include "AliL3MemHandler.h"
  14 #include "AliL3Transform.h"
  15 #include "AliL3Logging.h"
  16
  17 #include "AliL3DigitData.h"
  18 #include "AliL3TrackSegmentData.h"
  19 #include "AliL3SpacePointData.h"
  20 #include "AliL3TrackArray.h"
  21
  22 //_____________________________________________________________
  23 // AliL3MemHandler
  24 //
  25 // The L3 Binary File handler
  26 //
  27 //
  28 //  This class does all the memory I/O handling on raw binary files.
  29 //  For the moment the compressed binary files are run-length encoded, using
  30 //  10 bit digits.
  31 //
  32 //  Examples:
  33 //
  34 //  1) Reading a binary file:
  35 //
  36 //  AliL3MemHandler file;
  37 //  file.SetBinaryInput(filename);
  38 //
  39 //  UInt_t ndigits;
  40 //  AliL3DigitRowData *data = file.CompBinary2Memory(ndigits);
  41 //
  42 //  for(int i=0; i<NumberOfRowsInPatch; i++)
  43 //    {
  44 //
  45 //    AliL3DigitData *dataPt = (AliL3DigitData*)data->fDigitData;
  46 //    for(int j=0; j<data->fNDigit; j++)
  47 //      {
  48 //      pad = dataPt[j].fPad;
  49 //      time = dataPt[j].fTime;
  50 //      charge = dataPt[j].fCharge;
  51 //     }
  52 //
  53 //    file.UpdateRowPointer(data);
  54 //
  55 //    }
  56 //  file.CloseBinaryInput();
  57 //  ________________________
  58 //
  59 //  2) Writing a binary file:
  60 //
  61 //  //First of all you need to store the data in memory,
  62 //  //and have a pointer to it of type AliL3DigitRowData.
  63 //  //E.g. if you just want to write the data you read in example 1)
  64 //  //into a new file, you can do the following:
  65 //
  66 //  AliL3MemHandler newfile;
  67 //  newfile.SetBinaryOutput(newfilename);
  68 //  newfile.Memory2CompBinary((UInt_t)NumberOfRowsInPatch,(AliL3DigitRowData*)data);
  69 //  newfile.CloseBinaryOutput();
  70
  71 ClassImp(AliL3MemHandler)
  72
  73 AliL3MemHandler::AliL3MemHandler()
  74 {
  75   ///Constructor
  76
  77   fPt = 0;
  78   fSize =0;
  79   fInBinary = 0;
  80   fOutBinary = 0;
  81   fNRandom = 0;
  82   Int_t r[2]={0,0};
  83   Init(0,0,r);
  84   IsRandom = kFALSE;
  85   fDigits = 0;
  86   fDPt =0;
  87   fNGenerate = 0;
  88   fNUsed = 0;
  89   fNDigits = 0;
  90
  91   Int_t row[2] = {0,175};
  92   Init(0,0,row);
  93   ResetROI();
  94 }
  95
  96
  97 AliL3MemHandler::~AliL3MemHandler()
  98 {
  99   //Destructor
 100   if(fPt) delete[] fPt;
 101   if(fDigits) delete [] fDigits;
 102   if(fDPt) delete [] fDPt;
 103 }
 104
 105 void AliL3MemHandler::ResetROI()
 106 {
 107   //Resets the Look-up table for Region of Interest mode.
 108
 109   for(Int_t i=fRowMin; i<=fRowMax; i++)
 110     {
 111       fEtaMinTimeBin[i] = 0;
 112       fEtaMaxTimeBin[i] = 445;
 113     }
 114 }
 115
 116
 117 void AliL3MemHandler::SetROI(Float_t *eta,Int_t *slice)
 118 {
 119   // Init the Look-up table for the Region of Interest mode.
 120   //   Here you can specify a certain etaregion, - all data
 121   //   outside this region will be discarded:
 122   //   eta[0] = mimium eta
 123   //   eta[1] = maximum eta
 124   //   slice[0] = mimumum slice
 125   //   slice[1] = maximum slice
 126
 127   if(eta[1]==0)
 128     {
 129       LOG(AliL3Log::kWarning,"AliL3MemHandler::SetROI","Eta Values")
 130         <<"Bad ROI parameters. IDIOT! "<<ENDLOG;
 131       for(Int_t i=fRowMin; i<=fRowMax; i++)
 132         {
 133           fEtaMinTimeBin[i]=0;
 134           fEtaMaxTimeBin[i]=0;
 135         }
 136       return;
 137     }
 138
 139   for(Int_t i=fRowMin; i<=fRowMax; i++)
 140     {
 141       Int_t sector,row;
 142       Float_t xyz[3];
 143
 144       Float_t thetamax = 2*atan(exp(-1.*eta[1]));
 145
 146       xyz[0] = fTransformer->Row2X(i);
 147       xyz[1]=0;
 148       xyz[2] = xyz[0]/tan(thetamax);
 149       fTransformer->Slice2Sector(fSlice,i,sector,row);
 150       fTransformer->Local2Raw(xyz,sector,row);
 151
 152       fEtaMinTimeBin[i] = (Int_t)xyz[2];
 153
 154       if(eta[0]==0)
 155         fEtaMaxTimeBin[i] = 445;
 156       else
 157         {
 158           Float_t thetamin = 2*atan(exp(-1.*eta[0]));
 159           xyz[0] = fTransformer->Row2X(i);
 160           xyz[1] = fTransformer->GetMaxY(i);
 161           Float_t radii = sqrt(pow(xyz[0],2) + pow(xyz[1],2));
 162           xyz[2] = radii/tan(thetamin);
 163           fTransformer->Local2Raw(xyz,sector,row);
 164           fEtaMaxTimeBin[i] = (Int_t)xyz[2];
 165         }
 166     }
 167
 168 }
 169
 170 Bool_t AliL3MemHandler::SetBinaryInput(char *name)
 171 {
 172   //Set the input binary file.
 173
 174   fInBinary = fopen(name,"r");
 175   if(!fInBinary){
 176     LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open")
 177       <<"Error opening file "<<name<<ENDLOG;
 178     return kFALSE;
 179   }
 180   return kTRUE;
 181 }
 182
 183 Bool_t AliL3MemHandler::SetBinaryInput(FILE *file)
 184 {
 185   //Set the input binary file.
 186
 187   fInBinary = file;
 188   if(!fInBinary){
 189     LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open")
 190     <<"Pointer to File = 0x0 "<<ENDLOG;
 191     return kFALSE;
 192   }
 193   return kTRUE;
 194 }
 195
 196 void AliL3MemHandler::CloseBinaryInput()
 197 {
 198   //Close the input file.
 199
 200   if(!fInBinary){
 201     LOG(AliL3Log::kWarning,"AliL3MemHandler::CloseBinaryInput","File Close")
 202       <<"Nothing to Close"<<ENDLOG;
 203     return;
 204   }
 205   fclose(fInBinary);
 206   fInBinary =0;
 207 }
 208
 209 Bool_t AliL3MemHandler::SetBinaryOutput(char *name)
 210 {
 211   //Set the binary output file.
 212   fOutBinary = fopen(name,"w");
 213   if(!fOutBinary){
 214     LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryOutput","File Open")
 215       <<"Pointer to File = 0x0 "<<ENDLOG;
 216     return kFALSE;
 217   }
 218   return kTRUE;
 219 }
 220
 221 Bool_t AliL3MemHandler::SetBinaryOutput(FILE *file)
 222 {
 223   //Set the binary output file.
 224
 225   fOutBinary = file;
 226   if(!fOutBinary){
 227     LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryOutput","File Open")
 228       <<"Pointer to File = 0x0 "<<ENDLOG;
 229     return kFALSE;
 230   }
 231   return kTRUE;
 232 }
 233
 234 void AliL3MemHandler::CloseBinaryOutput()
 235 {
 236   if(!fOutBinary){
 237     LOG(AliL3Log::kWarning,"AliL3MemHandler::CloseBinaryOutPut","File Close")
 238       <<"Nothing to Close"<<ENDLOG;
 239     return;
 240   }
 241   fclose(fOutBinary);
 242   fOutBinary =0;
 243 }
 244
 245
 246 UInt_t AliL3MemHandler::GetFileSize()
 247 {
 248   //Returns the file size in bytes of the input file.
 249
 250   if(!fInBinary){
 251     LOG(AliL3Log::kWarning,"AliL3MemHandler::GetFileSize","File")
 252       <<"No Input File"<<ENDLOG;
 253     return 0;
 254   }
 255   fseek(fInBinary,0,SEEK_END);
 256   UInt_t size = (UInt_t) ftell(fInBinary);
 257   rewind(fInBinary);
 258   return size;
 259 }
 260
 261 Byte_t *AliL3MemHandler::Allocate()
 262 {
 263   return Allocate(GetFileSize());
 264 }
 265
 266 Byte_t *AliL3MemHandler::Allocate(AliL3TrackArray *array)
 267 {
 268   //Allocate memory for tracks in memory. Used by TrackArray2Binary()
 269
 270   if(!array){
 271     LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory")
 272       <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
 273     return 0;
 274   }
 275   return Allocate(array->GetOutSize());
 276 }
 277
 278 Byte_t *AliL3MemHandler::Allocate(UInt_t size)
 279 {
 280   //Allocate memory of size in bytes.
 281
 282   if(fPt){
 283     LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory")
 284       <<"Delete Memory"<<ENDLOG;
 285     Free();
 286   }
 287   fPt = new Byte_t[size];
 288   fSize = size;
 289   memset(fPt,0,fSize);
 290   LOG(AliL3Log::kDebug,"AliL3MemHandler::Allocate","Memory")
 291   <<AliL3Log::kDec<<"Allocate "<<size<<" Bytes of Memory"<<ENDLOG;
 292   return fPt;
 293 }
 294
 295 void AliL3MemHandler::Free()
 296 {
 297   //Clear the memory, if allocated.
 298
 299   if(!fPt){
 300     LOG(AliL3Log::kWarning,"AliL3MemHandler::Free","Memory")
 301       <<"No Memory allocated - can't Free"<<ENDLOG;
 302     return;
 303   }
 304   delete[] fPt;
 305   fPt = 0;
 306   fSize =0;
 307 }
 308
 309 ///////////////////////////////////////// Random
 310 void AliL3MemHandler::SetRandomSeed()
 311 {
 312   //If you are adding random data to the original data.
 313   time_t *tp=0;
 314   SetRandomSeed(time(tp));
 315 }
 316
 317 void AliL3MemHandler::SetRandomCluster(Int_t maxnumber)
 318 {
 319   //If you are adding random data to the original data.
 320
 321   IsRandom = kTRUE;
 322   fNRandom = maxnumber;
 323   fNDigits = 0;
 324   if(fDigits) delete [] fDigits;
 325   fDigits = new AliL3RandomDigitData[fNRandom*9];
 326   if(fDPt) delete [] fDPt;
 327   fDPt = new AliL3RandomDigitData *[fNRandom*9];
 328 }
 329
 330 void AliL3MemHandler::QSort(AliL3RandomDigitData **a, Int_t first, Int_t last){
 331
 332    // Sort array of AliL3RandomDigitData pointers using a quicksort algorithm.
 333    // Uses CompareDigits() to compare objects.
 334    // Thanks to Root!
 335
 336    static AliL3RandomDigitData *tmp;
 337    static int i;           // "static" to save stack space
 338    int j;
 339
 340    while (last - first > 1) {
 341       i = first;
 342       j = last;
 343       for (;;) {
 344          while (++i < last && CompareDigits(a[i], a[first]) < 0)
 345             ;
 346          while (--j > first && CompareDigits(a[j], a[first]) > 0)
 347             ;
 348          if (i >= j)
 349             break;
 350
 351          tmp  = a[i];
 352          a[i] = a[j];
 353          a[j] = tmp;
 354       }
 355       if (j == first) {
 356          ++first;
 357          continue;
 358       }
 359       tmp = a[first];
 360       a[first] = a[j];
 361       a[j] = tmp;
 362
 363       if (j - first < last - (j + 1)) {
 364         QSort(a, first, j);
 365         first = j + 1;   // QSort(j + 1, last);
 366       } else {
 367         QSort(a, j + 1, last);
 368         last = j;        // QSort(first, j);
 369       }
 370    }
 371 }
 372
 373 UInt_t AliL3MemHandler::GetRandomSize()
 374 {
 375   Int_t nrandom = 0;
 376   for(Int_t r=fRowMin;r<=fRowMax;r++){
 377     Int_t npad=fTransformer->GetNPads(r);
 378     nrandom  += Int_t (fNGenerate * ((Double_t) npad/141.));
 379   }
 380   return 9 * nrandom * sizeof(AliL3DigitData);
 381 }
 382
 383 void AliL3MemHandler::Generate(Int_t row)
 384 {
 385   //Generate random data on row, if you didn't ask for this, nothing happens here.
 386
 387   if(!IsRandom) return;
 388   ResetRandom();
 389   fNDigits = 0;
 390   Int_t npad=fTransformer->GetNPads(row);
 391   Int_t ntime = fEtaMaxTimeBin[row] - fEtaMinTimeBin[row];
 392   Int_t nrandom  = Int_t (fNGenerate * ((Double_t) npad/141.) *
 393                           (Double_t) ntime/(Double_t) fTransformer->GetNTimeBins() );
 394
 395   for(Int_t n=0;n<nrandom;n++){
 396     Int_t pad = (int)((float)rand()/RAND_MAX*npad);
 397     Int_t time =(int)((float)rand()/RAND_MAX*ntime+fEtaMinTimeBin[row] );
 398     Int_t charge = (int)((float)rand()/RAND_MAX*1023);
 399     DigitizePoint(row,pad,time,charge);
 400   }
 401   QSort(fDPt,0,fNDigits);
 402   //  for(Int_t d=0;d<fNDigits;d++)
 403   //    fprintf(stderr,"%d %d %d %d\n",fDPt[d]->fRow,fDPt[d]->fPad,
 404   //                             fDPt[d]->fTime,fDPt[d]->fCharge);
 405 }
 406
 407
 408 void AliL3MemHandler::DigitizePoint(Int_t row, Int_t pad,
 409                                     Int_t time,Int_t charge)
 410 {
 411   //Making one single random cluster.
 412   for(Int_t j=-1;j<2;j++){
 413     for(Int_t k=-1;k<2;k++){
 414       Int_t dcharge = charge;
 415       if(j) dcharge /=2;
 416       if(k) dcharge /=2;
 417       if(dcharge<10) continue;
 418       Int_t dpad  = j + pad;
 419       Int_t dtime = k + time;
 420
 421       if(dpad<0||dpad>=fTransformer->GetNPads(row))  continue;
 422       if(dtime<0||dtime>=fTransformer->GetNTimeBins()) continue;
 423
 424       fDigits[fNDigits].fCharge = dcharge;
 425       fDigits[fNDigits].fRow = row;
 426       fDigits[fNDigits].fPad = dpad;
 427       fDigits[fNDigits].fTime = dtime;
 428       fDPt[fNDigits] = &fDigits[fNDigits];
 429       fNDigits++;
 430     }
 431   }
 432 }
 433
 434 ///////////////////////////////////////// Digit IO
 435 Bool_t AliL3MemHandler::Memory2Binary(UInt_t nrow,AliL3DigitRowData *data)
 436 {
 437   //Write data to the outputfile as is. No run-length encoding is done.
 438
 439   if(!fOutBinary){
 440     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
 441       <<"No Output File"<<ENDLOG;
 442     return kFALSE;
 443   }
 444   if(!data){
 445     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
 446       <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
 447     return kFALSE;
 448   }
 449
 450   AliL3DigitRowData *row_pt = data;
 451   Int_t outsize = 0;
 452   for(UInt_t i=0;i<nrow;i++){
 453     Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit
 454       + sizeof(AliL3DigitRowData);
 455     outsize += size;
 456     fwrite(row_pt,size,1,fOutBinary);
 457     Byte_t  *byte_pt =(Byte_t *) row_pt;
 458     byte_pt += size;
 459     row_pt = (AliL3DigitRowData *) byte_pt;
 460   }
 461   LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","Memory")
 462     <<AliL3Log::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
 463     <<nrow<<" Rows)"<<ENDLOG;
 464   return kTRUE;
 465 }
 466
 467 Bool_t AliL3MemHandler::Binary2Memory(UInt_t & nrow,AliL3DigitRowData *data)
 468 {
 469   //Read inputfile into memory as is, and store it in data. No run-length encoding
 470   // is assumed.
 471
 472   if(!fInBinary){
 473     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
 474       <<"No Input File"<<ENDLOG;
 475     return kFALSE;
 476   }
 477   if(!data){
 478     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
 479       <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
 480     return kFALSE;
 481   }
 482   rewind(fInBinary);
 483   AliL3DigitRowData *row_pt = data;
 484   UInt_t rowcount = 0;
 485   Int_t outsize =0;
 486   while(!feof(fInBinary)){
 487     Byte_t  *byte_pt =(Byte_t *) row_pt;
 488
 489     if(fread(row_pt,sizeof(AliL3DigitRowData),1,fInBinary)!=1) break;
 490     byte_pt += sizeof(AliL3DigitRowData);
 491     outsize += sizeof(AliL3DigitRowData);
 492
 493     Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit;
 494
 495     if(fread(byte_pt,size,1,fInBinary)!=1) break;
 496     byte_pt += size;
 497     outsize += size;
 498
 499     row_pt = (AliL3DigitRowData *) byte_pt;
 500     rowcount++;
 501   }
 502   nrow= rowcount;
 503     LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","Memory")
 504     <<AliL3Log::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
 505     <<rowcount<<" Rows)"<<ENDLOG;
 506   return kTRUE;
 507 }
 508
 509 void AliL3MemHandler::AddData(AliL3DigitData *data,UInt_t & ndata,
 510                               UInt_t row,UShort_t pad,UShort_t time,UShort_t charge)
 511 {
 512   data[ndata].fPad = pad;
 513   data[ndata].fTime = time;
 514   data[ndata].fCharge = charge;
 515   ndata++;
 516 }
 517
 518 void AliL3MemHandler::AddRandom(AliL3DigitData *data, UInt_t & ndata)
 519 {
 520   data[ndata].fPad = fDPt[fNUsed]->fPad;
 521   data[ndata].fTime = fDPt[fNUsed]->fTime;
 522   data[ndata].fCharge = fDPt[fNUsed]->fCharge;
 523   ndata++;
 524   fNUsed++;
 525 }
 526
 527 void AliL3MemHandler::MergeDataRandom(AliL3DigitData *data, UInt_t & ndata,
 528                                       UInt_t row, UShort_t pad, UShort_t time, UShort_t charge)
 529 {
 530   data[ndata].fPad = pad;
 531   data[ndata].fTime = time;
 532   data[ndata].fCharge = charge;
 533   while(ComparePoints(row,pad,time)==0){
 534     Int_t ch = data[ndata].fCharge + fDPt[fNUsed]->fCharge;
 535     if(charge>1023) ch = 1023;
 536     data[ndata].fCharge = ch;
 537     fNUsed++;
 538   }
 539   ndata++;
 540 }
 541
 542 void AliL3MemHandler::AddDataRandom(AliL3DigitData *data, UInt_t & ndata,
 543                    UInt_t row, UShort_t pad, UShort_t time, UShort_t charge)
 544 {
 545   Int_t action;
 546   while((action=ComparePoints(row,pad,time))==1){
 547     AddRandom(data,ndata);
 548   }
 549   if(action==0){
 550     MergeDataRandom(data,ndata,row,pad,time,charge);
 551   }
 552   if(action<0){
 553     AddData(data,ndata,row,pad,time,charge);
 554   }
 555 }
 556
 557 void AliL3MemHandler::Write(UInt_t *comp, UInt_t & index,
 558                             UInt_t & subindex, UShort_t value)
 559 {
 560   UInt_t shift[3] = {0,10,20};
 561   if(subindex==0) comp[index] =0; //clean up memory
 562   comp[index] |= (value&0x03ff)<<shift[subindex];
 563   if(subindex == 2){
 564     subindex = 0;
 565     index++;
 566   }
 567   else subindex++;
 568 }
 569
 570 UShort_t AliL3MemHandler::Read(UInt_t *comp, UInt_t & index, UInt_t & subindex)
 571 {
 572   UInt_t shift[3] = {0,10,20};
 573   UShort_t value = (comp[index]>>shift[subindex])&0x03ff;
 574   if(subindex == 2){
 575     subindex = 0;
 576     index++;
 577   }
 578   else subindex++;
 579
 580   return value;
 581 }
 582
 583 UShort_t AliL3MemHandler::Test(UInt_t *comp,
 584                                UInt_t index, UInt_t  subindex)
 585 {
 586   UInt_t shift[3] = {0,10,20};
 587   return (comp[index]>>shift[subindex])&0x03ff;
 588 }
 589
 590 Int_t AliL3MemHandler::Memory2CompMemory(UInt_t nrow,
 591                                          AliL3DigitRowData *data,UInt_t *comp)
 592 {
 593   //Performs run-length encoding on data stored in memory pointed to by data.
 594   //The compressed data is written to comp.
 595   if(!comp){
 596     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2CompMemory","Memory")
 597       <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 598     return 0;
 599   }
 600   if(!data){
 601     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2CompMemory","Memory")
 602       <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
 603     return 0;
 604   }
 605   AliL3DigitRowData *row_pt = data;
 606   UInt_t index=0;
 607   UInt_t subindex=0;
 608
 609   for(UInt_t i=0;i<nrow;i++){
 610     UShort_t value = row_pt->fRow;
 611     Write(comp,index,subindex,value);
 612     UShort_t maxpad=0;
 613     UShort_t npad=0;
 614     Int_t ddd[1000];
 615     for(Int_t d=0;d<200;d++) ddd[d]=0;
 616     for(UInt_t dig=0;dig<row_pt->fNDigit;dig++){
 617       if(row_pt->fDigitData[dig].fPad <200){
 618         ddd[row_pt->fDigitData[dig].fPad]++;
 619       }
 620     }
 621     for(Int_t d=0;d<200;d++){
 622       if(ddd[d]){
 623         npad++;
 624         maxpad =d;
 625       }
 626     }
 627     Write(comp,index,subindex,npad);
 628     UInt_t digit=0;
 629     for(UShort_t pad=0;pad <= maxpad;pad++){
 630       if(digit>=row_pt->fNDigit || row_pt->fDigitData[digit].fPad !=  pad)
 631         continue;
 632       Write(comp,index,subindex,pad);
 633 //    write zero if time != 0
 634       if(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
 635         if(row_pt->fDigitData[digit].fTime>0){
 636           Write(comp,index,subindex,0);
 637           Write(comp,index,subindex,row_pt->fDigitData[digit].fTime);
 638         }
 639       }
 640       while(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
 641         UShort_t charge = row_pt->fDigitData[digit].fCharge;
 642         if(charge>=1024){
 643           charge=1023;
 644         }
 645         Write(comp,index,subindex,charge);
 646         if(digit+1<row_pt->fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){
 647           if(row_pt->fDigitData[digit].fTime +1 !=
 648                      row_pt->fDigitData[digit+1].fTime){
 649             Write(comp,index,subindex,0);
 650             UShort_t nzero = row_pt->fDigitData[digit+1].fTime -
 651                              (row_pt->fDigitData[digit].fTime +1);
 652             Write(comp,index,subindex,nzero);
 653           }
 654         }
 655         digit++;
 656       }
 657       Write(comp,index,subindex,0);
 658       Write(comp,index,subindex,0);
 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(subindex)
 668     Write(comp,index,subindex,0);
 669   return index * sizeof(UInt_t);
 670 }
 671
 672 Int_t AliL3MemHandler::CompMemory2Memory(UInt_t  nrow,
 673                                          AliL3DigitRowData *data,UInt_t *comp)
 674 {
 675   //Uncompress the run-length encoded data in memory pointed to by comp, and
 676   //  store it in data.
 677
 678   if(!comp){
 679     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2Memory","Memory")
 680       <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 681     return 0;
 682   }
 683   if(!data){
 684     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2Memory","Memory")
 685       <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
 686     return 0;
 687   }
 688   Int_t outsize=0;
 689
 690   AliL3DigitRowData *row_pt = data;
 691   UInt_t index=0;
 692   UInt_t subindex=0;
 693
 694   for(UInt_t i=0;i<nrow;i++){
 695     UInt_t ndigit=0;
 696     UInt_t row =Read(comp,index,subindex);
 697     row_pt->fRow=row;
 698     Generate(row);
 699     UShort_t npad = Read(comp,index,subindex);
 700     for(UShort_t p=0;p<npad;p++){
 701       UShort_t charge;
 702       UShort_t time =0;
 703       UShort_t pad = Read(comp,index,subindex);
 704       if(Test(comp,index,subindex)==0){
 705         Read(comp,index,subindex);
 706         if( (time = Read(comp,index,subindex)) == 0 ){
 707           continue;
 708         }
 709       }
 710       for(;;){
 711         while( (charge=Read(comp,index,subindex)) != 0){
 712           if(time>=fEtaMinTimeBin[row]&&time<=fEtaMaxTimeBin[row])
 713             //          AddData(row_pt->fDigitData,ndigit,row,pad,time,charge);
 714             AddDataRandom(row_pt->fDigitData,ndigit,row,pad,time,charge);
 715           time++;
 716         }
 717         UShort_t tshift = Read(comp,index,subindex);
 718         if(tshift ==0) break;
 719         time += tshift;
 720       }
 721     }
 722     row_pt->fNDigit = ndigit;
 723     Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
 724       sizeof(AliL3DigitRowData);
 725     Byte_t  *byte_pt =(Byte_t *) row_pt;
 726     byte_pt += size;
 727     outsize += size;
 728     row_pt = (AliL3DigitRowData *) byte_pt;
 729   }
 730   return outsize;
 731 }
 732
 733 UInt_t AliL3MemHandler::GetCompMemorySize(UInt_t nrow,AliL3DigitRowData *data)
 734 {
 735   //Return the size of RLE data, after compressing data.
 736
 737   if(!data){
 738     LOG(AliL3Log::kWarning,"AliL3MemHandler::GetCompMemorySize","Memory")
 739       <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
 740     return 0;
 741   }
 742   AliL3DigitRowData *row_pt = data;
 743   UInt_t index=0;
 744
 745   for(UInt_t i=0;i<nrow;i++){
 746     index++;
 747     UShort_t maxpad=0;
 748     UShort_t npad=0;
 749     Int_t ddd[1000];
 750     for(Int_t d=0;d<200;d++) ddd[d]=0;
 751     for(UInt_t dig=0;dig<row_pt->fNDigit;dig++){
 752       if(row_pt->fDigitData[dig].fPad <200){
 753         ddd[row_pt->fDigitData[dig].fPad]++;
 754       }
 755     }
 756     for(Int_t d=0;d<200;d++){
 757       if(ddd[d]){
 758         npad++;
 759         maxpad =d;
 760       }
 761     }
 762     index++;
 763     UInt_t digit=0;
 764     for(UShort_t pad=0;pad <= maxpad;pad++){
 765       if(digit>=row_pt->fNDigit || row_pt->fDigitData[digit].fPad !=  pad)
 766         continue;
 767       index++;
 768       //    write zero if time != 0
 769       if(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
 770         if(row_pt->fDigitData[digit].fTime>0){
 771           index++;
 772           index++;
 773         }
 774       }
 775       while(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
 776         index++;
 777         if(digit+1<row_pt->fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){
 778           if(row_pt->fDigitData[digit].fTime +1 !=
 779                      row_pt->fDigitData[digit+1].fTime){
 780             index++;
 781             index++;
 782           }
 783         }
 784         digit++;
 785       }
 786       index++;
 787       index++;
 788     }
 789
 790     Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
 791                                             sizeof(AliL3DigitRowData);
 792     Byte_t  *byte_pt =(Byte_t *) row_pt;
 793     byte_pt += size;
 794     row_pt = (AliL3DigitRowData *) byte_pt;
 795   }
 796   while(index%3)
 797     index++;
 798   return (index/3) * sizeof(UInt_t);
 799 }
 800
 801 UInt_t AliL3MemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp){
 802   if(!comp){
 803     LOG(AliL3Log::kWarning,"AliL3MemHandler::GetMemorySize","Memory")
 804     <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 805     return 0;
 806   }
 807   Int_t outsize=0;
 808
 809   UInt_t index=0;
 810   UInt_t subindex=0;
 811
 812   for(UInt_t i=0;i<nrow;i++){
 813     UInt_t ndigit=0;
 814     Read(comp,index,subindex);
 815     UShort_t npad = Read(comp,index,subindex);
 816     for(UShort_t p=0;p<npad;p++){
 817       Read(comp,index,subindex);
 818       if(Test(comp,index,subindex)==0){
 819         Read(comp,index,subindex);
 820         if(Read(comp,index,subindex)== 0) continue;
 821       }
 822       for(;;){
 823         while(Read(comp,index,subindex)!=0) ndigit++;
 824         if(Read(comp,index,subindex)==0) break;
 825       }
 826     }
 827     Int_t size = sizeof(AliL3DigitData) * ndigit+
 828                                         sizeof(AliL3DigitRowData);
 829     outsize += size;
 830   }
 831
 832   return outsize;
 833 }
 834
 835 UInt_t AliL3MemHandler::GetNRow(UInt_t *comp,UInt_t size)
 836 {
 837   if(!comp){
 838     LOG(AliL3Log::kWarning,"AliL3MemHandler::GetNRow","Memory")
 839       <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 840     return 0;
 841   }
 842   size = size /4;
 843   UInt_t nrow=0;
 844   UInt_t index=0;
 845   UInt_t subindex=0;
 846   while(index<size-1){ //don't start with last word
 847     nrow++;
 848     UInt_t ndigit=0;
 849     Read(comp,index,subindex);
 850     UShort_t npad = Read(comp,index,subindex);
 851     for(UShort_t p=0;p<npad;p++){
 852       Read(comp,index,subindex);
 853       if(Test(comp,index,subindex)==0){
 854         Read(comp,index,subindex);
 855         if(Read(comp,index,subindex)==0)continue;
 856       }
 857       for(;;){
 858         while(Read(comp,index,subindex)!=0) ndigit++;
 859         if(Read(comp,index,subindex)==0) break;
 860       }
 861     }
 862   }
 863   if(index==size-1){  //last word
 864     if(subindex<2){
 865       if(Read(comp,index,subindex)!=0) nrow++;
 866     }
 867   }
 868   return nrow;
 869 }
 870
 871 Bool_t AliL3MemHandler::CompMemory2CompBinary(UInt_t nrow,UInt_t *comp,
 872                                               UInt_t size)
 873 {
 874   //Write the RLE data in comp to the output file.
 875
 876   if(!fOutBinary){
 877     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","File")
 878     <<"No Output File"<<ENDLOG;
 879     return kFALSE;
 880   }
 881   if(!comp){
 882     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","Memory")
 883     <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 884     return kFALSE;
 885   }
 886   if(size==0)
 887     size=GetMemorySize(nrow,comp);
 888   if(!size){
 889     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","Memory")
 890     <<"Memory size = 0 "<<ENDLOG;
 891     return kFALSE;
 892   }
 893   UInt_t length = size/sizeof(UInt_t);
 894   fwrite(&length,sizeof(UInt_t),1,fOutBinary);
 895   fwrite(comp,size,1,fOutBinary);
 896   return kTRUE;
 897 }
 898
 899 Bool_t AliL3MemHandler::CompBinary2CompMemory(UInt_t & nrow,UInt_t *comp)
 900 {
 901   //Read the RLE data from file, and store it in comp. No unpacking yet.
 902
 903   if(!fInBinary){
 904     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompBinary2CompMemory","File")
 905       <<"No Output File"<<ENDLOG;
 906     return kFALSE;
 907   }
 908   if(!comp){
 909     LOG(AliL3Log::kWarning,"AliL3MemHandler::CompBinary2CompMemory","Memory")
 910       <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 911     return kFALSE;
 912   }
 913   rewind(fInBinary);
 914   UInt_t length;
 915   if(fread(&length,sizeof(UInt_t),1,fInBinary)!=1) return kFALSE;
 916   UInt_t size = length*sizeof(UInt_t);
 917   if(fread(comp,size,1,fInBinary)!=1) return kFALSE;
 918   // now find the number of dig
 919   nrow =  GetNRow(comp,size);
 920   return kTRUE;
 921 }
 922
 923 AliL3DigitRowData *AliL3MemHandler::CompBinary2Memory(UInt_t & nrow)
 924 {
 925   // Read the RLE inputfile, unpack it and return the pointer to it.
 926
 927   AliL3MemHandler * handler = new AliL3MemHandler();
 928   handler->SetBinaryInput(fInBinary);
 929   UInt_t *comp =(UInt_t *)handler->Allocate();
 930   handler->CompBinary2CompMemory(nrow,comp);
 931   UInt_t size = GetMemorySize(nrow,comp);
 932   AliL3DigitRowData *data = (AliL3DigitRowData *)Allocate(size);
 933   CompMemory2Memory(nrow,data,comp);
 934   handler->Free();
 935   delete handler;
 936   return data;
 937 }
 938
 939 Bool_t AliL3MemHandler::Memory2CompBinary(UInt_t nrow,AliL3DigitRowData *data)
 940 {
 941   //Perform RLE on the data, and write it to the output file.
 942   Bool_t out = kTRUE;
 943   AliL3MemHandler * handler = new AliL3MemHandler();
 944   UInt_t size = GetCompMemorySize(nrow,data);
 945   UInt_t *comp =(UInt_t *)handler->Allocate(size);
 946   Memory2CompMemory(nrow,data,comp);
 947   CompMemory2CompBinary(nrow,comp,size);
 948   handler->Free();
 949   delete handler;
 950   return out;
 951 }
 952
 953
 954 ///////////////////////////////////////// Point IO
 955 Bool_t AliL3MemHandler::Memory2Binary(UInt_t npoint,AliL3SpacePointData *data)
 956 {
 957   //Writing spacepoints stored in data to the outputfile.
 958   if(!fOutBinary){
 959     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
 960       <<"No Output File"<<ENDLOG;
 961     return kFALSE;
 962   }
 963   if(!data){
 964     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
 965       <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
 966     return kFALSE;
 967   }
 968   UInt_t size = npoint*sizeof(AliL3SpacePointData);
 969   fwrite(data,size,1,fOutBinary);
 970
 971   return kTRUE;
 972 }
 973
 974 Bool_t AliL3MemHandler::Transform(UInt_t npoint,AliL3SpacePointData *data,
 975                                   Int_t slice, AliL3Transform* trans)
 976 {
 977   //Transform the space points in data, to global coordinates in slice.
 978   if(!data){
 979     LOG(AliL3Log::kWarning,"AliL3MemHandler::Transform","Memory")
 980     <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
 981     return kFALSE;
 982   }
 983   if(!trans){
 984     LOG(AliL3Log::kWarning,"AliL3MemHandler::Transform","Object")
 985     <<"Pointer to AliL3Transform = 0x0 "<<ENDLOG;
 986     return kFALSE;
 987   }
 988   for(UInt_t i=0;i<npoint;i++){
 989     Float_t xyz[3];
 990     xyz[0] = data[i].fX;
 991     xyz[1] = data[i].fY;
 992     xyz[2] = data[i].fZ;
 993     trans->Local2Global(xyz,slice);
 994     data[i].fX = xyz[0];
 995     data[i].fY = xyz[1];
 996     data[i].fZ = xyz[2];
 997   }
 998   return kTRUE;
 999 }
1000
1001 Bool_t AliL3MemHandler::Binary2Memory(UInt_t & npoint,AliL3SpacePointData *data)
1002 {
1003   //Read the space points in inputfile, and store it in data.
1004   if(!fInBinary){
1005     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
1006     <<"No Input File"<<ENDLOG;
1007     return kFALSE;
1008   }
1009   if(!data){
1010     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
1011     <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
1012     return kFALSE;
1013   }
1014
1015   Int_t size = GetFileSize();
1016 /*
1017   UInt_t  size,slice,patch,row[2];
1018   AliL3EventDataTypeRoot datatype;
1019   UInt_t node;
1020   if(fread(&datatype,sizeof(AliL3EventDataTypeRoot),1,fInBinary)!=1){
1021     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1022     <<"File Read Error "<<ENDLOG;
1023     return kFALSE;
1024   }
1025   if(fread(&node,sizeof(UInt_t),1,fInBinary)!=1){
1026     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1027     <<"File Read Error "<<ENDLOG;
1028     return kFALSE;
1029   }
1030   if(fread(&size,sizeof(UInt_t),1,fInBinary)!=1){
1031     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1032     <<"File Read Error "<<ENDLOG;
1033     return kFALSE;
1034   }
1035   if(fread(&slice,sizeof(UInt_t),1,fInBinary)!=1){
1036     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1037     <<"File Read Error "<<ENDLOG;
1038     return kFALSE;
1039   }
1040   if(fread(&patch,sizeof(UInt_t),1,fInBinary)!=1){
1041     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1042     <<"File Read Error "<<ENDLOG;
1043     return kFALSE;
1044   }
1045   if(fread(row,2*sizeof(UInt_t),1,fInBinary)!=1){
1046     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1047     <<"File Read Error "<<ENDLOG;
1048     return kFALSE;
1049   }
1050 */
1051   npoint = size/sizeof(AliL3SpacePointData);
1052   if(fread(data,size,1,fInBinary)!=1){
1053     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1054     <<"File Read Error "<<ENDLOG;
1055     return kFALSE;
1056   }
1057   if(size%sizeof(AliL3SpacePointData)){
1058     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File Size")
1059     <<"File Size wrong "<<ENDLOG;
1060     return kFALSE;
1061   }
1062   LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","File")
1063   <<AliL3Log::kDec<<"Wrote  "<<size<<" Bytes to Memory"<<ENDLOG;
1064   return kTRUE;
1065 }
1066
1067 ///////////////////////////////////////// Track IO
1068 Bool_t AliL3MemHandler::Memory2Binary(UInt_t ntrack,AliL3TrackSegmentData *data)
1069 {
1070   //Write the tracks stored in data, to outputfile.
1071   if(!fOutBinary){
1072     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
1073     <<"No Output File"<<ENDLOG;
1074     return kFALSE;
1075   }
1076   if(!data){
1077     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
1078     <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1079     return kFALSE;
1080   }
1081   AliL3TrackSegmentData *track_pt = data;
1082   for(UInt_t i=0;i<ntrack;i++){
1083     Int_t size=sizeof(AliL3TrackSegmentData)+track_pt->fNPoints*sizeof(UInt_t);
1084     fwrite(track_pt,size,1,fOutBinary);
1085     Byte_t *byte_pt = (Byte_t*) track_pt;
1086     byte_pt += size;
1087     track_pt = (AliL3TrackSegmentData*) byte_pt;
1088   }
1089   LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","File")
1090   <<AliL3Log::kDec<<"Wrote  "<<ntrack<<" Tracks to File"<<ENDLOG;
1091
1092   return kTRUE;
1093 }
1094
1095 Bool_t AliL3MemHandler::Binary2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data)
1096 {
1097   //Read the tracks in inputfile, and store it in data.
1098
1099   if(!fInBinary){
1100     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
1101     <<"No Input File"<<ENDLOG;
1102     return kFALSE;
1103   }
1104   if(!data){
1105     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
1106     <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1107     return kFALSE;
1108   }
1109
1110   ntrack=0;
1111   AliL3TrackSegmentData *track_pt = data;
1112   rewind(fInBinary);
1113 /*
1114   UInt_t  size,slice,patch,row[2];
1115   AliL3EventDataTypeRoot datatype;
1116   UInt_t node;
1117   if(fread(&datatype,sizeof(AliL3EventDataTypeRoot),1,fInBinary)!=1){
1118     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1119     <<"File Read Error "<<ENDLOG;
1120     return kFALSE;
1121   }
1122   if(fread(&node,sizeof(UInt_t),1,fInBinary)!=1){
1123     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1124     <<"File Read Error "<<ENDLOG;
1125     return kFALSE;
1126   }
1127   if(fread(&size,sizeof(UInt_t),1,fInBinary)!=1){
1128     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1129     <<"File Read Error "<<ENDLOG;
1130     return kFALSE;
1131   }
1132   if(fread(&slice,sizeof(UInt_t),1,fInBinary)!=1){
1133     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1134     <<"File Read Error "<<ENDLOG;
1135     return kFALSE;
1136   }
1137   if(fread(&patch,sizeof(UInt_t),1,fInBinary)!=1){
1138     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1139     <<"File Read Error "<<ENDLOG;
1140     return kFALSE;
1141   }
1142   if(fread(row,2*sizeof(UInt_t),1,fInBinary)!=1){
1143     LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
1144     <<"File Read Error "<<ENDLOG;
1145     return kFALSE;
1146   }
1147 */
1148   while(!feof(fInBinary)){
1149     if(fread(track_pt,sizeof(AliL3TrackSegmentData),1,fInBinary)!=1) break;
1150     Int_t size=track_pt->fNPoints*sizeof(UInt_t);
1151     if(fread(track_pt->fPointIDs,size,1,fInBinary)!=1) break;
1152     Byte_t *byte_pt = (Byte_t*) track_pt;
1153     byte_pt += sizeof(AliL3TrackSegmentData)+size;
1154     track_pt = (AliL3TrackSegmentData*) byte_pt;
1155     ntrack++;
1156   }
1157   LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","File")
1158   <<AliL3Log::kDec<<"Wrote  "<<ntrack<<" Tracks to Memory"<<ENDLOG;
1159   return kTRUE;
1160 }
1161
1162 Bool_t AliL3MemHandler::TrackArray2Binary(AliL3TrackArray *array)
1163 {
1164   //Write the trackarray to the outputfile.
1165   if(!fOutBinary){
1166     LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Binary","File")
1167     <<"No Output File"<<ENDLOG;
1168     return kFALSE;
1169   }
1170   if(!array){
1171     LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Binary","Memory")
1172     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1173     return kFALSE;
1174   }
1175   AliL3TrackSegmentData *data = (AliL3TrackSegmentData *)Allocate(array);
1176   UInt_t ntrack;
1177   TrackArray2Memory(ntrack,data,array);
1178   Memory2Binary(ntrack,data);
1179   Free();
1180   return kTRUE;
1181 }
1182
1183 Bool_t AliL3MemHandler::Binary2TrackArray(AliL3TrackArray *array)
1184 {
1185   //Read the tracks in inputfile, and fill it in trackarray.
1186   //array should already be constructed.
1187   if(!fInBinary){
1188     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2TrackArray","File")
1189     <<"No Input File"<<ENDLOG;
1190     return kFALSE;
1191   }
1192   if(!array){
1193     LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2TrackArray","Memory")
1194     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1195     return kFALSE;
1196   }
1197   AliL3TrackSegmentData *data = (AliL3TrackSegmentData *)Allocate();
1198   UInt_t ntrack;
1199   Binary2Memory(ntrack,data);
1200   Memory2TrackArray(ntrack,data,array);
1201   Free();
1202   return kTRUE;
1203 }
1204
1205 Bool_t AliL3MemHandler::TrackArray2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array)
1206 {
1207   //Fill the trackarray into the AliTrackSegmentData structures before writing to outputfile.
1208   if(!data){
1209     LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Memory","Memory")
1210     <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1211     return kFALSE;
1212   }
1213   if(!array){
1214     LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Memory","Memory")
1215     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1216     return kFALSE;
1217   }
1218   array->WriteTracks(ntrack,data);
1219   return kTRUE;
1220 }
1221
1222 Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array)
1223 {
1224   //Fill the tracks in data into trackarray.
1225
1226   if(!data){
1227     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1228     <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1229     return kFALSE;
1230   }
1231   if(!array){
1232     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1233     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1234     return kFALSE;
1235   }
1236   array->FillTracks(ntrack,data);
1237   return kTRUE;
1238 }
1239
1240 Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array,Int_t slice,
1241                                           AliL3Transform* trans)
1242 {
1243   //Fill the tracks in data into trackarray, and rotate the tracks to global coordinates.
1244
1245   if(!data){
1246     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1247     <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1248     return kFALSE;
1249   }
1250   if(!array){
1251     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1252     <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1253     return kFALSE;
1254   }
1255   if(!trans){
1256     LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Object")
1257     <<"Pointer to AliL3Transform = 0x0 "<<ENDLOG;
1258     return kFALSE;
1259   }
1260   array->FillTracks(ntrack,data,slice,trans);
1261   return kTRUE;
1262 }
1263
1264 void AliL3MemHandler::UpdateRowPointer(AliL3DigitRowData *&tempPt)
1265 {
1266   //Update the data pointer to the next padrow in memory.
1267
1268   Byte_t *tmp = (Byte_t*)tempPt;
1269   Int_t size = sizeof(AliL3DigitRowData) + tempPt->fNDigit*sizeof(AliL3DigitData);
1270   tmp += size;
1271   tempPt = (AliL3DigitRowData*)tmp;
1272 }