aab2da3efa494d1f233db4612d1bfbb566f621a2
[u/mrichter/AliRoot.git] / TPC / AliTPCCompression.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18
19 // This class contains the implementation of the 
20 // compression and decompression algorithms 
21 // Compression is performed reading the Altro data block (called packet) backward.
22 // Similarly decompression is also done backward so that the final file is restored
23 // after the compression and decompression phase.
24
25 #include <stdlib.h>
26 #include <TObjArray.h>
27 #include <Riostream.h>
28 #include <TMath.h>
29 #include "AliTPCCompression.h"
30 #include "AliTPCBuffer160.h"
31 #include "AliTPCHuffman.h"
32
33 ClassImp(AliTPCCompression)
34 //////////////////////////////////////////////////////////////////////////////////////////////////
35 AliTPCCompression::AliTPCCompression(){
36   //Defaul constructor
37   fDimBuffer=sizeof(ULong_t)*8;
38   fFreeBitsBuffer=fDimBuffer;
39   fReadBits=0;
40   fPos=0;
41   fBuffer=0;
42   fVerbose=0;
43   fFillWords=0;
44   return;
45 }
46 //////////////////////////////////////////////////////////////////////////////////////////////////
47 AliTPCCompression::AliTPCCompression(const AliTPCCompression &source){
48   //Constructor
49   this->fDimBuffer=source.fDimBuffer;
50   this->fFreeBitsBuffer=source.fFreeBitsBuffer;
51   this->fReadBits=source.fReadBits;
52   this->fPos=source.fPos;
53   this->fBuffer=source.fBuffer;
54   this->fVerbose=source.fVerbose;
55   this->fFillWords=source.fFillWords;
56   return;
57 }
58 //////////////////////////////////////////////////////////////////////////////////////////////////
59 AliTPCCompression&  AliTPCCompression::operator=(const AliTPCCompression &source){
60   //Redefinition of the assignment operator
61   this->fDimBuffer=source.fDimBuffer;
62   this->fFreeBitsBuffer=source.fFreeBitsBuffer;
63   this->fReadBits=source.fReadBits;
64   this->fPos=source.fPos;
65   this->fBuffer=source.fBuffer;
66   this->fVerbose=source.fVerbose;
67   this->fFillWords=source.fFillWords;
68   return *this;
69
70 //////////////////////////////////////////////////////////////////////////////////////////////////
71 void AliTPCCompression::NextTable(Int_t Val,Int_t &NextTableType,Int_t &BunchLen,Int_t &Count)const{
72   //Depending on the data type (5 types of data) a specific table is called
73   /*
74     Table index:
75     0==> Bunch length value     
76     1==> Time Bin value 
77     2==> 1-samples bunch
78     3==> Central samples
79     4==> Border samples
80   */  
81   switch (NextTableType){
82   case 0:{
83     BunchLen=Val-2;
84     NextTableType=1;
85     break;
86   }//end case 0
87   case 1:{
88     if (BunchLen==1)NextTableType=2;
89     else{
90       NextTableType=4;
91       Count=1;
92     }
93     break;
94   }//end case 1
95   case 2:{
96     NextTableType=0;
97     break;
98   }//end case 2
99   case 3:{
100     Count++;
101     if (Count==(BunchLen-1)){
102       NextTableType=4;
103     }
104     break;
105   }//end case 3
106   case 4:{
107     if (Count==1){
108       if (BunchLen>2)
109         NextTableType=3;
110       else
111         Count++;
112     }
113     else
114       NextTableType=0;
115     break;
116   }//end case 4
117   }//end switch
118   return;
119 }
120
121 /////////////////////////////////////////////////////////////////////////////////////////////////////
122
123 /////////////////////////////////////////////////////////////////////////////////////////////////////
124
125 Int_t AliTPCCompression::FillTables(const char* fSource,AliTPCHTable* table[],const Int_t NumTables){
126   //This method is used to compute the frequencies of the symbols in the source file
127   AliTPCBuffer160 buff(fSource,0);
128   ULong_t countWords=0;
129   ULong_t countTrailer=0;
130   Int_t numWords,padNum,rowNum,secNum=0;
131   Int_t value=0;
132   ULong_t stat[5]={0,0,0,0,0};
133   Int_t endFill=0;
134   Int_t end=1;
135   while(buff.ReadTrailerBackward(numWords,padNum,rowNum,secNum) !=-1 ){
136     if(end){
137       endFill=buff.GetFillWordsNum();
138       end=0;
139     }//endif
140     countTrailer++;
141     if (numWords%4){
142       fFillWords+=4-numWords%4;
143       for(Int_t j=0;j<(4-numWords%4);j++){
144         value=buff.GetNextBackWord();
145       }//end for
146     }//end if
147     
148     Int_t packet[1024];
149     Int_t timePos[345];
150     Int_t tp=0;
151     for(Int_t i=0;i<345;i++)timePos[i]=0;
152     for(Int_t i=0;i<1024;i++)packet[i]=0;
153     
154     Int_t nextTableType=0;
155     Int_t bunchLen=0;
156     Int_t count=0;
157     for(Int_t i=0;i<numWords;i++){
158       value=buff.GetNextBackWord();
159       packet[i]=value;
160       if(nextTableType==1){
161         timePos[tp]=i;
162         tp++;
163       }
164       NextTable(value,nextTableType,bunchLen,count);
165     }//end for
166     //computing the Time gap between two bunches
167     Int_t temp=0;
168     tp--;
169     Int_t previousTime=packet[timePos[tp]];
170     for(Int_t i=tp-1;i>=0;i--){
171       Int_t timPos=timePos[i];
172       Int_t bunchLen=packet[timPos-1]-2;
173       temp=packet[timPos];
174       packet[timPos]=packet[timPos]-previousTime-bunchLen;
175       previousTime=temp;
176     }
177     nextTableType=0;
178     count=0;
179     bunchLen=0;
180     for(Int_t i=0;i<numWords;i++){
181       value=packet[i];
182       table[nextTableType]->SetFrequency(value);
183       stat[nextTableType]++;
184       NextTable(value,nextTableType,bunchLen,count);
185       countWords++;
186     }//end for
187   }//end while
188   cout<<"Number of words:       "<<countWords<<endl;
189   cout<<"Number of trailers:    "<<countTrailer<<endl;
190   cout<<"Number of fill words   "<<fFillWords+endFill<<endl;
191   cout<<"Total number of words: "<<countWords+countTrailer*4+fFillWords<<endl;
192   //STATISTICS  
193   fStat.open("Statistics");
194   fStat<<"Number of words:..........................................."<<countWords<<endl;
195   fStat<<"Number of trailers (4 10 bits words in each one)..........."<<countTrailer<<endl;
196   fStat<<"Number of fill words:......................................"<<fFillWords+endFill<<endl;
197   fStat<<"Total number of words:....................................."<<countWords+countTrailer*4+fFillWords+endFill<<endl;
198   fStat<<"-----------------------------------------"<<endl;
199   fStat<<"Number of Bunches............."<<stat[0]<<endl;
200   fStat<<"Number of Time bin............"<<stat[1]<<endl;
201   fStat<<"Number of One Samples Bunch..."<<stat[2]<<endl;
202   fStat<<"Number of Central Samples....."<<stat[3]<<endl;
203   fStat<<"Number of Border Samples......"<<stat[4]<<endl;
204   fStat<<"-----------------------------------------"<<endl;
205   ULong_t fileDimension=(ULong_t)TMath::Ceil(double((countTrailer*4+countWords+fFillWords+endFill)*10/8));
206   fStat<<"Total file Size in bytes.."<<fileDimension<<endl;
207   Double_t percentage=TMath::Ceil((fFillWords+endFill)*125)/fileDimension;
208   fStat<<"Fill Words................"<<(ULong_t)TMath::Ceil((fFillWords+endFill)*10/8)<<" bytes   "<<percentage<<"%"<<endl;  
209   percentage=(Double_t)countTrailer*500/fileDimension;
210   fStat<<"Trailer..................."<<countTrailer*5<<" bytes   "<<percentage<<"%"<<endl;
211
212   percentage=(Double_t)((stat[0]+stat[1]+stat[2]+stat[3]+stat[4])) *125/fileDimension;
213   fStat<<"Data......................"<<(ULong_t)TMath::Ceil((stat[0]+stat[1]+stat[2]+stat[3]+stat[4])*10/8)<<" bytes   "<<percentage<<"%"<<endl;
214
215   percentage=(Double_t)(stat[0]*125)/fileDimension;
216   fStat<<"Bunch....................."<<(ULong_t)TMath::Ceil(stat[0]*10/8)<<" bytes  "<<percentage<<"%"<<endl;  //  
217   percentage=(Double_t)(stat[1]*125)/fileDimension;
218   fStat<<"Time......................"<<(ULong_t)TMath::Ceil(stat[1]*10/8)<<" bytes  "<<percentage<<"%"<<endl;  //  
219
220
221   percentage=(Double_t)((stat[2]+stat[3]+stat[4])) *125/fileDimension;
222   fStat<<"Amplitude values.........."<<(ULong_t)TMath::Ceil((stat[2]+stat[3]+stat[4])*10/8)<<" bytes  "<<percentage<<"%"<<endl;
223   percentage=(Double_t)(stat[2]*125)/fileDimension;
224   fStat<<"     One Samples..............."<<(ULong_t)TMath::Ceil(stat[2]*10/8)<<" bytes  "<<percentage<<"%"<<endl;  //  
225   percentage=(Double_t)(stat[3]*125)/fileDimension;
226   fStat<<"     Central Samples..........."<<(ULong_t)TMath::Ceil(stat[3]*10/8)<<" bytes  "<<percentage<<"%"<<endl;  //  
227   percentage=(Double_t)(stat[4]*125)/fileDimension;
228   fStat<<"     Border Samples............"<<(ULong_t)TMath::Ceil(stat[4]*10/8)<<" bytes  "<<percentage<<"%"<<endl;  //  
229   fStat.close();
230   return 0;
231 }
232 ////////////////////////////////////////////////////////////////////////////////////////
233 Int_t AliTPCCompression::StoreTables(AliTPCHTable* table[],const Int_t NumTable){
234   //This method stores the tables in a sequence of binary file
235   char filename[15];
236   ofstream fTable;
237   for(Int_t k=0;k<NumTable;k++){
238     sprintf(filename,"Table%d.dat",k);
239 #ifndef __DECCXX 
240     fTable.open(filename,ios::binary);
241 #else
242     fTable.open(filename);
243 #endif
244     Int_t dim=table[k]->Size();
245     //Table dimension is written into a file
246     fTable.write((char*)(&dim),sizeof(Int_t));
247     //One table is written into a file
248     for(Int_t i=0;i<dim;i++){
249       UChar_t codeLen=table[k]->CodeLen()[i];
250       //      ULong_t code=(ULong_t)table[k]->Code()[i];
251       Double_t code=table[k]->Code()[i];
252       fTable.write((char*)(&codeLen),sizeof(UChar_t));
253       //fTable.write((char*)(&code),sizeof(ULong_t));
254       fTable.write((char*)(&code),sizeof(Double_t));
255     } //end for
256     fTable.close();
257   }//end for
258   return 0;
259 }
260 ////////////////////////////////////////////////////////////////////////////////////////
261 Int_t AliTPCCompression::CreateTableFormula(Double_t beta,ULong_t  M,Int_t dim,Int_t Type){
262   // Type = 0 for Bunch length
263   // Type = 1 for Time Gap
264   ULong_t freq;
265   Double_t sum=0;
266   Double_t min=10;
267   Double_t alpha=0;
268   Double_t A=0;
269   AliTPCHTable *Table=new AliTPCHTable(dim);
270   
271   freq=1;
272   Double_t FreqArray[1024];
273   for(Int_t i=0;i<1024;i++){
274     FreqArray[i]=0;
275   }
276   alpha=M*0.000000602+0.0104;
277   if (fVerbose)
278     cout<<"alpha "<<alpha<<endl;
279   for(Int_t x=0;x<dim;x++){
280     if (Type==1)
281       FreqArray[x]=TMath::Power((x+1),-beta)*TMath::Exp(-alpha*(x+1));
282     else
283       FreqArray[x]=TMath::Power((x+1),-beta);
284     sum+=FreqArray[x];
285     if (FreqArray[x]<min)min=FreqArray[x];
286   }//end for
287   if (fVerbose)
288     cout<<"Minimun Value "<<min<<endl;
289   A=1/sum;
290   if (fVerbose)
291     cout<<"A Value: "<<A<<endl;
292   for(Int_t x=0;x<dim;x++){
293     if (Type==0)//Bunch length
294       if (x>=3)//minimum bunch length
295         Table->SetValFrequency(x,A*FreqArray[x]*1000);
296       else
297         Table->SetValFrequency(x,0);
298     else //Time table
299       Table->SetValFrequency(x,A*FreqArray[x]);
300   }
301   Table->BuildHTable();
302   ofstream fTable;
303   char filename[15];
304   sprintf(filename,"Table%d.dat",Type); 
305 #ifndef __DECCXX 
306   fTable.open(filename,ios::binary);
307 #else
308   fTable.open(filename);
309 #endif
310   Int_t dimTable=Table->Size();
311   //Table dimension is written into a file
312   fTable.write((char*)(&dimTable),sizeof(Int_t));
313   //One table is written into a file
314   for(Int_t i=0;i<dimTable;i++){
315     UChar_t CodeLen=Table->CodeLen()[i];
316     Double_t Code=Table->Code()[i];
317     fTable.write((char*)(&CodeLen),sizeof(UChar_t));
318     fTable.write((char*)(&Code),sizeof(Double_t));
319   } //end for
320   fTable.close();
321   delete Table;
322   return 0;
323 }
324 ////////////////////////////////////////////////////////////////////////////////////////
325 Int_t AliTPCCompression::CreateTables(const char* fSource,const Int_t NumTables){
326   //Tables manager
327   /*
328     Table index:
329     0==> Bunch length values     
330     1==> Time Bin values 
331     2==> 1-samples bunch
332     3==> Central samples
333     4==> Border samples
334   */
335   Int_t n=10;// 10 bits per symbol 
336   AliTPCHTable ** table = new AliTPCHTable*[NumTables];
337   //The table is inizialized with the rigth number of rows 
338   for(Int_t i=0;i<NumTables;i++){
339     table[i]=new  AliTPCHTable((Int_t)(TMath::Power(2,n)));
340     table[i]->SetVerbose(fVerbose);
341   }
342   //The frequencies are calculated and the tables are filled
343   if (fVerbose)
344     cout<<"Filling tables...\n";
345   //The get the frequencies 
346   FillTables(fSource,table,NumTables);
347
348   //This part will be used in the table optimization phase
349   /*
350   for(Int_t i=0;i<NumTables;i++){
351     table[i]->CompleteTable(i);
352   }
353   */
354   if(fVerbose){
355     cout<<"Entropy of Bunch length table........."<<table[0]->GetEntropy()<<endl;
356     cout<<"Entropy of Time bin table............."<<table[1]->GetEntropy()<<endl;
357     cout<<"Entropy of one Sample bunch table....."<<table[2]->GetEntropy()<<endl;
358     cout<<"Entropy of Central Sample table......."<<table[3]->GetEntropy()<<endl;
359     cout<<"Entropy Border Samples table.........."<<table[4]->GetEntropy()<<endl;
360   }
361   fStat.open("Statistics",ios::app);
362   fStat<<endl;
363   fStat<<"----------------- ENTROPY for castomized tables --------------------------"<<endl;
364   fStat<<"Entropy of Bunch length table......."<<table[0]->GetEntropy()<<endl;
365   fStat<<"Entropy of Time bin table..........."<<table[1]->GetEntropy()<<endl;
366   fStat<<"Entropy of one Sample bunch table..."<<table[2]->GetEntropy()<<endl;
367   fStat<<"Entropy of Central Sample table....."<<table[3]->GetEntropy()<<endl;
368   fStat<<"Entropy Border Samples table........"<<table[4]->GetEntropy()<<endl;
369   fStat.close();
370  
371   if (fVerbose)
372     cout<<"Tables filled \n";
373   
374   //Frequencies normalization
375   table[0]->NormalizeFrequencies();
376   table[1]->NormalizeFrequencies();
377   table[2]->NormalizeFrequencies();
378   table[3]->NormalizeFrequencies();
379   table[4]->NormalizeFrequencies();
380   
381   //Tables are saved in a sequence of text file and using the macro Histo.C is it possible to get
382   //a series of histograms rappresenting the frequency distribution
383   table[0]->StoreFrequencies("BunchLenFreq.txt");
384   table[1]->StoreFrequencies("TimeFreq.txt");
385   table[2]->StoreFrequencies("Sample1Freq.txt");
386   table[3]->StoreFrequencies("SCentralFreq.txt");
387   table[4]->StoreFrequencies("SBorderFreq.txt");
388   if (fVerbose)
389     cout<<"Creating Tables..\n";
390   //One Huffman tree is created for each table starting from the frequencies of the symbols
391   for(Int_t i=0;i<NumTables;i++){
392     table[i]->BuildHTable();
393     if (fVerbose==2){
394       cout<<"Number of elements inside the table:"<<table[i]->GetWordsNumber();
395       switch(i){
396       case 0:{
397         cout<<" (Bunch Length)"<<endl;
398         break;
399       }
400       case 1:{
401         cout<<" (Time Bin)"<<endl;
402         break;
403       }
404       case 2:{
405         cout<<" (1 Samples Bunch)"<<endl;
406         break;
407       }
408       case 3:{
409         cout<<" (Central Samples)"<<endl;
410         break;
411       }
412       case 4:{
413         cout<<" (Border Samples)"<<endl;
414         break;
415       }
416       }//end switch
417       table[i]->PrintTable();
418     }
419   }
420   //The tables are saved ad binary files
421   StoreTables(table,NumTables);
422   //The tables stored in memory are deleted; 
423   for(Int_t i=0;i<NumTables;i++)delete table[i];
424   delete [] table;
425   return 0;
426 }
427 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
428 Int_t AliTPCCompression::RetrieveTables(AliTPCHTable* table[],Int_t NumTable){
429   //This method retrieve the Huffman tables from a sequence of binary files
430   if (fVerbose)
431     cout<<"Retrieving tables from files \n";
432   //  ULong_t code;
433   Double_t code;
434   UChar_t codeLen;
435   ifstream fTable;  
436   char filename[15];
437   //The following for loop is used to generate the Huffman trees acording to the tables
438   for(Int_t k=0;k<NumTable;k++){
439     Int_t dim;//this variable contains the table dimension
440     sprintf(filename,"Table%d.dat",k); 
441 #ifndef __DECCXX 
442     fTable.open(filename,ios::binary);
443 #else
444     fTable.open(filename);
445 #endif
446     if(!fTable){cout<<"File doesn't exist:"<<filename<<endl; exit(1);}
447     fTable.read((char*)(&dim),sizeof(Int_t));
448     if (fVerbose)
449       cout<<"Table dimension: "<<dim<<endl;
450     table[k]=new AliTPCHTable(dim);
451     for(Int_t i=0;i<dim;i++){
452       fTable.read((char*)(&codeLen),sizeof(UChar_t));
453       table[k]->SetCodeLen(codeLen,i);
454       //      fTable.read((char*)(&code),sizeof(ULong_t));
455       fTable.read((char*)(&code),sizeof(Double_t));
456       table[k]->SetCode(Mirror((ULong_t)code,codeLen),i);
457     }//end for 
458     fTable.close();
459   }//end for 
460   if (fVerbose)
461     cout<<"Trees generated \n";
462   //At this point the trees are been built
463   return 0;
464 }
465
466 Int_t AliTPCCompression::CreateTablesFromTxtFiles(Int_t NumTable){
467   //This method creates a set of binary tables, needed by the Huffman
468   //algorith, starting from a set of frequencies tables stored in form of
469   //txt files
470   if (fVerbose)
471     cout<<"Retrieving frequencies from txt files \n";
472   ifstream fTable;  
473   char filename[15];
474   //Tables are read from the files (Each codeword has been "Mirrored")
475   AliTPCHTable **table = new AliTPCHTable*[NumTable];
476   for(Int_t k=0;k<NumTable;k++){
477     sprintf(filename,"Table%d.txt",k); 
478     cout<<filename<<endl;
479     fTable.open(filename);
480     if(!fTable){cout<<"File doesn't exist: "<<filename<<endl; exit(1);}
481     Int_t symbol=0;
482     Double_t freq=0;
483     table[k]=new AliTPCHTable(1024);
484     while(!fTable.eof()){
485       fTable>>freq;
486       if (fTable.good()){
487         if (freq<0){
488           cout<<"Frequency cannot be negative !!!\n";
489           exit(1);
490         }
491         table[k]->SetValFrequency(symbol,freq);
492       }
493       symbol++;
494     }//end while
495     fTable.clear();
496     fTable.close();
497   }//end for
498   fStat.open("Statistics",ios::app);
499   fStat<<endl;
500   fStat<<"----------------- ENTROPY for external txt tables --------------------------"<<endl;
501   fStat<<"Entropy of Bunch length table......."<<table[0]->GetEntropy()<<endl;
502   fStat<<"Entropy of Time bin table..........."<<table[1]->GetEntropy()<<endl;
503   fStat<<"Entropy of one Sample bunch table..."<<table[2]->GetEntropy()<<endl;
504   fStat<<"Entropy of Central Sample table....."<<table[3]->GetEntropy()<<endl;
505   fStat<<"Entropy Border Samples table........"<<table[4]->GetEntropy()<<endl;
506   fStat.close();
507   for(Int_t k=0;k<NumTable;k++){
508     table[k]->BuildHTable();
509   }//end for
510   //The tables are saved ad binary files
511   StoreTables(table,NumTable);  
512   //The tables stored in memory are deleted; 
513   for(Int_t i=0;i<NumTable;i++)delete table[i];
514   delete [] table;
515   return 0;
516 }
517
518 ////////////////////////////////////////////////////////////////////////////////////////
519 /*                               COMPRESSION                                          */
520 ////////////////////////////////////////////////////////////////////////////////////////
521
522 void AliTPCCompression::StoreValue(ULong_t val,UChar_t len){
523   //This method stores the value "val" of "len" bits into the internal buffer "fBuffer"
524   if (len<=fFreeBitsBuffer){           // val is not splitted in two buffer
525     fFreeBitsBuffer-=len;
526     fBuffer=fBuffer<<len;
527     fBuffer=fBuffer|val;    
528     if(!fFreeBitsBuffer){              // if the buffer is full it is written into a file 
529       f.write((char*)(&fBuffer),sizeof(ULong_t));       
530       fFreeBitsBuffer=fDimBuffer;
531       fBuffer=0;
532     }
533   }//end if
534   else{                               //val has to be splitted in two buffers
535     fBuffer=fBuffer<<fFreeBitsBuffer;
536     ULong_t temp;
537     temp=val;
538     temp=temp>>(len-fFreeBitsBuffer);
539     fBuffer=fBuffer|temp;
540     f.write((char*)(&fBuffer),sizeof(ULong_t));
541     fFreeBitsBuffer=fDimBuffer-(len-fFreeBitsBuffer);
542     val=val<<fFreeBitsBuffer;
543     val=val>>fFreeBitsBuffer;
544     fBuffer=val;
545   }//end else
546   return;
547 }
548 //////////////////////////////////////////////////////////////////////////////////////////////////
549 void AliTPCCompression::Flush(){
550   //The last buffer cannot be completely full so to save it 
551   //into the output file it is first necessary to fill it with an hexadecimal pattern
552   if(fFreeBitsBuffer<fDimBuffer){
553     fBuffer=fBuffer<<fFreeBitsBuffer;
554     f.write((char*)(&fBuffer),sizeof(ULong_t));  
555   }//end if
556   return;
557 }
558 //////////////////////////////////////////////////////////////////////////////////////////////////
559 ULong_t AliTPCCompression::Mirror(ULong_t val,UChar_t len)const{
560   //This method inverts the digits of the number "val" and length "len"
561   //indicates the number of digits of the number considered in binary notation
562   ULong_t specular=0;
563   ULong_t mask=0x1;
564   ULong_t bit;
565   for(Int_t i=0;i<len;i++){
566     bit=val&mask;
567     bit=bit>>i;
568     specular=specular<<1;
569     specular=specular|bit;
570     mask=mask<<1;
571   }
572   return specular;
573 }
574 //////////////////////////////////////////////////////////////////////////////////////////////////
575 Int_t AliTPCCompression::CompressData(AliTPCHTable* table[],Int_t NumTable,const char* fSource,const char* fDest){
576   //This method is used to compress the data stored in the Altro format file using specific tables
577   //calculated considering the frequencies of the symbol of the file that has to be compressed
578   cout<<" COMPRESSION "<<endl;
579   cout<<"compression of the file "<<fSource<<" Output File: "<<fDest<<endl;
580   //the output file is open
581 #ifndef __DECCXX 
582   f.open(fDest,ios::binary|ios::out);
583 #else
584   f.open(fDest,ios::out);
585 #endif
586   //Tables are written into the output file
587   for(Int_t k=0;k<NumTable;k++){
588     Int_t dim=table[k]->Size();
589     //Table dimension is written into a file
590     f.write((char*)(&dim),sizeof(Int_t));
591     //One table is written into a file
592     for(Int_t i=0;i<dim;i++){
593       UChar_t codeLen=table[k]->CodeLen()[i];
594       ULong_t code=(ULong_t)table[k]->Code()[i];
595       f.write((char*)(&codeLen),sizeof(UChar_t));
596       f.write((char*)(&code),sizeof(ULong_t));
597     } //end for
598   }//end for
599
600   // Source file is open
601   AliTPCBuffer160 buff(fSource,0);
602   //coded words are written into the output file
603   Int_t numWords,padNum,rowNum,secNum=0;
604   ULong_t storedWords=0;
605   Int_t value=0;
606   ULong_t numPackets=0;
607   while(buff.ReadTrailerBackward(numWords,padNum,rowNum,secNum) !=-1 ){
608     numPackets++;
609     if (numWords%4){
610       for(Int_t j=0;j<(4-numWords%4);j++){
611         value=buff.GetNextBackWord();
612       }//end for
613     }//end if
614
615     Int_t packet[1024];
616     Int_t timePos[345];
617     Int_t tp=0;
618     for(Int_t i=0;i<345;i++)timePos[i]=0;
619     for(Int_t i=0;i<1024;i++)packet[i]=0;
620
621     Int_t nextTableType=0;
622     Int_t bunchLen=0;
623     Int_t count=0;
624     for(Int_t i=0;i<numWords;i++){
625       value=buff.GetNextBackWord();
626       packet[i]=value;
627       if(nextTableType==1){
628         timePos[tp]=i;
629         tp++;
630       }
631       NextTable(value,nextTableType,bunchLen,count);
632     }//end for
633     //computing the Time gap between two bunches
634     Int_t temp=0;
635     tp--;
636     Int_t previousTime=packet[timePos[tp]];
637     for(Int_t i=tp-1;i>=0;i--){
638       Int_t timPos=timePos[i];
639       Int_t bunchLen=packet[timPos-1]-2;
640       temp=packet[timPos];
641       packet[timPos]=packet[timPos]-previousTime-bunchLen;
642       previousTime=temp;
643     }//end for
644     nextTableType=0;
645     count=0;
646     bunchLen=0;
647     Int_t timeBin=0;
648     //All the words for one pad are compressed and stored in the compress file
649     for(Int_t i=0;i<numWords;i++){
650       value=packet[i];
651       if(nextTableType==1)timeBin=value;
652       if(nextTableType>1){
653         //      ULong_t val=(ULong_t)table[nextTableType]->Code()[value];     // val is the code
654         Double_t val=table[nextTableType]->Code()[value];     // val is the code
655         UChar_t len=table[nextTableType]->CodeLen()[value];  // len is the length (number of bits)of val
656         StoreValue(Mirror((ULong_t)val,len),len);
657         storedWords++;
658       }//end if
659       NextTable(value,nextTableType,bunchLen,count);
660       if(nextTableType==0){
661         //      ULong_t val=(ULong_t)table[1]->Code()[timeBin];     // val is the code
662         Double_t val=table[1]->Code()[timeBin];     // val is the code
663         UChar_t len=table[1]->CodeLen()[timeBin];  // len is the length (number of bits)of val
664         StoreValue(Mirror((ULong_t)val,len),len);
665         //val=(ULong_t)table[nextTableType]->Code()[(bunchLen+2)];     // val is the code
666         val=table[nextTableType]->Code()[(bunchLen+2)];     // val is the code
667         len=table[nextTableType]->CodeLen()[(bunchLen+2)];  // len is the length (number of bits)of val
668         StoreValue(Mirror((ULong_t)val,len),len);
669         storedWords+=2;
670       }
671     }//end for
672     //Trailer
673     StoreValue(numWords,10);
674     StoreValue(padNum,10);
675     StoreValue(rowNum,10);
676     StoreValue(secNum,9);
677     StoreValue(1,1);
678     storedWords+=4;
679   }//end  while
680   StoreValue(numPackets,32);
681   cout<<"Number of strored packet: "<<numPackets<<endl;
682   StoreValue(1,1);
683   //The last buffen cannot be completely full
684   Flush();
685   cout<<"Number of stored words: "<<storedWords<<endl;
686   f.close();
687   return 0;
688 }
689
690 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
691 Int_t AliTPCCompression::CompressDataOptTables(Int_t NumTable,const char* fSource,const char* fDest){
692   //This method compress an Altro format file using a general set of tables stored as binary files to be provided
693   if (fVerbose){
694     cout<<" BackWord COMPRESSION "<<endl;
695     cout<<"compression of the file "<<fSource<<" Output File: "<<fDest<<endl;
696   }
697   //Tables are read from the files (Each codeword has been "Mirrored")
698   AliTPCHTable **table = new AliTPCHTable*[NumTable];
699   RetrieveTables(table,NumTable);
700   //the output file is open
701 #ifndef __DECCXX 
702   f.open(fDest,ios::binary|ios::out);
703 #else
704   f.open(fDest,ios::out);
705 #endif
706   // Source file is open
707   AliTPCBuffer160 buff(fSource,0);
708   //coded words are written into a file
709   Int_t numWords,padNum,rowNum,secNum=0;
710   ULong_t  storedWords=0;
711   Int_t    value=0;
712   ULong_t  numPackets=0;
713   Double_t stat[5]={0.,0.,0.,0.,0.};
714   ULong_t  trailerNumbers=0;
715   Double_t numElem[5]={0,0,0,0,0};
716   Double_t fillWords=0.;
717   fStat.open("Statistics",ios::app);
718   fStat<<endl;
719   fStat<<"-------------------COMPRESSION STATISTICS----------"<<endl;
720   Int_t end=1;
721   while(buff.ReadTrailerBackward(numWords,padNum,rowNum,secNum) !=-1 ){
722     if(end){
723       fillWords=buff.GetFillWordsNum();
724       end=0;
725     }//endif
726
727     numPackets++;
728     if (numWords%4){
729       fillWords+=4-numWords%4;
730       for(Int_t j=0;j<(4-numWords%4);j++){
731         value=buff.GetNextBackWord();
732       }//end for
733     }//end if
734
735     Int_t packet[1024];
736     Int_t timePos[345];
737     Int_t tp=0;
738     for(Int_t i=0;i<345;i++)timePos[i]=0;
739     for(Int_t i=0;i<1024;i++)packet[i]=0;
740
741     Int_t nextTableType=0;
742     Int_t bunchLen=0;
743     Int_t count=0;
744     for(Int_t i=0;i<numWords;i++){
745       value=buff.GetNextBackWord();
746       packet[i]=value;
747       if(nextTableType==1){
748         timePos[tp]=i;
749         tp++;
750       }
751       NextTable(value,nextTableType,bunchLen,count);
752     }//end for
753     //computing the Time gap between two bunches
754     Int_t temp=0;
755     tp--;
756     Int_t previousTime=packet[timePos[tp]];
757     for(Int_t i=tp-1;i>=0;i--){
758       Int_t timPos=timePos[i];
759       Int_t bunchLen=packet[timPos-1]-2;
760       temp=packet[timPos];
761       packet[timPos]=packet[timPos]-previousTime-bunchLen;
762       previousTime=temp;
763     }//end for
764
765     nextTableType=0;
766     count=0;
767     bunchLen=0;
768     Int_t timeBin=0;
769     for(Int_t i=0;i<numWords;i++){
770       value=packet[i];
771       if(nextTableType==1)timeBin=value;
772       if(nextTableType>1){
773         //ULong_t val=(ULong_t)table[nextTableType]->Code()[value];     // val is the code
774         Double_t val=table[nextTableType]->Code()[value];     // val is the code
775         UChar_t len=table[nextTableType]->CodeLen()[value];  // len is the length (number of bits)of val
776         stat[nextTableType]+=len;
777         numElem[nextTableType]++;
778         StoreValue((ULong_t)val,len);
779         storedWords++;
780       }//end if
781       NextTable(value,nextTableType,bunchLen,count);
782       if(nextTableType==0){
783         //      ULong_t val=(ULong_t)table[1]->Code()[timeBin];     // val is the code
784         Double_t val=table[1]->Code()[timeBin];     // val is the code
785         UChar_t len=table[1]->CodeLen()[timeBin];  // len is the length (number of bits)of val
786         stat[1]+=len;
787         numElem[1]++;
788         StoreValue((ULong_t)val,len);
789         //      val=(ULong_t)table[nextTableType]->Code()[(bunchLen+2)];     // val is the code
790         val=table[nextTableType]->Code()[(bunchLen+2)];     // val is the code
791         len=table[nextTableType]->CodeLen()[(bunchLen+2)];  // len is the length (number of bits)of val
792         StoreValue((ULong_t)val,len);
793         stat[nextTableType]+=len;
794         numElem[nextTableType]++;
795         storedWords+=2;
796       }
797     }//end for
798     //Trailer
799     StoreValue(numWords,10);
800     StoreValue(padNum,10);
801     StoreValue(rowNum,10);
802     StoreValue(secNum,9);
803     StoreValue(1,1);
804     storedWords+=4;
805     trailerNumbers++;
806   }//end  while
807   StoreValue(numPackets,32);
808   if(fVerbose)
809     cout<<"Number of strored packets: "<<numPackets<<endl;
810   StoreValue(1,1);
811   //The last buffen cannot be completely full
812   Flush();
813   if(fVerbose)
814     cout<<"Number of stored words: "<<storedWords<<endl;
815   f.close();
816   //Tables are deleted
817   for(Int_t i=0;i<NumTable;i++){
818     delete table[i];
819   }//end for
820   delete [] table;
821   Double_t dimension=(ULong_t)TMath::Ceil((stat[0]+stat[1]+stat[2]+stat[3]+stat[4])/8)+trailerNumbers*5;
822   fStat<<"Trailer Dimension in bytes......"<<trailerNumbers*5<<endl;
823   fStat<<"Data Dimension in bytes........."<<(ULong_t)TMath::Ceil((stat[0]+stat[1]+stat[2]+stat[3]+stat[4])/8)<<endl;
824   fStat<<"Compressed file dimension......."<<(ULong_t)dimension<<endl;
825   /*
826   fStat<<(ULong_t)trailerNumbers<<endl;
827   fStat<<(ULong_t)fillWords<<endl;
828   fStat<<(ULong_t)numElem[0]<<endl;
829   fStat<<(ULong_t)numElem[1]<<endl;
830   fStat<<(ULong_t)numElem[2]<<endl;
831   fStat<<(ULong_t)numElem[3]<<endl;
832   fStat<<(ULong_t)numElem[4]<<endl;
833   */
834   fillWords=(fillWords+numElem[0]+numElem[1]+numElem[2]+numElem[3]+numElem[4]+trailerNumbers*4)*10/8;
835   fStat<<"Original file dimension........."<<(ULong_t)fillWords<<endl;
836
837   Double_t ratio=(dimension/fillWords)*100;
838   fStat<<"Compression ratio (Compressed/Uncompressed)..."<<ratio<<"%"<<endl;
839   fStat<<endl;
840   if (numElem[0])
841     fStat<<"Bunch length size in bytes......"<<(ULong_t)TMath::Ceil(stat[0]/8)<<" Comppression.."<<(stat[0]/numElem[0])*10<<"%"<<endl;
842   if (numElem[1])  
843     fStat<<"Time gap size in bytes.........."<<(ULong_t)TMath::Ceil(stat[1]/8)<<" Comppression.."<<(stat[1]/numElem[1])*10<<"%"<<endl;
844   if (numElem[2]+numElem[3]+numElem[4])  
845     fStat<<"Amplitude values in bytes......."<<(ULong_t)TMath::Ceil((stat[2]+stat[3]+stat[4])/8)<<" Comppression.."<<
846       ((stat[2]+stat[3]+stat[4])/(numElem[2]+numElem[3]+numElem[4]))*10<<"%"<<endl;
847   if (numElem[2])
848   fStat<<"     One Samples in bytes............"<<(ULong_t)TMath::Ceil(stat[2]/8)<<" Comppression.."<<(stat[2]/numElem[2])*10<<"%"<<endl;
849   if (numElem[3])
850   fStat<<"     Central Samples size in bytes..."<<(ULong_t)TMath::Ceil(stat[3]/8)<<" Comppression.."<<(stat[3]/numElem[3])*10<<"%"<<endl;
851   if (numElem[4])
852   fStat<<"     Border Samples size in bytes...."<<(ULong_t)TMath::Ceil(stat[4]/8)<<" Comppression.."<<(stat[4]/numElem[4])*10<<"%"<<endl;
853   fStat<<endl;
854   fStat<<"Average number of bits per word"<<endl;
855   if (numElem[0])
856     fStat<<"Bunch length ......"<<stat[0]/numElem[0]<<endl;
857   if (numElem[1])
858     fStat<<"Time gap .........."<<stat[1]/numElem[1]<<endl;
859   if (numElem[2])
860     fStat<<"One Samples........"<<stat[2]/numElem[2]<<endl;
861   if (numElem[3])
862     fStat<<"Central Samples ..."<<stat[3]/numElem[3]<<endl;
863   if (numElem[4])
864     fStat<<"Border Samples....."<<stat[4]/numElem[4]<<endl;
865   fStat.close();
866   return 0;
867 }
868
869 ////////////////////////////////////////////////////////////////////////////////////////
870
871 ////////////////////////////////////////////////////////////////////////////////////////
872 /*                               DECOMPRESSION                                        */
873 ////////////////////////////////////////////////////////////////////////////////////////
874 void AliTPCCompression::CreateTrees(AliTPCHNode *RootNode[],const Int_t NumTables){
875   //The first part of the compressed file cotains the tables
876   //The following for loop is used to generate the Huffman trees acording to the tables
877   if(fVerbose)
878     cout<<"Creating the Huffman trees \n";
879   AliTPCHNode *node=0;
880   //  ULong_t code;
881   Double_t code;
882   UChar_t codeLen;
883   //loop over the numbero of tables
884   for(Int_t k=0;k<NumTables;k++){
885     RootNode[k]=new AliTPCHNode(); //RootNode is the root of the tree
886     Int_t dim;//this variable contains the table dimension
887     f.read((char*)(&dim),sizeof(Int_t));
888     if (fVerbose)
889       cout<<"Table dimension: "<<dim<<endl;
890     //loop over the words of a table
891     for(Int_t i=0;i<dim;i++){
892       f.read((char*)(&codeLen),sizeof(UChar_t));
893       //f.read((char*)(&code),sizeof(ULong_t));
894       f.read((char*)(&code),sizeof(Double_t));
895       node=RootNode[k];
896       for(Int_t j=1;j<=codeLen;j++){
897         ULong_t bit,val=0;
898         val=(ULong_t)TMath::Power(2,codeLen-j);
899         bit=(ULong_t)code&val; 
900         AliTPCHNode *temp=node;
901         if(bit){
902           node=node->GetRight();
903           if(!node){
904             node=new AliTPCHNode();
905             temp->SetRight(node);
906           }//end if
907         }//end if
908         else{
909           node=node->GetLeft();
910           if(!node){
911             node=new AliTPCHNode();
912             temp->SetLeft(node);
913           }//end if
914         }//end else
915       }//end for
916       if(codeLen){
917         node->SetSymbol(i);
918         node->SetFrequency(codeLen);
919       }//end if
920       //cout<<node->GetSymbol()<<"  "<<(Int_t)node->GetFrequency()<<endl;
921     }//end for 
922   }//end for 
923   if (fVerbose)
924     cout<<"Trees generated \n";
925   //At this point the trees are been built
926 }
927 //////////////////////////////////////////////////////////////////////////////////////////////////
928 void AliTPCCompression::CreateTreesFromFile(AliTPCHNode *RootNode[],const Int_t NumTables){
929   //For each table this method builds the associate Huffman tree starting from the codeword and 
930   //the codelength of each symbol 
931   if(fVerbose)
932     cout<<"Creating the Huffman trees \n";
933   AliTPCHNode *node=0;
934   // ULong_t code;
935   Double_t code;
936   UChar_t codeLen;
937   ifstream fTable;  
938   char filename[15];
939   //The following for loop is used to generate the Huffman trees acording to the tables
940   //loop over the tables
941   for(Int_t k=0;k<NumTables;k++){
942     RootNode[k]=new AliTPCHNode(); //RootNode is the root of the tree
943     Int_t dim=0;//this variable contains the table dimension
944     sprintf(filename,"Table%d.dat",k); 
945 #ifndef __DECCXX 
946     fTable.open(filename,ios::binary);
947 #else
948     fTable.open(filename);
949 #endif
950     fTable.read((char*)(&dim),sizeof(Int_t));
951     if (fVerbose)
952       cout<<"Table dimension: "<<dim<<endl;
953     //loop over the words of one table
954     for(Int_t i=0;i<dim;i++){
955       fTable.read((char*)(&codeLen),sizeof(UChar_t));
956       //fTable.read((char*)(&code),sizeof(ULong_t));
957       fTable.read((char*)(&code),sizeof(Double_t));
958       node=RootNode[k];
959       for(Int_t j=1;j<=codeLen;j++){
960         ULong_t bit,val=0;
961         val=(ULong_t)TMath::Power(2,codeLen-j);
962         bit=(ULong_t)code&val; 
963         AliTPCHNode *temp=node;
964         if(bit){
965           node=node->GetRight();
966           if(!node){
967             node=new AliTPCHNode();
968             temp->SetRight(node);
969           }//end if 
970         }//end if
971         else{
972           node=node->GetLeft();
973           if(!node){
974             node=new AliTPCHNode();
975             temp->SetLeft(node);
976           }//end if
977         }//end else
978       }//end for
979       if(codeLen){
980         node->SetSymbol(i);
981         node->SetFrequency(codeLen);
982       }//end if
983     }//end for 
984     fTable.close();
985   }//end for 
986   if (fVerbose)
987     cout<<"Trees generated \n";
988   //At this point the trees are been built
989 }
990 //////////////////////////////////////////////////////////////////////////////////////////////////
991 void AliTPCCompression::DeleteHuffmanTree(AliTPCHNode* node){
992   //This function deletes all the nodes of an Huffman tree
993   //In an Huffman tree any internal node has always two children 
994   if (node){
995     DeleteHuffmanTree(node->GetLeft());
996     DeleteHuffmanTree(node->GetRight());
997     //    cout<<node->GetSymbol()<<"  "<<(Int_t)node->GetFrequency()<<endl;
998     delete node;
999   }
1000 }
1001 //////////////////////////////////////////////////////////////////////////////////////////////////
1002 void AliTPCCompression::VisitHuffmanTree(AliTPCHNode* node){
1003   //This function realizes an in order visit of a binary tree 
1004   if (node){
1005     cout<<node->GetSymbol()<<" "<<node->GetFrequency()<<endl;
1006     VisitHuffmanTree(node->GetLeft());
1007     VisitHuffmanTree(node->GetRight());
1008   }
1009 }
1010 //////////////////////////////////////////////////////////////////////////////////////////////////
1011 ULong_t AliTPCCompression::ReadWord(Int_t NumberOfBit){
1012   //This method retrieves a word of a specific number of bits from the file through the internal buffer 
1013   ULong_t result=0;
1014   ULong_t bit=0;
1015   for (Int_t i=0;i<NumberOfBit;i++){
1016     if (fReadBits==32){
1017       fPos-=sizeof(ULong_t);
1018       f.seekg(fPos);
1019       f.read((char*)(&fBuffer),sizeof(ULong_t));
1020       fReadBits=0;
1021     }//end if
1022     ULong_t mask=0;
1023     mask=(ULong_t)TMath::Power(2,fReadBits);
1024     bit=fBuffer&mask;
1025     bit=bit>>fReadBits;
1026     fReadBits++;
1027     bit=bit<<i;
1028     result=result|bit;
1029   }//end for
1030   return result;
1031 }
1032 //////////////////////////////////////////////////////////////////////////////////////////////////
1033 void AliTPCCompression::ReadTrailer(Int_t &WordsNumber,Int_t &PadNumber,Int_t &RowNumber,Int_t &SecNumber){
1034   //It retrieves a trailer 
1035   ReadWord(1);
1036   SecNumber=ReadWord(9);
1037   RowNumber=ReadWord(10);
1038   PadNumber=ReadWord(10);
1039   WordsNumber=ReadWord(10);
1040   return;
1041 }
1042 //////////////////////////////////////////////////////////////////////////////////////////////////
1043 ULong_t AliTPCCompression::GetDecodedWord(AliTPCHNode* root){
1044   //This method retrieves a decoded word.
1045   AliTPCHNode *node=root;
1046   ULong_t symbol=0;
1047   Bool_t decoded=0;
1048   while(!decoded){
1049     ULong_t bit=ReadWord(1);
1050     if(bit)
1051       node=node->GetRight();
1052     else
1053       node=node->GetLeft();
1054     if (!(node->GetLeft())){
1055       symbol=node->GetSymbol();
1056       decoded=1;
1057     }
1058   }//end while
1059   return symbol;
1060 }
1061 //////////////////////////////////////////////////////////////////////////////////////////////////
1062 Int_t AliTPCCompression::DecompressData(Int_t NumTables,const char* fname,char* fDest){
1063   //Decompression method 
1064   cout<<"   DECOMPRESSION:"<<endl;
1065   cout<<"Source File "<<fname<<" Destination File "<<fDest<<endl;
1066 #ifndef __DECCXX 
1067   f.open(fname,ios::binary|ios::in);
1068 #else
1069   f.open(fname,ios::in);
1070 #endif
1071   if(!f){cout<<"File doesn't exist:"<<fname<<endl;;return -1;}
1072   AliTPCHNode ** rootNode = new AliTPCHNode*[NumTables];
1073   //Creation of the Huffman trees
1074   CreateTrees(rootNode,NumTables);
1075   //to go to the end of the file
1076   f.seekg(0,ios::end);
1077   //to get the file dimension in byte
1078   fPos=f.tellg();
1079   fPos-=sizeof(ULong_t);
1080   f.seekg(fPos);
1081   fReadBits=0;
1082   fBuffer=0;
1083   f.read((char*)(&fBuffer),sizeof(ULong_t));
1084   Int_t bit=0;
1085   ULong_t mask=0x1;
1086   while(!bit){
1087     bit=fBuffer&mask;
1088     mask=mask<<1;
1089     fReadBits++;
1090   }
1091   ULong_t packetNumber=ReadWord(sizeof(ULong_t)*8);
1092   cout<<"Number of Packect: "<<packetNumber<<endl;
1093   AliTPCBuffer160 bufferFile(fDest,1);
1094   ULong_t k=0;
1095   ULong_t wordsRead=0; //number of read coded words 
1096   while(k<packetNumber){
1097     Int_t numWords,padNumber,rowNumber,secNumber=0;
1098     ReadTrailer(numWords,padNumber,rowNumber,secNumber);
1099     k++;
1100     wordsRead+=4;
1101     Int_t previousTime=-1;
1102     Int_t time=0;
1103     Int_t nextTableType=0;
1104     Int_t bunchLen=0;
1105     Int_t count=0;
1106     for(Int_t i=0;i<numWords;i++){
1107       ULong_t symbol=GetDecodedWord(rootNode[nextTableType]);
1108       wordsRead++;
1109       //Time reconstruction
1110       if (nextTableType==1){
1111         if (previousTime!=-1){
1112           previousTime=symbol+previousTime+bunchLen;
1113         }
1114         else previousTime=symbol;
1115         time=previousTime;
1116       }
1117       if(nextTableType>1)
1118         bufferFile.FillBuffer(symbol);
1119       NextTable(symbol,nextTableType,bunchLen,count); 
1120       if(nextTableType==0){
1121         bufferFile.FillBuffer(time);
1122         bufferFile.FillBuffer(bunchLen+2);
1123         bunchLen=0;
1124       }
1125     }//end for
1126     bufferFile.WriteTrailer(numWords,padNumber,rowNumber,secNumber);
1127   }//end while
1128   cout<<"Number of decoded words:"<<wordsRead<<endl;
1129   f.close();
1130   //The trees are deleted 
1131   for(Int_t j=0;j<NumTables;j++){
1132       DeleteHuffmanTree(rootNode[j]);
1133   }//end for
1134   delete [] rootNode; 
1135   return 0; 
1136 }
1137
1138 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1139
1140 Int_t AliTPCCompression::DecompressDataOptTables(Int_t NumTables,const char* fname,char* fDest){
1141   //This method decompress a file using separate Huffman tables
1142   if(fVerbose){
1143     cout<<"   DECOMPRESSION:"<<endl;
1144     cout<<"Source File "<<fname<<" Destination File "<<fDest<<endl; 
1145   }
1146   AliTPCHNode ** rootNode = new AliTPCHNode*[NumTables];
1147   //Creation of the Huffman trees
1148   CreateTreesFromFile(rootNode,NumTables);
1149 #ifndef __DECCXX
1150   f.open(fname,ios::binary|ios::in);
1151 #else
1152   f.open(fname,ios::in);
1153 #endif
1154   if(!f){cout<<"File doesn't exist:"<<fname<<endl;;return -1;}
1155   //to go to the end of the file
1156   f.seekg(0,ios::end);
1157   //to get the file dimension in byte
1158   fPos=f.tellg();
1159   fPos-=sizeof(ULong_t);
1160   f.seekg(fPos);
1161   fReadBits=0;
1162   fBuffer=0;
1163   f.read((char*)(&fBuffer),sizeof(ULong_t));
1164   Int_t bit=0;
1165   ULong_t mask=0x1;
1166   while(!bit){
1167     bit=fBuffer&mask;
1168     mask=mask<<1;
1169     fReadBits++;
1170   }
1171   ULong_t packetNumber=ReadWord(sizeof(ULong_t)*8);
1172   if(fVerbose){
1173     cout<<"Number of Packect: "<<packetNumber<<endl;
1174   }
1175   AliTPCBuffer160 bufferFile(fDest,1);
1176   ULong_t k=0;
1177   ULong_t wordsRead=0; //number of read coded words 
1178   while(k<packetNumber){
1179     Int_t numWords,padNumber,rowNumber,secNumber=0;
1180     ReadTrailer(numWords,padNumber,rowNumber,secNumber);
1181     k++;
1182     wordsRead+=4;
1183     Int_t previousTime=-1;
1184     Int_t time=0;
1185     Int_t nextTableType=0;
1186     Int_t bunchLen=0;
1187     Int_t count=0;
1188     for(Int_t i=0;i<numWords;i++){
1189       ULong_t symbol=GetDecodedWord(rootNode[nextTableType]);
1190       wordsRead++;
1191       //Time reconstruction
1192       if (nextTableType==1){
1193         if (previousTime!=-1){
1194           previousTime=symbol+previousTime+bunchLen;
1195         }
1196         else previousTime=symbol;
1197         time=previousTime;
1198       }
1199       if(nextTableType>1)
1200         bufferFile.FillBuffer(symbol);
1201       NextTable(symbol,nextTableType,bunchLen,count); 
1202       if(nextTableType==0){
1203         bufferFile.FillBuffer(time);
1204         bufferFile.FillBuffer(bunchLen+2);
1205         bunchLen=0;
1206       }
1207     }//end for
1208     bufferFile.WriteTrailer(numWords,padNumber,rowNumber,secNumber);
1209   }//end while
1210   if(fVerbose){
1211     cout<<"Number of decoded words:"<<wordsRead<<endl;
1212   }
1213   f.close();
1214   //The trees are deleted 
1215   for(Int_t j=0;j<NumTables;j++){
1216       DeleteHuffmanTree(rootNode[j]);
1217   }//end for
1218   delete [] rootNode;
1219   return 0; 
1220 }
1221
1222 ///////////////////////////////////////////////////////////////////////////////////////////
1223
1224 void AliTPCCompression::ReadAltroFormat(char* fileOut,char* fileIn)const{
1225   //This method creates a text file containing the same information stored in 
1226   //an Altro file. The information in the text file is organized pad by pad and 
1227   //and for each pad it consists in a sequence of bunches (Bunch length +2,
1228   //Time bin of the last amplitude sample in the bunch, amplitude values)
1229   //It is used mainly for debugging
1230   ofstream ftxt(fileOut);
1231   AliTPCBuffer160 buff(fileIn,0);
1232   Int_t numWords,padNum,rowNum,secNum=0;
1233   Int_t value=0;
1234   if (fVerbose) cout<<"Creating a txt file from an Altro Format file"<<endl;
1235   while(buff.ReadTrailerBackward(numWords,padNum,rowNum,secNum) !=-1 ){
1236     ftxt<<"S:"<<secNum<<" R:"<<rowNum<<" P:"<<padNum<<" W:"<<numWords<<endl;
1237     if (numWords%4){
1238       for(Int_t j=0;j<(4-numWords%4);j++){
1239         value=buff.GetNextBackWord();
1240       }//end for
1241     }//end if
1242     for(Int_t i=0;i<numWords;i++){
1243       value=buff.GetNextBackWord();
1244       ftxt<<value<<endl;
1245     }//end for
1246   }//end while
1247   ftxt.close();
1248   return;
1249 }
1250
1251 //////////////////////////////////////////////////////////////////////////////////////////