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