HLT/src/AliL3MemHandler.cxx

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