[u/mrichter/AliRoot.git] / TOF / AliTOFDDLRawData.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.                  *
 **************************************************************************/

/*
Revision 0.01  2004/6/11 A.De Caro, S.B.Sellitto, R.Silvestri
        First implementation: global methods RawDataTOF
                                             GetDigits
*/
//
// This class contains the methods to create the Raw Data files
// for the TOF detector starting from the Digits.
// In this preliminary implementation, we defined the structure
// of the ALICE-TOF raw data starting from the current format
// for the TOF digits and the TOF raw data.
//

#include <stdlib.h>
#include <Riostream.h>
#include <TClonesArray.h>
#include <TTree.h>
#include <TMath.h>
#include "AliLog.h"

#include "AliTOFGeometry.h"
#include "AliTOFdigit.h"
#include "AliTOFDDLRawData.h"
#include "AliRawDataHeader.h"
#include "AliBitPacking.h"

ClassImp(AliTOFDDLRawData)

//----------------------------------------------------------------------------------------
AliTOFDDLRawData::AliTOFDDLRawData()
{
  //Default constructor
  fIndex=-1;
  fVerbose=0;
}

//----------------------------------------------------------------------------------------

AliTOFDDLRawData::AliTOFDDLRawData(const AliTOFDDLRawData &source) : 
    TObject(source){
  //Copy Constructor
  this->fIndex=source.fIndex;
  this->fVerbose=source.fVerbose;
  return;
}

//---------------------------------------------------------------------------------------

AliTOFDDLRawData& AliTOFDDLRawData::operator=(const AliTOFDDLRawData &source){
  //Assigment operator
  this->fIndex=source.fIndex;
  this->fVerbose=source.fVerbose;
  return *this;
}

//---------------------------------------------------------------------------------------

