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