HLT/src/AliL3MemHandler.cxx

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