void AliTOFDDLRawData::GetDigits(TClonesArray *TOFdigits,Int_t nDDL,UInt_t *buf)
{
  //This method packs the TOF digits in a proper 32 bits structure
  Int_t iDDL=(Int_t)((nDDL/4.-(Int_t)(nDDL/4.))*4);
  Int_t iSector=(Int_t)(nDDL/4.);
  Int_t iTRM=0;
  Int_t iTDC=0;
  Int_t iCH=-1;
  Int_t sector; 
  Int_t plate;
  Int_t strip;
  Int_t padx;
  Int_t padz;
  Int_t totCharge;
  Int_t timeOfFlight;
  Int_t error=0;
  Int_t eureka;
  UInt_t word;
  UInt_t baseWord;
  Int_t ndigits = TOFdigits->GetEntries();
  AliTOFdigit *digs;
  ofstream ftxt;
  if(!ndigits) 
    {
      AliError("No found TOF digits");
      return;
    }

  if (fVerbose==2) ftxt.open("TOFdigits.txt",ios::app);
  for (Int_t digit=0;digit<ndigits;digit++) {
    digs = (AliTOFdigit*)TOFdigits->UncheckedAt(digit);
    sector=digs->GetSector(); // Sector Number (0-17)
    plate=digs->GetPlate();   // Plate Number (0-4)
    strip=digs->GetStrip();   // Strip Number (0-14/18/19)
    padx=digs->GetPadx();     // Pad Number in x direction (0-47)
    padz=digs->GetPadz();     // Pad Number in z direction (0-1)
    eureka=digs->GetTotPad(); // Global Pad Number inside a Sector
    totCharge = (Int_t)digs->GetAdc();
    timeOfFlight = (Int_t)digs->GetTdc();
    /*
    Int_t istriPlate=0;
    switch (plate)
      {
      case 0:
	break;
      case 1:
	istriPlate = AliTOFGeometry::NStripC();
	break;
      case 2:
	istriPlate = AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB();
	break;
      case 3:
	istriPlate = AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB()+AliTOFGeometry::NStripA();
	break;
      case 4:
	istriPlate = AliTOFGeometry::NStripC()+2*AliTOFGeometry::NStripB()+AliTOFGeometry::NStripA();
	break;
      }

    eureka=2*padx+padz+AliTOFGeometry::NpadXStrip()*(strip+istriPlate);
    
    if (eureka!=digs->GetTotPad()) printf(" eureka = %d AND digs->GetTotPad() = %d",eureka,digs->GetTotPad());
    */
    if (sector!=iSector || (Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM()/AliTOFGeometry::NTRM())!=iDDL) continue;
    
    if (fVerbose==2) ftxt <<" Sector: "<<sector<<" plate: "<<plate<<" strip "<<strip<<" padx "<<padx<<" padz "<<padz<<" eureka "<<eureka<<endl;
    
    iTRM = (Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM() - AliTOFGeometry::NTRM()*iDDL);
    
    iTDC = (Int_t)(AliTOFGeometry::NTdc()* 
		   (
		    (Float_t)eureka/AliTOFGeometry::NPadXTRM() -
		    (Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM())
		    )
		   );
    
    iCH  = (Int_t)(AliTOFGeometry::NCh() * 
		   (
		    (Float_t)eureka/AliTOFGeometry::NPadXTRM()*AliTOFGeometry::NTdc() - (Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM()*AliTOFGeometry::NTdc()) -
		    (Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM()*AliTOFGeometry::NTdc() - (Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM()*AliTOFGeometry::NTdc()))
		    )
		   );
    
    if (fVerbose==2) ftxt << "DDL: "<<iDDL<<" Sector: "<<sector<<" TRM: "<<iTRM<<" TDC: "<<iTDC<<" Channel: "<<iCH<<" totCharge: "<<totCharge<<" tof: "<<timeOfFlight<<endl;
    
    baseWord=0;
    
    word=iTRM;
    AliBitPacking::PackWord(word,baseWord, 0, 3); // TRM ID
    word=iTDC;
    AliBitPacking::PackWord(word,baseWord, 4, 8); // TDC ID
    word=iCH;
    AliBitPacking::PackWord(word,baseWord, 9,11); // CH ID

    // temporary control
    if (totCharge<0) word=TMath::Abs(totCharge);
    else word=totCharge;
    AliBitPacking::PackWord(word,baseWord,12,31); // Charge (TOT)
    
    fIndex++;
    buf[fIndex]=baseWord;
    
    baseWord=0;
    
    word=error;
    AliBitPacking::PackWord(word,baseWord,0, 7); // Error flag
    word=timeOfFlight;
    AliBitPacking::PackWord(word,baseWord,8,31); // time-of-flight
    
    fIndex++;
    buf[fIndex]=baseWord;
    word=0;
    baseWord=0;
    
  }//end for
  
  if (fVerbose==2) ftxt.close();

  return;

}//end GetDigits

//---------------------------------------------------------------------------------------

Int_t AliTOFDDLRawData::RawDataTOF(TBranch* branch){
  //This method creates the Raw data files for TOF detector
  const Int_t kSize=5000; //2*AliTOFGeometry::NpadXSector() 
                          //max number of digits per DDL file times 2
  UInt_t buf[kSize];
  UInt_t baseWord;
  UInt_t word;

  fIndex=-1;

  TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
  char fileName[15];
  ofstream outfile;         // logical name of the output file 
  AliRawDataHeader header;

  //loop over TOF DDL files
  for(Int_t i=0;i<72;i++){
    sprintf(fileName,"TOF_%d.ddl",i+kDDLOffset); //The name of the output file
#ifndef __DECCXX
    outfile.open(fileName,ios::binary);
#else
    outfile.open(fileName);
#endif
    //write Dummy DATA HEADER
    UInt_t dataHeaderPosition=outfile.tellp();
    outfile.write((char*)(&header),sizeof(header));

    baseWord=0;
    word=i;
    AliBitPacking::PackWord(word,baseWord,0, 31); // Number of DDL file

    fIndex++;
    buf[fIndex]=baseWord;

    branch->GetEvent();

    //For each DDL file, buf contains the array of data words in Binary format
    //fIndex gives the number of 32 bits words in the buffer for each DDL file
    GetDigits(digits,i,buf);
    outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));

    for(Int_t ii=0;ii<(fIndex+1);ii++) buf[ii]=0;
    fIndex=-1;
    
    //Write REAL DATA HEADER
    UInt_t currentFilePosition=outfile.tellp();
    outfile.seekp(dataHeaderPosition);
    header.fSize=currentFilePosition-dataHeaderPosition;
    header.SetAttribute(0);  // valid data
    outfile.write((char*)(&header),sizeof(header));
    outfile.close();

  }//end for
  
  return 0;  
}

