[u/mrichter/AliRoot.git] / TPC / AliTPCDDLRawData.cxx

/**************************************************************************
 * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
/* $Id$ */


//This class conteins all the methods to create raw data 
//as par a given DDL.
//It produces DDL with both compressed and uncompressed format.
//For compression we use the optimized table wich needs 
//to be provided.

#include <TObjArray.h>
#include <Riostream.h>
#include <stdio.h>
#include <stdlib.h>
#include "AliTPCCompression.h"
#include "AliTPCBuffer160.h"
#include "AliTPCDDLRawData.h"

ClassImp(AliTPCDDLRawData)
////////////////////////////////////////////////////////////////////////////////////////

AliTPCDDLRawData::AliTPCDDLRawData(const AliTPCDDLRawData &source):
  TObject(source)
{
  // Copy Constructor
  fVerbose=source.fVerbose;
  return;
}

AliTPCDDLRawData& AliTPCDDLRawData::operator=(const AliTPCDDLRawData &source){
  //Assigment operator
  fVerbose=source.fVerbose;
  return *this;
}


////////////////////////////////////////////////////////////////////////////
void AliTPCDDLRawData::RawData(Int_t LDCsNumber,Int_t EventNumber){
  //Raw data slides generation
  //Number of DDL=2*36+4*36=216
  //2 DDL for each inner sector
  //4 DDL for each outer sector
  Int_t ddlPerFile=216/LDCsNumber;
  Int_t offset=1;
  if (216%LDCsNumber) ddlPerFile++;
  cout<<"Number of DDL per slide: "<<ddlPerFile<<endl;
  ifstream f;
#ifndef __DECCXX
  f.open("AliTPCDDL.dat",ios::binary);
#else
  f.open("AliTPCDDL.dat");
#endif
  if(!f){cout<<"File doesn't exist !!"<<endl;return;}
  struct DataPad{
    Int_t Sec;
    Int_t SubSec;
    Int_t Row;
    Int_t Pad;
    Int_t Dig;
    Int_t Time;
  };
  DataPad data;

  //AliTPCBuffer160 is used in write mode to generate AltroFormat.dat file
  Int_t sliceNumber=1;
  char  filename[15];
  sprintf(filename,"Ev%dTPCslice%d",EventNumber,sliceNumber); 
  cout<<"   Creating "<<filename<<endl;
  AliTPCBuffer160 *buffer=new AliTPCBuffer160(filename,1);

  UInt_t count=0;
  Int_t pSecNumber=-1;  //Previous Sector number
  Int_t pRowNumber=-1;  //Previous Row number  
  Int_t pPadNumber=-1;  //Previous Pad number
  Int_t pTimeBin=-1;    //Previous Time-Bin
  Int_t pSubSector=-1;  //Previous Sub Sector
  Int_t bunchLength=0;
  Int_t countDDL=0;
  Int_t nwords=0;
  UInt_t numPackets=0;
  while (f.read((char*)(&data),sizeof(data))){
    count++;
    if (pPadNumber==-1){
      pSecNumber=data.Sec;
      pRowNumber=data.Row;
      pPadNumber=data.Pad;
      pTimeBin=data.Time;
      pSubSector=data.SubSec;
      //size magic word sector number sub-sector number 0 for TPC 0 for uncompressed
      buffer->WriteMiniHeader(0,pSecNumber,pSubSector,0,0);//Dummy;
      bunchLength=1;
      buffer->FillBuffer(data.Dig-offset);
      nwords++;
    }//end if
    else{
      if ( (data.Time==(pTimeBin+1)) &&
	   (pPadNumber==data.Pad) &&
	   (pRowNumber==data.Row) &&
	   (pSecNumber==data.Sec)){
	bunchLength++;
      }//end if
      else{
	buffer->FillBuffer(pTimeBin);
	buffer->FillBuffer(bunchLength+2);
	nwords+=2;
	if ((pPadNumber!=data.Pad)||(pRowNumber!=data.Row)||(pSecNumber!=data.Sec)){
	  //Trailer is formatted and inserted!!
	  buffer->WriteTrailer(nwords,pPadNumber,pRowNumber,pSecNumber);
	  numPackets++;
	  nwords=0;

	  if(pSubSector!=data.SubSec){
	    countDDL++;
	    if(countDDL==ddlPerFile){
	      //size magic word sector number sub-sector number 0 for TPC 0 for uncompressed
	      buffer->Flush();
	      buffer->WriteMiniHeader(1,pSecNumber,pSubSector,0,0);
	      //cout<<"Mini header for DDL:"<<PSecNumber<<" Sub-sec:"<<PSubSector<<endl;
	      delete buffer;
	      sliceNumber++;
	      sprintf(filename,"Ev%dTPCslice%d",EventNumber,sliceNumber);
	      cout<<"   Creating "<<filename<<endl;
	      buffer=new AliTPCBuffer160(filename,1);
	      buffer->WriteMiniHeader(0,data.Sec,data.SubSec,0,0);//Dummy;
	      countDDL=0;
	    }//end if
	    else{
	      buffer->Flush();
	      buffer->WriteMiniHeader(1,pSecNumber,pSubSector,0,0);
	      buffer->WriteMiniHeader(0,data.Sec,data.SubSec,0,0);//Dummy;
	    }
	    pSubSector=data.SubSec;
	  }//end if
	}//end if
	
	bunchLength=1;
	pPadNumber=data.Pad;
	pRowNumber=data.Row;
	pSecNumber=data.Sec;
      }//end else
      pTimeBin=data.Time;
      buffer->FillBuffer(data.Dig-offset);
      nwords++;
    }//end else
  }//end while
  buffer->FillBuffer(pTimeBin);
  buffer->FillBuffer(bunchLength+2);
  nwords+=2;
  buffer->WriteTrailer(nwords,pPadNumber,pRowNumber,pSecNumber);
  //write the  M.H.
  buffer->Flush();
  buffer->WriteMiniHeader(1,pSecNumber,pSubSector,0,0);
  //cout<<"Mini header for D D L:"<<pSecNumber<<" Sub-sec:"<<pSubSector<<endl;
  delete buffer;
  cout<<"Number of digits: "<<count<<endl;
  f.close();
  return;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////


Int_t AliTPCDDLRawData::RawDataCompDecompress(Int_t LDCsNumber,Int_t EventNumber,Int_t Comp){
  //This method is used to compress and decompress the slides
  static const Int_t kNumTables=5;
  char filename[20];
  char dest[20];
  fstream f;
  UInt_t size=0;
  //Int_t MagicWord,DDLNumber,SecNumber,SubSector,Detector;
  Int_t flag=0;
  for(Int_t i=1;i<=LDCsNumber;i++){
    if(!Comp){
      sprintf(filename,"Ev%dTPCslice%d",EventNumber,i);
      sprintf(dest,"Ev%dTPCslice%d.comp",EventNumber,i);
    }
    else{
      sprintf(filename,"Ev%dTPCslice%d.comp",EventNumber,i);
      sprintf(dest,"Ev%dTPCslice%d.decomp",EventNumber,i);
    }
#ifndef __DECCXX
    f.open(filename,ios::binary|ios::in);
#else
    f.open(filename,ios::in);
#endif
    if(!f){cout<<"BE CAREFUL!! There isn't enough data to generate "<<LDCsNumber<<" slices"<<endl;break;}
    if (fVerbose)
      cout<<filename<<"  "<<dest<<endl;
    ofstream fdest;
#ifndef __DECCXX
    fdest.open(dest,ios::binary);
#else
    fdest.open(dest);
#endif
    //loop over the DDL block 
    //Each block contains a Mini Header followed by raw data (ALTRO FORMAT)
    //The number of block is ceil(216/LDCsNumber)
    UInt_t miniHeader[3];
    //here the Mini Header is read
    while( (f.read((char*)(miniHeader),sizeof(UInt_t)*3)) ){
      size=miniHeader[0];
      // cout<<"Data size:"<<size<<endl;
      //Int_t dim=sizeof(UInt_t)+sizeof(Int_t)*5;
      //cout<<" Sec "<<SecNumber<<" SubSector "<<SubSector<<" size "<<size<<endl;
      //open the temporay File
      ofstream fo;
      char temp[15]="TempFile";
#ifndef __DECCXX
      fo.open(temp,ios::binary);
#else
      fo.open(temp);
#endif
      Int_t car=0;
      for(UInt_t j=0;j<size;j++){
	f.read((char*)(&car),1);
	fo.write((char*)(&car),1);
      }//end for
      fo.close();
      //The temp file is compressed or decompressed
      AliTPCCompression *util = new AliTPCCompression();
      util->SetVerbose(0);
      if(!Comp){
	util->CompressDataOptTables(kNumTables,temp,"TempCompDecomp");
      }
      else
	util->DecompressDataOptTables(kNumTables,temp,"TempCompDecomp");
      delete util;
      //the temp compressed file is open and copied to the final file fdest
      ifstream fi;
#ifndef __DECCXX
      fi.open("TempCompDecomp",ios::binary);
#else
      fi.open("TempCompDecomp");
#endif
      fi.seekg(0,ios::end);
      size=fi.tellg();
      fi.seekg(0);
      //The Mini Header is updated (size and Compressed flag) 
      //and written into the output file
      miniHeader[0]=size;
      if(!Comp)
	flag=1;
      else
	flag=0;
      UInt_t aux=0x0;
      flag<<=8;
      aux|=flag;
      miniHeader[2]=miniHeader[2]|aux;
      fdest.write((char*)(miniHeader),sizeof(UInt_t)*3);
      //The compressem temp file is copied into the output file fdest
      for(UInt_t j=0;j<size;j++){
	fi.read((char*)(&car),1);
	fdest.write((char*)(&car),1);
      }//end for
      fi.close();
    }//end while
    f.clear();
    f.close();
    fdest.close();
    remove("TempFile");
    remove("TempCompDecomp");
  }//end for
  return 0;
}

/////////////////////////////////////////////////////////////////////////////////
void AliTPCDDLRawData::RawDataAltro()const{
  //This method is used to build the Altro format from AliTPCDDL.dat
  //It is used to debug the code and creates the tables used in the compresseion phase
  Int_t offset=1;
  ifstream f;
#ifndef __DECCXX
  f.open("AliTPCDDL.dat",ios::binary);
#else
  f.open("AliTPCDDL.dat");
#endif
  if(!f){cout<<"File doesn't exist !!"<<endl;return;}
  struct DataPad{
    Int_t Sec;
    Int_t SubSec;
    Int_t Row;
    Int_t Pad;
    Int_t Dig;
    Int_t Time;
  };
  DataPad data;

  //AliTPCBuffer160 is used in write mode to generate AltroFormat.dat file
  char  filename[30]="AltroFormatDDL.dat";
  cout<<"   Creating "<<filename<<endl;
  AliTPCBuffer160 *buffer=new AliTPCBuffer160(filename,1);

  UInt_t count=0;
  Int_t pSecNumber=-1;  //Previous Sector number
  Int_t pRowNumber=-1;  //Previous Row number  
  Int_t pPadNumber=-1;  //Previous Pad number
  Int_t pTimeBin=-1;    //Previous Time-Bin
  Int_t bunchLength=0;
  Int_t nwords=0;
  UInt_t numPackets=0;
  while (f.read((char*)(&data),sizeof(data))){
    count++;
    if (pPadNumber==-1){
      pSecNumber=data.Sec;
      pRowNumber=data.Row;
      pPadNumber=data.Pad;
      pTimeBin=data.Time;
      bunchLength=1;
      buffer->FillBuffer(data.Dig-offset);
      nwords++;
    }//end if
    else{
      if ( (data.Time==(pTimeBin+1)) &&
	   (pPadNumber==data.Pad) &&
	   (pRowNumber==data.Row) &&
	   (pSecNumber==data.Sec)){
	bunchLength++;
      }//end if
      else{
	buffer->FillBuffer(pTimeBin);
	buffer->FillBuffer(bunchLength+2);
	nwords+=2;
	if ((pPadNumber!=data.Pad)||(pRowNumber!=data.Row)||(pSecNumber!=data.Sec)){
	  //Trailer is formatted and inserted!!
	  buffer->WriteTrailer(nwords,pPadNumber,pRowNumber,pSecNumber);
	  numPackets++;
	  nwords=0;
	}//end if
	
	bunchLength=1;
	pPadNumber=data.Pad;
	pRowNumber=data.Row;
	pSecNumber=data.Sec;
      }//end else
      pTimeBin=data.Time;
      buffer->FillBuffer(data.Dig-offset);
      nwords++;
    }//end else
  }//end while
  buffer->FillBuffer(pTimeBin);
  buffer->FillBuffer(bunchLength+2);
  nwords+=2;
  buffer->WriteTrailer(nwords,pPadNumber,pRowNumber,pSecNumber);
  delete buffer;
  cout<<"Number of digits: "<<count<<endl;
  f.close(); 
  return;
}

/////////////////////////////////////////////////////////////////////////
void AliTPCDDLRawData::RawDataAltroDecode(Int_t LDCsNumber,Int_t EventNumber,Int_t Comp){
  //This method merges the slides in only one file removing at the same 
  //time all the mini headers. The file so obtained must be Altro format
  //complaiant.
  //It is used mainly in the debugging phase 
  char filename[15];
  char dest[30];
  fstream f;
  if(!Comp)
    sprintf(dest,"AltroDDLRecomposed.dat");
  else
    sprintf(dest,"AltroDDLRecomposedDec.dat");
  ofstream fdest;

#ifndef __DECCXX
  fdest.open(dest,ios::binary);
#else
  fdest.open(dest);
#endif
  UInt_t size=0;
  //Int_t MagicWord,DDLNumber,SecNumber,SubSector,Detector,flag=0;
  for(Int_t i=1;i<=LDCsNumber;i++){
    if(!Comp){
      sprintf(filename,"Ev%dTPCslice%d",EventNumber,i);  
    }
    else{
      sprintf(filename,"Ev%dTPCslice%d.decomp",EventNumber,i);  
    }
#ifndef __DECCXX
    f.open(filename,ios::binary|ios::in);
#else
    f.open(filename,ios::in);
#endif
    if(!f){cout<<"BE CAREFUL!! There isn't enough data to generate "<<LDCsNumber<<" slices"<<endl;break;}
    //loop over the DDL block 
    //Each block contains a Mini Header followed by raw data (ALTRO FORMAT)
    //The number of block is ceil(216/LDCsNumber)
    UInt_t miniHeader[3];
    //here the Mini Header is read
    //cout<<filename<<endl;
    while( (f.read((char*)(miniHeader),sizeof(UInt_t)*3)) ){
      Int_t car=0;
      size=miniHeader[0];
      for(UInt_t j=0;j<size;j++){
	f.read((char*)(&car),1);
	fdest.write((char*)(&car),1);
      }//end for
    }//end while
    f.clear();
    f.close();
  }//end for
  fdest.close();
  return;
}
Commit	Line	Data
	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
	18	//This class conteins all the methods to create raw data
	19	//as par a given DDL.
	20	//It produces DDL with both compressed and uncompressed format.
	21	//For compression we use the optimized table wich needs
	22	//to be provided.
	23
	24	#include <TObjArray.h>
	25	#include <Riostream.h>
	26	#include <stdio.h>
	27	#include <stdlib.h>
	28	#include "AliTPCCompression.h"
	29	#include "AliTPCBuffer160.h"
	30	#include "AliTPCDDLRawData.h"
	31
	32	ClassImp(AliTPCDDLRawData)
	33	////////////////////////////////////////////////////////////////////////////////////////
	34
	35	AliTPCDDLRawData::AliTPCDDLRawData(const AliTPCDDLRawData &source):
	36	TObject(source)
	37	{
	38	// Copy Constructor
	39	fVerbose=source.fVerbose;
	40	return;
	41	}
	42
	43	AliTPCDDLRawData& AliTPCDDLRawData::operator=(const AliTPCDDLRawData &source){
	44	//Assigment operator
	45	fVerbose=source.fVerbose;
	46	return *this;
	47	}
	48
	49
	50	////////////////////////////////////////////////////////////////////////////
	51	void AliTPCDDLRawData::RawData(Int_t LDCsNumber,Int_t EventNumber){
	52	//Raw data slides generation
	53	//Number of DDL=236+436=216
	54	//2 DDL for each inner sector
	55	//4 DDL for each outer sector
	56	Int_t ddlPerFile=216/LDCsNumber;
	57	Int_t offset=1;
	58	if (216%LDCsNumber) ddlPerFile++;
	59	cout<<"Number of DDL per slide: "<<ddlPerFile<<endl;
	60	ifstream f;
	61	#ifndef __DECCXX
	62	f.open("AliTPCDDL.dat",ios::binary);
	63	#else
	64	f.open("AliTPCDDL.dat");
	65	#endif
	66	if(!f){cout<<"File doesn't exist !!"<<endl;return;}
	67	struct DataPad{
	68	Int_t Sec;
	69	Int_t SubSec;
	70	Int_t Row;
	71	Int_t Pad;
	72	Int_t Dig;
	73	Int_t Time;
	74	};
	75	DataPad data;
	76
	77	//AliTPCBuffer160 is used in write mode to generate AltroFormat.dat file
	78	Int_t sliceNumber=1;
	79	char filename[15];
	80	sprintf(filename,"Ev%dTPCslice%d",EventNumber,sliceNumber);
	81	cout<<" Creating "<<filename<<endl;
	82	AliTPCBuffer160 *buffer=new AliTPCBuffer160(filename,1);
	83
	84	UInt_t count=0;
	85	Int_t pSecNumber=-1; //Previous Sector number
	86	Int_t pRowNumber=-1; //Previous Row number
	87	Int_t pPadNumber=-1; //Previous Pad number
	88	Int_t pTimeBin=-1; //Previous Time-Bin
	89	Int_t pSubSector=-1; //Previous Sub Sector
	90	Int_t bunchLength=0;
	91	Int_t countDDL=0;
	92	Int_t nwords=0;
	93	UInt_t numPackets=0;
	94	while (f.read((char*)(&data),sizeof(data))){
	95	count++;
	96	if (pPadNumber==-1){
	97	pSecNumber=data.Sec;
	98	pRowNumber=data.Row;
	99	pPadNumber=data.Pad;
	100	pTimeBin=data.Time;
	101	pSubSector=data.SubSec;
	102	//size magic word sector number sub-sector number 0 for TPC 0 for uncompressed
	103	buffer->WriteMiniHeader(0,pSecNumber,pSubSector,0,0);//Dummy;
	104	bunchLength=1;
	105	buffer->FillBuffer(data.Dig-offset);
	106	nwords++;
	107	}//end if
	108	else{
	109	if ( (data.Time==(pTimeBin+1)) &&
	110	(pPadNumber==data.Pad) &&
	111	(pRowNumber==data.Row) &&
	112	(pSecNumber==data.Sec)){
	113	bunchLength++;
	114	}//end if
	115	else{
	116	buffer->FillBuffer(pTimeBin);
	117	buffer->FillBuffer(bunchLength+2);
	118	nwords+=2;
	119	if ((pPadNumber!=data.Pad)\|\|(pRowNumber!=data.Row)\|\|(pSecNumber!=data.Sec)){
	120	//Trailer is formatted and inserted!!
	121	buffer->WriteTrailer(nwords,pPadNumber,pRowNumber,pSecNumber);
	122	numPackets++;
	123	nwords=0;
	124
	125	if(pSubSector!=data.SubSec){
	126	countDDL++;
	127	if(countDDL==ddlPerFile){
	128	//size magic word sector number sub-sector number 0 for TPC 0 for uncompressed
	129	buffer->Flush();
	130	buffer->WriteMiniHeader(1,pSecNumber,pSubSector,0,0);
	131	//cout<<"Mini header for DDL:"<<PSecNumber<<" Sub-sec:"<<PSubSector<<endl;
	132	delete buffer;
	133	sliceNumber++;
	134	sprintf(filename,"Ev%dTPCslice%d",EventNumber,sliceNumber);
	135	cout<<" Creating "<<filename<<endl;
	136	buffer=new AliTPCBuffer160(filename,1);
	137	buffer->WriteMiniHeader(0,data.Sec,data.SubSec,0,0);//Dummy;
	138	countDDL=0;
	139	}//end if
	140	else{
	141	buffer->Flush();
	142	buffer->WriteMiniHeader(1,pSecNumber,pSubSector,0,0);
	143	buffer->WriteMiniHeader(0,data.Sec,data.SubSec,0,0);//Dummy;
	144	}
	145	pSubSector=data.SubSec;
	146	}//end if
	147	}//end if
	148
	149	bunchLength=1;
	150	pPadNumber=data.Pad;
	151	pRowNumber=data.Row;
	152	pSecNumber=data.Sec;
	153	}//end else
	154	pTimeBin=data.Time;
	155	buffer->FillBuffer(data.Dig-offset);
	156	nwords++;
	157	}//end else
	158	}//end while
	159	buffer->FillBuffer(pTimeBin);
	160	buffer->FillBuffer(bunchLength+2);
	161	nwords+=2;
	162	buffer->WriteTrailer(nwords,pPadNumber,pRowNumber,pSecNumber);
	163	//write the M.H.
	164	buffer->Flush();
	165	buffer->WriteMiniHeader(1,pSecNumber,pSubSector,0,0);
	166	//cout<<"Mini header for D D L:"<<pSecNumber<<" Sub-sec:"<<pSubSector<<endl;
	167	delete buffer;
	168	cout<<"Number of digits: "<<count<<endl;
	169	f.close();
	170	return;
	171	}
	172	////////////////////////////////////////////////////////////////////////////
	173	////////////////////////////////////////////////////////////////////////////
	174
	175
	176	Int_t AliTPCDDLRawData::RawDataCompDecompress(Int_t LDCsNumber,Int_t EventNumber,Int_t Comp){
	177	//This method is used to compress and decompress the slides
	178	static const Int_t kNumTables=5;
	179	char filename[20];
	180	char dest[20];
	181	fstream f;
	182	UInt_t size=0;
	183	//Int_t MagicWord,DDLNumber,SecNumber,SubSector,Detector;
	184	Int_t flag=0;
	185	for(Int_t i=1;i<=LDCsNumber;i++){
	186	if(!Comp){
	187	sprintf(filename,"Ev%dTPCslice%d",EventNumber,i);
	188	sprintf(dest,"Ev%dTPCslice%d.comp",EventNumber,i);
	189	}
	190	else{
	191	sprintf(filename,"Ev%dTPCslice%d.comp",EventNumber,i);
	192	sprintf(dest,"Ev%dTPCslice%d.decomp",EventNumber,i);
	193	}
	194	#ifndef __DECCXX
	195	f.open(filename,ios::binary\|ios::in);
	196	#else
	197	f.open(filename,ios::in);
	198	#endif
	199	if(!f){cout<<"BE CAREFUL!! There isn't enough data to generate "<<LDCsNumber<<" slices"<<endl;break;}
	200	if (fVerbose)
	201	cout<<filename<<" "<<dest<<endl;
	202	ofstream fdest;
	203	#ifndef __DECCXX
	204	fdest.open(dest,ios::binary);
	205	#else
	206	fdest.open(dest);
	207	#endif
	208	//loop over the DDL block
	209	//Each block contains a Mini Header followed by raw data (ALTRO FORMAT)
	210	//The number of block is ceil(216/LDCsNumber)
	211	UInt_t miniHeader[3];
	212	//here the Mini Header is read
	213	while( (f.read((char)(miniHeader),sizeof(UInt_t)3)) ){
	214	size=miniHeader[0];
	215	// cout<<"Data size:"<<size<<endl;
	216	//Int_t dim=sizeof(UInt_t)+sizeof(Int_t)*5;
	217	//cout<<" Sec "<<SecNumber<<" SubSector "<<SubSector<<" size "<<size<<endl;
	218	//open the temporay File
	219	ofstream fo;
	220	char temp[15]="TempFile";
	221	#ifndef __DECCXX
	222	fo.open(temp,ios::binary);
	223	#else
	224	fo.open(temp);
	225	#endif
	226	Int_t car=0;
	227	for(UInt_t j=0;j<size;j++){
	228	f.read((char*)(&car),1);
	229	fo.write((char*)(&car),1);
	230	}//end for
	231	fo.close();
	232	//The temp file is compressed or decompressed
	233	AliTPCCompression *util = new AliTPCCompression();
	234	util->SetVerbose(0);
	235	if(!Comp){
	236	util->CompressDataOptTables(kNumTables,temp,"TempCompDecomp");
	237	}
	238	else
	239	util->DecompressDataOptTables(kNumTables,temp,"TempCompDecomp");
	240	delete util;
	241	//the temp compressed file is open and copied to the final file fdest
	242	ifstream fi;
	243	#ifndef __DECCXX
	244	fi.open("TempCompDecomp",ios::binary);
	245	#else
	246	fi.open("TempCompDecomp");
	247	#endif
	248	fi.seekg(0,ios::end);
	249	size=fi.tellg();
	250	fi.seekg(0);
	251	//The Mini Header is updated (size and Compressed flag)
	252	//and written into the output file
	253	miniHeader[0]=size;
	254	if(!Comp)
	255	flag=1;
	256	else
	257	flag=0;
	258	UInt_t aux=0x0;
	259	flag<<=8;
	260	aux\|=flag;
	261	miniHeader[2]=miniHeader[2]\|aux;
	262	fdest.write((char)(miniHeader),sizeof(UInt_t)3);
	263	//The compressem temp file is copied into the output file fdest
	264	for(UInt_t j=0;j<size;j++){
	265	fi.read((char*)(&car),1);
	266	fdest.write((char*)(&car),1);
	267	}//end for
	268	fi.close();
	269	}//end while
	270	f.clear();
	271	f.close();
	272	fdest.close();
	273	remove("TempFile");
	274	remove("TempCompDecomp");
	275	}//end for
	276	return 0;
	277	}
	278
	279	/////////////////////////////////////////////////////////////////////////////////
	280	void AliTPCDDLRawData::RawDataAltro()const{
	281	//This method is used to build the Altro format from AliTPCDDL.dat
	282	//It is used to debug the code and creates the tables used in the compresseion phase
	283	Int_t offset=1;
	284	ifstream f;
	285	#ifndef __DECCXX
	286	f.open("AliTPCDDL.dat",ios::binary);
	287	#else
	288	f.open("AliTPCDDL.dat");
	289	#endif
	290	if(!f){cout<<"File doesn't exist !!"<<endl;return;}
	291	struct DataPad{
	292	Int_t Sec;
	293	Int_t SubSec;
	294	Int_t Row;
	295	Int_t Pad;
	296	Int_t Dig;
	297	Int_t Time;
	298	};
	299	DataPad data;
	300
	301	//AliTPCBuffer160 is used in write mode to generate AltroFormat.dat file
	302	char filename[30]="AltroFormatDDL.dat";
	303	cout<<" Creating "<<filename<<endl;
	304	AliTPCBuffer160 *buffer=new AliTPCBuffer160(filename,1);
	305
	306	UInt_t count=0;
	307	Int_t pSecNumber=-1; //Previous Sector number
	308	Int_t pRowNumber=-1; //Previous Row number
	309	Int_t pPadNumber=-1; //Previous Pad number
	310	Int_t pTimeBin=-1; //Previous Time-Bin
	311	Int_t bunchLength=0;
	312	Int_t nwords=0;
	313	UInt_t numPackets=0;
	314	while (f.read((char*)(&data),sizeof(data))){
	315	count++;
	316	if (pPadNumber==-1){
	317	pSecNumber=data.Sec;
	318	pRowNumber=data.Row;
	319	pPadNumber=data.Pad;
	320	pTimeBin=data.Time;
	321	bunchLength=1;
	322	buffer->FillBuffer(data.Dig-offset);
	323	nwords++;
	324	}//end if
	325	else{
	326	if ( (data.Time==(pTimeBin+1)) &&
	327	(pPadNumber==data.Pad) &&
	328	(pRowNumber==data.Row) &&
	329	(pSecNumber==data.Sec)){
	330	bunchLength++;
	331	}//end if
	332	else{
	333	buffer->FillBuffer(pTimeBin);
	334	buffer->FillBuffer(bunchLength+2);
	335	nwords+=2;
	336	if ((pPadNumber!=data.Pad)\|\|(pRowNumber!=data.Row)\|\|(pSecNumber!=data.Sec)){
	337	//Trailer is formatted and inserted!!
	338	buffer->WriteTrailer(nwords,pPadNumber,pRowNumber,pSecNumber);
	339	numPackets++;
	340	nwords=0;
	341	}//end if
	342
	343	bunchLength=1;
	344	pPadNumber=data.Pad;
	345	pRowNumber=data.Row;
	346	pSecNumber=data.Sec;
	347	}//end else
	348	pTimeBin=data.Time;
	349	buffer->FillBuffer(data.Dig-offset);
	350	nwords++;
	351	}//end else
	352	}//end while
	353	buffer->FillBuffer(pTimeBin);
	354	buffer->FillBuffer(bunchLength+2);
	355	nwords+=2;
	356	buffer->WriteTrailer(nwords,pPadNumber,pRowNumber,pSecNumber);
	357	delete buffer;
	358	cout<<"Number of digits: "<<count<<endl;
	359	f.close();
	360	return;
	361	}
	362
	363	/////////////////////////////////////////////////////////////////////////
	364	void AliTPCDDLRawData::RawDataAltroDecode(Int_t LDCsNumber,Int_t EventNumber,Int_t Comp){
	365	//This method merges the slides in only one file removing at the same
	366	//time all the mini headers. The file so obtained must be Altro format
	367	//complaiant.
	368	//It is used mainly in the debugging phase
	369	char filename[15];
	370	char dest[30];
	371	fstream f;
	372	if(!Comp)
	373	sprintf(dest,"AltroDDLRecomposed.dat");
	374	else
	375	sprintf(dest,"AltroDDLRecomposedDec.dat");
	376	ofstream fdest;
	377
	378	#ifndef __DECCXX
	379	fdest.open(dest,ios::binary);
	380	#else
	381	fdest.open(dest);
	382	#endif
	383	UInt_t size=0;
	384	//Int_t MagicWord,DDLNumber,SecNumber,SubSector,Detector,flag=0;
	385	for(Int_t i=1;i<=LDCsNumber;i++){
	386	if(!Comp){
	387	sprintf(filename,"Ev%dTPCslice%d",EventNumber,i);
	388	}
	389	else{
	390	sprintf(filename,"Ev%dTPCslice%d.decomp",EventNumber,i);
	391	}
	392	#ifndef __DECCXX
	393	f.open(filename,ios::binary\|ios::in);
	394	#else
	395	f.open(filename,ios::in);
	396	#endif
	397	if(!f){cout<<"BE CAREFUL!! There isn't enough data to generate "<<LDCsNumber<<" slices"<<endl;break;}
	398	//loop over the DDL block
	399	//Each block contains a Mini Header followed by raw data (ALTRO FORMAT)
	400	//The number of block is ceil(216/LDCsNumber)
	401	UInt_t miniHeader[3];
	402	//here the Mini Header is read
	403	//cout<<filename<<endl;
	404	while( (f.read((char)(miniHeader),sizeof(UInt_t)3)) ){
	405	Int_t car=0;
	406	size=miniHeader[0];
	407	for(UInt_t j=0;j<size;j++){
	408	f.read((char*)(&car),1);
	409	fdest.write((char*)(&car),1);
	410	}//end for
	411	}//end while
	412	f.clear();
	413	f.close();
	414	}//end for
	415	fdest.close();
	416	return;
	417	}
	418