get tables from the aliroot directory if they are not in the current one
[u/mrichter/AliRoot.git] / RAW / AliTPCCompression.cxx
index 789af8d2c5816981f6bde540be00e85e9c166f2b..d00703575cea5ddc874f8f5afab996267503603d 100644 (file)
@@ -26,6 +26,7 @@
 #include <TObjArray.h>
 #include <Riostream.h>
 #include <TMath.h>
+#include <TSystem.h>
 #include "AliTPCBuffer160.h"
 #include "AliTPCHuffman.h"
 #include "AliTPCCompression.h"
@@ -125,7 +126,7 @@ void AliTPCCompression::NextTable(Int_t Val,Int_t &NextTableType,Int_t &BunchLen
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////
 
-Int_t AliTPCCompression::FillTables(const char* fSource,AliTPCHTable* table[],const Int_t /*NumTables*/){
+Int_t AliTPCCompression::FillTables(const char* fSource,AliTPCHTable* table[],Int_t /*NumTables*/){
   //This method is used to compute the frequencies of the symbols in the source file
   AliTPCBuffer160 buff(fSource,0);
   UInt_t countWords=0;
@@ -261,7 +262,7 @@ Int_t AliTPCCompression::StoreTables(AliTPCHTable* table[],const Int_t NumTable)
   return 0;
 }
 ////////////////////////////////////////////////////////////////////////////////////////
-Int_t AliTPCCompression::CreateTableFormula(Double_t beta,UInt_t  M,Int_t dim,Int_t Type){
+Int_t AliTPCCompression::CreateTableFormula(Double_t beta,UInt_t M,Int_t dim,Int_t Type){
   // Type = 0 for Bunch length
   // Type = 1 for Time Gap
   UInt_t freq;
@@ -325,7 +326,7 @@ Int_t AliTPCCompression::CreateTableFormula(Double_t beta,UInt_t  M,Int_t dim,In
   return 0;
 }
 ////////////////////////////////////////////////////////////////////////////////////////
-Int_t AliTPCCompression::CreateTables(const char* fSource,const Int_t NumTables){
+Int_t AliTPCCompression::CreateTables(const char* fSource,Int_t NumTables){
   //Tables manager
   /*
     Table index:
@@ -436,7 +437,7 @@ Int_t AliTPCCompression::RetrieveTables(AliTPCHTable* table[],Int_t NumTable){
   Double_t code;
   UChar_t codeLen;
   ifstream fTable;  
-  char filename[15];
+  char filename[256];
   //The following for loop is used to generate the Huffman trees acording to the tables
   for(Int_t k=0;k<NumTable;k++){
     Int_t dim;//this variable contains the table dimension
@@ -446,7 +447,19 @@ Int_t AliTPCCompression::RetrieveTables(AliTPCHTable* table[],Int_t NumTable){
 #else
     fTable.open(filename);
 #endif
-    if(!fTable){cout<<"File doesn't exist:"<<filename<<endl; exit(1);}
+    if(!fTable && gSystem->Getenv("ALICE_ROOT")){
+      fTable.clear();
+      sprintf(filename,"%s/RAW/Table%d.dat",gSystem->Getenv("ALICE_ROOT"),k); 
+#ifndef __DECCXX 
+      fTable.open(filename,ios::binary);
+#else
+      fTable.open(filename);
+#endif
+    }
+    if(!fTable){
+      Error("RetrieveTables", "File doesn't exist: %s", filename);
+      return 1;
+    }
     fTable.read((char*)(&dim),sizeof(Int_t));
     if (fVerbose)
       cout<<"Table dimension: "<<dim<<endl;
@@ -480,7 +493,10 @@ Int_t AliTPCCompression::CreateTablesFromTxtFiles(Int_t NumTable){
     sprintf(filename,"Table%d.txt",k); 
     cout<<filename<<endl;
     fTable.open(filename);
-    if(!fTable){cout<<"File doesn't exist: "<<filename<<endl; exit(1);}
+    if(!fTable){
+      Error("CreateTablesFromTxtFiles", "File doesn't exist: %s", filename);
+      return 1;
+    }
     Int_t symbol=0;
     Double_t freq=0;
     table[k]=new AliTPCHTable(1024);
@@ -584,8 +600,14 @@ Int_t AliTPCCompression::CompressDataOptTables(Int_t NumTable,const char* fSourc
   }
   //Tables are read from the files (Each codeword has been "Mirrored")
   AliTPCHTable **table = new AliTPCHTable*[NumTable];
-  RetrieveTables(table,NumTable);
+  for(Int_t i=0;i<NumTable;i++) table[i] = NULL;
+  if (RetrieveTables(table,NumTable) != 0) {
+    for(Int_t i=0;i<NumTable;i++) delete table[i];
+    delete [] table;
+    return 1;
+  }
   //the output file is open
+  f.clear();
 #ifndef __DECCXX 
   f.open(fDest,ios::binary|ios::out);
 #else
@@ -602,6 +624,7 @@ Int_t AliTPCCompression::CompressDataOptTables(Int_t NumTable,const char* fSourc
   UInt_t  trailerNumbers=0;
   Double_t numElem[5]={0,0,0,0,0};
   Double_t fillWords=0.;
+  fStat.clear();
   fStat.open("Statistics",ios::app);
   fStat<<endl;
   fStat<<"-------------------COMPRESSION STATISTICS----------"<<endl;
@@ -760,7 +783,7 @@ Int_t AliTPCCompression::CompressDataOptTables(Int_t NumTable,const char* fSourc
 /*                               DECOMPRESSION                                        */
 ////////////////////////////////////////////////////////////////////////////////////////
 
-void AliTPCCompression::CreateTreesFromFile(AliTPCHNode *RootNode[],const Int_t NumTables){
+Int_t AliTPCCompression::CreateTreesFromFile(AliTPCHNode *RootNode[],Int_t NumTables){
   //For each table this method builds the associate Huffman tree starting from the codeword and 
   //the codelength of each symbol 
   if(fVerbose)
@@ -782,7 +805,19 @@ void AliTPCCompression::CreateTreesFromFile(AliTPCHNode *RootNode[],const Int_t
 #else
     fTable.open(filename);
 #endif
-    if(!fTable){cout<<"Tables don't exist !!!"<<endl;exit(1);}
+    if(!fTable && gSystem->Getenv("ALICE_ROOT")){
+      fTable.clear();
+      sprintf(filename,"%s/RAW/Table%d.dat",gSystem->Getenv("ALICE_ROOT"),k); 
+#ifndef __DECCXX 
+      fTable.open(filename,ios::binary);
+#else
+      fTable.open(filename);
+#endif
+    }
+    if(!fTable){
+      Error("CreateTreesFromFile", "File doesn't exist: %s", filename);
+      return 1;
+    }
     fTable.read((char*)(&dim),sizeof(Int_t));
     if (fVerbose)
       cout<<"Table dimension: "<<dim<<endl;
@@ -822,6 +857,7 @@ void AliTPCCompression::CreateTreesFromFile(AliTPCHNode *RootNode[],const Int_t
   if (fVerbose)
     cout<<"Trees generated \n";
   //At this point the trees are been built
+  return 0;
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////
 void AliTPCCompression::DeleteHuffmanTree(AliTPCHNode* node){
@@ -939,21 +975,32 @@ UInt_t AliTPCCompression::GetDecodedWord(AliTPCHNode* root,Bool_t Memory){
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-Int_t AliTPCCompression::DecompressDataOptTables(Int_t NumTables,const char* fname,char* fDest){
+Int_t AliTPCCompression::DecompressDataOptTables(Int_t NumTables,const char* fname, const char* fDest){
   //This method decompress a file using separate Huffman tables
   if(fVerbose){
     cout<<"   DECOMPRESSION:"<<endl;
     cout<<"Source File "<<fname<<" Destination File "<<fDest<<endl; 
   }
   AliTPCHNode ** rootNode = new AliTPCHNode*[NumTables];
+  for(Int_t i=0;i<NumTables;i++) rootNode[i] = NULL;
   //Creation of the Huffman trees
-  CreateTreesFromFile(rootNode,NumTables);
+  if (CreateTreesFromFile(rootNode,NumTables) != 0) {
+    for(Int_t i=0;i<NumTables;i++) {
+      if (rootNode[i]) DeleteHuffmanTree(rootNode[i]);
+    }
+    delete [] rootNode;
+    return 1;
+  }
+  f.clear();
 #ifndef __DECCXX
   f.open(fname,ios::binary|ios::in);
 #else
   f.open(fname,ios::in);
 #endif
-  if(!f){cout<<"File doesn't exist:"<<fname<<endl;;return -1;}
+  if(!f){
+    Error("DecompressDataOptTables", "File doesn't exist:",fname);
+    return -1;
+  }
   //to go to the end of the file
   f.seekg(0,ios::end);
   //to get the file dimension in byte
@@ -1022,7 +1069,7 @@ Int_t AliTPCCompression::DecompressDataOptTables(Int_t NumTables,const char* fna
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
-Int_t AliTPCCompression::Decompress(AliTPCHNode *RootNode[],const Int_t /*NumTables*/,char* PointBuffer,UInt_t BufferSize,UShort_t out[],UInt_t &dim){
+Int_t AliTPCCompression::Decompress(AliTPCHNode *RootNode[],Int_t /*NumTables*/,char* PointBuffer,UInt_t BufferSize,UShort_t out[],UInt_t &dim){
   //This method decompress a file using separate Huffman tables
 
   fPointBuffer=PointBuffer+BufferSize-4;
@@ -1109,7 +1156,7 @@ Int_t AliTPCCompression::Decompress(AliTPCHNode *RootNode[],const Int_t /*NumTab
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
-Int_t AliTPCCompression::DestroyTables(AliTPCHNode *RootNode[],const Int_t NumTables){
+Int_t AliTPCCompression::DestroyTables(AliTPCHNode *RootNode[],Int_t NumTables){
   //The trees are deleted
   for(Int_t j=0;j<NumTables;j++){
     DeleteHuffmanTree(RootNode[j]);