//-----------------------------------------------------------------------------------------
/*
void AliTOFDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t EventCnt,UInt_t &BaseWord)
{
  //This method writes a chip header 
  BaseWord=0;
  PackWord(BaseWord,ChipAddr,0,3);
  PackWord(BaseWord,EventCnt,4,10);
  PackWord(BaseWord,0x7,11,13);
  PackWord(BaseWord,0x1,14,15);
  return;
}//end WriteChipHeader
*/
//----------------------------------------------------------------------------------------
/*
void AliTOFDDLRawData::ReadChipHeader(Int_t &ChipAddr,Int_t &EventCnt,UInt_t BaseWord)
{
  //This method reads a chip header
  UInt_t temp=0;
  UnpackWord(BaseWord,0,3,temp);
  ChipAddr=(Int_t)temp;
  UnpackWord(BaseWord,4,10,temp);
  EventCnt=(Int_t)temp;
  if(fVerbose)
    Info("ReadChipHeader", "Chip:&d Half Stave module:%d",ChipAddr,EventCnt);
  return;
}//end ReadChipHeader
*/
//----------------------------------------------------------------------------------------
/*
void  AliTOFDDLRawData::WriteChipTrailer(UInt_t *buf,Int_t ChipHitCount,UInt_t &BaseWord)
{
  //This method writes a chip trailer
  //pixel fill word
  if((ChipHitCount%2)!=0){
    PackWord(BaseWord,0xFEDC,0,15);
  }
  PackWord(BaseWord,ChipHitCount,16,28);
  PackWord(BaseWord,0x0,30,31);
  fIndex++;
  buf[fIndex]=BaseWord;
  BaseWord=0;
  return;
}//end WriteChipTrailer
*/
//------------------------------------------------------------------------------------------
/*
void  AliTOFDDLRawData::ReadChipTrailer(Int_t &ChipHitCount,UInt_t BaseWord)
{
  //This method reads a chip trailer
  UInt_t temp=0;
  UnpackWord(BaseWord,16,28,temp);
  ChipHitCount=(Int_t)temp;
  return;
}//end ReadChipTrailer
*/
//------------------------------------------------------------------------------------------
Commit	Line	Data
7e6dce66	1	/**************************************************************************
	2	* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/*
	17	Revision 0.01 2004/6/11 A.De Caro, S.B.Sellitto, R.Silvestri
	18	First implementation: global methods RawDataTOF
	19	GetDigits
7e6dce66	20	*/
	21	//
	22	// This class contains the methods to create the Raw Data files
	23	// for the TOF detector starting from the Digits.
	24	// In this preliminary implementation, we defined the structure
	25	// of the ALICE-TOF raw data starting from the current format
	26	// for the TOF digits and the TOF raw data.
	27	//
	28
	29	#include <stdlib.h>
	30	#include <Riostream.h>
	31	#include <TClonesArray.h>
	32	#include <TTree.h>
	33	#include <TMath.h>
d076c8d5	34	#include "AliLog.h"
43f77f2d	35
7e6dce66	36	#include "AliTOFGeometry.h"
	37	#include "AliTOFdigit.h"
	38	#include "AliTOFDDLRawData.h"
	39	#include "AliRawDataHeader.h"
