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