[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){
  // 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){
  //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,"TPCslice%d",sliceNumber); 
  cout<<"   Creating "<<filename<<endl;
  AliTPCBuffer160 *buffer=new AliTPCBuffer160(filename,1);

  ULong_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;
  ULong_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,"TPCslice%d",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 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;
  ULong_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,"TPCslice%d",i);
      sprintf(dest,"TPCslice%d.comp",i);
    }
    else{
      sprintf(filename,"TPCslice%d.comp",i);
      sprintf(dest,"TPCslice%d.decomp",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;}
    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)
    ULong_t miniHeader[3];
    //here the Mini Header is read
    while( (f.read((char*)(miniHeader),sizeof(ULong_t)*3)) ){
      size=miniHeader[0];
      // cout<<"Data size:"<<size<<endl;
      //Int_t dim=sizeof(ULong_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(ULong_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;
      ULong_t aux=0x0;
      flag<<=8;
      aux|=flag;
      miniHeader[2]=miniHeader[2]|aux;
      fdest.write((char*)(miniHeader),sizeof(ULong_t)*3);
      //The compressem temp file is copied into the output file fdest
      for(ULong_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);

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