344f25d2	40	#include "AliBitPacking.h"
7e6dce66	41
	42	ClassImp(AliTOFDDLRawData)
	43
	44	//----------------------------------------------------------------------------------------
	45	AliTOFDDLRawData::AliTOFDDLRawData()
	46	{
	47	//Default constructor
	48	fIndex=-1;
	49	fVerbose=0;
	50	}
	51
	52	//----------------------------------------------------------------------------------------
	53
	54	AliTOFDDLRawData::AliTOFDDLRawData(const AliTOFDDLRawData &source) :
	55	TObject(source){
	56	//Copy Constructor
	57	this->fIndex=source.fIndex;
	58	this->fVerbose=source.fVerbose;
	59	return;
	60	}
	61
	62	//---------------------------------------------------------------------------------------
	63
	64	AliTOFDDLRawData& AliTOFDDLRawData::operator=(const AliTOFDDLRawData &source){
	65	//Assigment operator
	66	this->fIndex=source.fIndex;
	67	this->fVerbose=source.fVerbose;
	68	return *this;
	69	}
	70
	71	//---------------------------------------------------------------------------------------
	72
	73	void AliTOFDDLRawData::GetDigits(TClonesArray TOFdigits,Int_t nDDL,UInt_t buf)
	74	{
	75	//This method packs the TOF digits in a proper 32 bits structure
	76	Int_t iDDL=(Int_t)((nDDL/4.-(Int_t)(nDDL/4.))*4);
	77	Int_t iSector=(Int_t)(nDDL/4.);
	78	Int_t iTRM=0;
	79	Int_t iTDC=0;
	80	Int_t iCH=-1;
	81	Int_t sector;
	82	Int_t plate;
	83	Int_t strip;
	84	Int_t padx;
	85	Int_t padz;
	86	Int_t totCharge;
	87	Int_t timeOfFlight;
	88	Int_t error=0;
	89	Int_t eureka;
	90	UInt_t word;
	91	UInt_t baseWord;
	92	Int_t ndigits = TOFdigits->GetEntries();
	93	AliTOFdigit *digs;
	94	ofstream ftxt;
	95	if(!ndigits)
	96	{
d076c8d5	97	AliError("No found TOF digits");
7e6dce66	98	return;
	99	}
	100
	101	if (fVerbose==2) ftxt.open("TOFdigits.txt",ios::app);
	102	for (Int_t digit=0;digit<ndigits;digit++) {
	103	digs = (AliTOFdigit*)TOFdigits->UncheckedAt(digit);
	104	sector=digs->GetSector(); // Sector Number (0-17)
	105	plate=digs->GetPlate(); // Plate Number (0-4)
	106	strip=digs->GetStrip(); // Strip Number (0-14/18/19)
	107	padx=digs->GetPadx(); // Pad Number in x direction (0-47)
	108	padz=digs->GetPadz(); // Pad Number in z direction (0-1)
	109	eureka=digs->GetTotPad(); // Global Pad Number inside a Sector
	110	totCharge = (Int_t)digs->GetAdc();
	111	timeOfFlight = (Int_t)digs->GetTdc();
	112	/*
	113	Int_t istriPlate=0;
	114	switch (plate)
	115	{
	116	case 0:
	117	break;
	118	case 1:
	119	istriPlate = AliTOFGeometry::NStripC();
	120	break;
	121	case 2:
	122	istriPlate = AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB();
	123	break;
	124	case 3:
	125	istriPlate = AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB()+AliTOFGeometry::NStripA();
	126	break;
	127	case 4:
	128	istriPlate = AliTOFGeometry::NStripC()+2*AliTOFGeometry::NStripB()+AliTOFGeometry::NStripA();
	129	break;
	130	}
	131
	132	eureka=2padx+padz+AliTOFGeometry::NpadXStrip()(strip+istriPlate);
	133
	134	if (eureka!=digs->GetTotPad()) printf(" eureka = %d AND digs->GetTotPad() = %d",eureka,digs->GetTotPad());
	135	*/
43f77f2d	136	if (sector!=iSector \|\| (Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM()/AliTOFGeometry::NTRM())!=iDDL) continue;
7e6dce66	137
	138	if (fVerbose==2) ftxt <<" Sector: "<<sector<<" plate: "<<plate<<" strip "<<strip<<" padx "<<padx<<" padz "<<padz<<" eureka "<<eureka<<endl;
	139
43f77f2d	140	iTRM = (Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM() - AliTOFGeometry::NTRM()*iDDL);
7e6dce66	141
43f77f2d	142	iTDC = (Int_t)(AliTOFGeometry::NTdc()*
7e6dce66	143	(
43f77f2d	144	(Float_t)eureka/AliTOFGeometry::NPadXTRM() -
43f77f2d	145	(Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM())
7e6dce66	146	)
	147	);
	148
43f77f2d	149	iCH = (Int_t)(AliTOFGeometry::NCh() *
7e6dce66	150	(
43f77f2d	151	(Float_t)eureka/AliTOFGeometry::NPadXTRM()AliTOFGeometry::NTdc() - (Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM()AliTOFGeometry::NTdc()) -
43f77f2d	152	(Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM()AliTOFGeometry::NTdc() - (Int_t)((Float_t)eureka/AliTOFGeometry::NPadXTRM()AliTOFGeometry::NTdc()))
7e6dce66	153	)
	154	);
	155
	156	if (fVerbose==2) ftxt << "DDL: "<<iDDL<<" Sector: "<<sector<<" TRM: "<<iTRM<<" TDC: "<<iTDC<<" Channel: "<<iCH<<" totCharge: "<<totCharge<<" tof: "<<timeOfFlight<<endl;
	157
	158	baseWord=0;
	159
	160	word=iTRM;
344f25d2	161	AliBitPacking::PackWord(word,baseWord, 0, 3); // TRM ID
7e6dce66	162	word=iTDC;
344f25d2	163	AliBitPacking::PackWord(word,baseWord, 4, 8); // TDC ID
7e6dce66	164	word=iCH;
344f25d2	165	AliBitPacking::PackWord(word,baseWord, 9,11); // CH ID
7e6dce66	166
	167	// temporary control
	168	if (totCharge<0) word=TMath::Abs(totCharge);
	169	else word=totCharge;
344f25d2	170	AliBitPacking::PackWord(word,baseWord,12,31); // Charge (TOT)
7e6dce66	171
	172	fIndex++;
	173	buf[fIndex]=baseWord;
	174
	175	baseWord=0;
	176
	177	word=error;
344f25d2	178	AliBitPacking::PackWord(word,baseWord,0, 7); // Error flag
7e6dce66	179	word=timeOfFlight;
344f25d2	180	AliBitPacking::PackWord(word,baseWord,8,31); // time-of-flight
7e6dce66	181
	182	fIndex++;
	183	buf[fIndex]=baseWord;
	184	word=0;
	185	baseWord=0;
	186
	187	}//end for
	188
	189	if (fVerbose==2) ftxt.close();
	190
	191	return;
	192
	193	}//end GetDigits
	194
7e6dce66	195	//---------------------------------------------------------------------------------------
	196
	197	Int_t AliTOFDDLRawData::RawDataTOF(TBranch* branch){
	198	//This method creates the Raw data files for TOF detector
	199	const Int_t kSize=5000; //2*AliTOFGeometry::NpadXSector()
	200	//max number of digits per DDL file times 2
	201	UInt_t buf[kSize];
	202	UInt_t baseWord;
	203	UInt_t word;
	204
	205	fIndex=-1;
	206
	207	TClonesArray& digits = (TClonesArray**) branch->GetAddress();
	208	char fileName[15];
	209	ofstream outfile; // logical name of the output file
	210	AliRawDataHeader header;
	211
	212	//loop over TOF DDL files
	213	for(Int_t i=0;i<72;i++){
3125b792	214	sprintf(fileName,"TOF_%d.ddl",i+kDDLOffset); //The name of the output file
7e6dce66	215	#ifndef __DECCXX
	216	outfile.open(fileName,ios::binary);
	217	#else
	218	outfile.open(fileName);
	219	#endif
	220	//write Dummy DATA HEADER
	221	UInt_t dataHeaderPosition=outfile.tellp();
	222	outfile.write((char*)(&header),sizeof(header));
	223
	224	baseWord=0;
	225	word=i;
344f25d2	226	AliBitPacking::PackWord(word,baseWord,0, 31); // Number of DDL file
7e6dce66	227
	228	fIndex++;
	229	buf[fIndex]=baseWord;
	230
	231	branch->GetEvent();
	232
	233	//For each DDL file, buf contains the array of data words in Binary format
	234	//fIndex gives the number of 32 bits words in the buffer for each DDL file
	235	GetDigits(digits,i,buf);
	236	outfile.write((char )buf,((fIndex+1)sizeof(UInt_t)));
	237
	238	for(Int_t ii=0;ii<(fIndex+1);ii++) buf[ii]=0;
	239	fIndex=-1;
	240
	241	//Write REAL DATA HEADER
	242	UInt_t currentFilePosition=outfile.tellp();
	243	outfile.seekp(dataHeaderPosition);
	244	header.fSize=currentFilePosition-dataHeaderPosition;
	245	header.SetAttribute(0); // valid data
	246	outfile.write((char*)(&header),sizeof(header));
	247	outfile.close();
	248
	249	}//end for
	250
	251	return 0;
	252	}
	253
	254	//-----------------------------------------------------------------------------------------
	255	/*
	256	void AliTOFDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t EventCnt,UInt_t &BaseWord)
	257	{
	258	//This method writes a chip header
	259	BaseWord=0;
	260	PackWord(BaseWord,ChipAddr,0,3);
	261	PackWord(BaseWord,EventCnt,4,10);
	262	PackWord(BaseWord,0x7,11,13);
	263	PackWord(BaseWord,0x1,14,15);
	264	return;
	265	}//end WriteChipHeader
	266	*/
	267	//----------------------------------------------------------------------------------------
	268	/*
	269	void AliTOFDDLRawData::ReadChipHeader(Int_t &ChipAddr,Int_t &EventCnt,UInt_t BaseWord)
	270	{
	271	//This method reads a chip header
	272	UInt_t temp=0;
	273	UnpackWord(BaseWord,0,3,temp);
	274	ChipAddr=(Int_t)temp;
	275	UnpackWord(BaseWord,4,10,temp);
	276	EventCnt=(Int_t)temp;
	277	if(fVerbose)
	278	Info("ReadChipHeader", "Chip:&d Half Stave module:%d",ChipAddr,EventCnt);
	279	return;
	280	}//end ReadChipHeader
	281	*/
	282	//----------------------------------------------------------------------------------------
	283	/*
	284	void AliTOFDDLRawData::WriteChipTrailer(UInt_t *buf,Int_t ChipHitCount,UInt_t &BaseWord)
	285	{
	286	//This method writes a chip trailer
	287	//pixel fill word
	288	if((ChipHitCount%2)!=0){
	289	PackWord(BaseWord,0xFEDC,0,15);
	290	}
291	PackWord(BaseWord,ChipHitCount,16,28);
292	PackWord(BaseWord,0x0,30,31);
293	fIndex++;
294	buf[fIndex]=BaseWord;
295	BaseWord=0;
296	return;
297	}//end WriteChipTrailer
298	*/
299	//------------------------------------------------------------------------------------------
300	/*
301	void AliTOFDDLRawData::ReadChipTrailer(Int_t &ChipHitCount,UInt_t BaseWord)
302	{
303	//This method reads a chip trailer
304	UInt_t temp=0;
305	UnpackWord(BaseWord,16,28,temp);
306	ChipHitCount=(Int_t)temp;
307	return;
308	}//end ReadChipTrailer
309	*/
310	//------------------------------------------------------------------------------------------