[u/mrichter/AliRoot.git] / T0 / AliT0RawReader.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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:  */

//____________________________________________________________________
//                                                                          
// T0 
// Class for reading T0 RAW data in TOF data format
//
#include "AliT0RawReader.h"
#include "AliT0Parameters.h"
#include "AliBitPacking.h"
#include "TBits.h"

#include <Riostream.h>
#include "TMath.h"
#include "TH1F.h"
#include "TArrayI.h"
#include "AliLog.h"
 
using std::cout;
using std::endl;
using std::ios_base;
ClassImp(AliT0RawReader)
  
  AliT0RawReader::AliT0RawReader (AliRawReader *rawReader, Bool_t isOnline)
    :  TTask("T0RawReader","read raw T0 data"),
       fRawReader(rawReader),
       fData(NULL),
       fPosition(0),
       fParam(NULL),
       fIsOnline(isOnline),
       fBunchID(0),
       fPrintout(kFALSE)

{
  //
// create an object to read T0raw digits
  AliDebug(1,"Start ");
 
  fRawReader->Reset();
  fRawReader->Select("T0");
  fParam = AliT0Parameters::Instance();  
  if (fIsOnline)
    fParam->InitIfOnline();
  else 
    fParam->Init();
 
}
 AliT0RawReader::~AliT0RawReader ()
{
  // 
}
/*
AliT0RawReader::AliT0RawReader(const AliT0RawReader& o): TTask(o),
     fRawReader(rawReader),
       fData(NULL),
       fPosition(0)
{
  //
}
*/


Bool_t  AliT0RawReader::Next()
{
// read the next raw digit
// returns kFALSE if there is no digit left
//"LookUpTable":
// Amplitude LED TRM=0; chain=0; TDC 0 -5        channel 0,2,4,6
// Time CFD      TRM=0; chain=0; TDC 6 - 11      channel 0,2,4,6
// mean time     TRM=0; chain=0; TDC 12          channel 0
// T0A           TRM=0; chain=0; TDC 12          channel 2
// T0C           TRM=0; chain=0; TDC 12          channel 4
// vertex        TRM=0; chain=0; TDC 12          channel 6
// mult QTC0        TRM=0; chain=0; TDC 13          channel 0
// mult QTC1        TRM=0; chain=0; TDC 13          channel 2

// Charge QTC0   TRM=1; chain=0; TDC 0 -5        channel 0,2,4,6
// Charge QTC1   TRM=1; chain=0; TDC 6 - 11      channel 0,2,4,6
// T0A trigger          TRM=1; chain=0; TDC 12          channel 0
// T0C trigger          TRM=1; chain=0; TDC 12          channel 2
// vertex trigger       TRM=1; chain=0; TDC 12          channel 4
// trigger central      TRM=1; chain=0; TDC 13          channel 0
// tigger semicenral    TRM=1; chain=0; TDC 13          channel 2
//
// allData array collect data from all channels in one :
// allData[0] - allData[23] 24 CFD channels
// allData[24] -   allData[47] 24 LED channels
//  allData[48]  mean (T0) signal  
// allData[49]   time difference (vertex)

  UInt_t word;
  Int_t time=0,  itdc=0, ichannel=0, uu; 
  Int_t numberOfWordsInTRM=0, iTRM=0;
  Int_t tdcTime, koef,hit=0;
  Int_t koefhits[220];
  Int_t trm_chain_header =  0x00000000;
  Int_t  trm_chain_trailer =  0x10000000;
  
  UInt_t  filler =  0x70000000;
  Bool_t correct=kTRUE;
  Int_t header;

  Int_t fNTRM = fParam->GetNumberOfTRMs();
  for ( Int_t k=0; k<220; k++) {
    koefhits[k]=0;
    for ( Int_t jj=0; jj<5; jj++) {
      fAllData[k][jj]=0;
    }
  }
  do {
    if (!fRawReader->ReadNextData(fData)) return kFALSE;
  } while (fRawReader->GetDataSize() == 0);
  
  fPosition = 0;
  //  cout.setf( ios_base::hex, ios_base::basefield );
  if(fPrintout)
    cout<<" CDH :: BC ID "<< (fRawReader->GetBCID())<<
      " Event size"<<fRawReader->GetDataSize()<<
      " orbit ID "<<fRawReader->GetOrbitID()<< 
      " event index "<<fRawReader->GetEventIndex()<<
      " event type " <<fRawReader->GetType()<<endl;
  //DRM header
    for (Int_t i=0; i<6; i++) {
      word = GetNextWord();
      if(fPrintout && i==0) cout<<" DRM header:: event words "<<AliBitPacking::UnpackWord(word,4, 20);
      //  cout<<i<<" DRM header "<<word<<endl;
      if (fPrintout && i==4 ) cout<<" L0BC ID "<< AliBitPacking::UnpackWord(word,4, 15)<<endl;
      header = AliBitPacking::UnpackWord(word,28,31);
      if( header !=4 ) 
	{
	  AliWarning(Form(" !!!! wrong  DRM header  %x!!!!", word));
	  fRawReader->AddFatalErrorLog(kWrongDRMHeader,Form("w=%x",word));
	  break;
	}
    }
    for (Int_t ntrm=0; ntrm< fNTRM; ntrm++)
      {
	//TRMheader  
	word = GetNextWord();
	if (word == filler )  word = GetNextWord(); 
	//	cout<<" TRM "<<word<<endl;
	header = AliBitPacking::UnpackWord(word,28,31);
	if ( header != 4 )
	  {
	    AliWarning(Form(" !!!! wrong TRM header  %x!!!!", word));
	    fRawReader->AddMajorErrorLog(kWrongTRMHeader,Form("w=%x",word));
	    break;
	  }
	numberOfWordsInTRM=AliBitPacking::UnpackWord(word,4,16);
	if(fPrintout) {
	  cout<<" TRM header :: event words "<<numberOfWordsInTRM;
	  cout<<" ACQ bits "<<AliBitPacking::UnpackWord(word,17,18);
	  cout<<" L bit "<<AliBitPacking::UnpackWord(word,19,19)<<endl;
	}
	iTRM=AliBitPacking::UnpackWord(word,0,3);
	for( Int_t ichain=0; ichain<2; ichain++)
	  {
	    //chain header
	    word = GetNextWord();
	    uu = word & trm_chain_header;
	    if(uu != trm_chain_header) 
	      {
		AliWarning(Form(" !!!! wrong CHAIN  0  header %x!!!!", word));
		fRawReader->AddMajorErrorLog(kWrongChain0Header,Form("w=%x",word));
		break;
	      }
	    fBunchID=AliBitPacking::UnpackWord(word,4,15);
	    if(fPrintout)
	      cout<<" chain "<< ichain<<" header:: BunchID  "<<fBunchID;
	    word = GetNextWord();
	    //   cout<<" next word "<<word<<endl;
	    tdcTime =  AliBitPacking::UnpackWord(word,31,31);   
	    //	    for (; tdcTime==1; tdcTime) 
	    while(tdcTime==1)
	      {
		correct = kTRUE;
		itdc=AliBitPacking::UnpackWord(word,24,27);
		ichannel=AliBitPacking::UnpackWord(word,21,23);
		time=AliBitPacking::UnpackWord(word,0,20);
		
		koef = fParam->GetChannel(iTRM,itdc,ichain,ichannel);
		if (koef != 0 ) 
		 if(fPrintout)
		   cout<<"RawReader>> "<<"koef "<<koef<<" trm "<<iTRM<<
		    " tdc "<<itdc<<" chain "<<ichain<<
		    " channel "<<ichannel<<" time "<<time<<endl;
		if (koef ==-1 ){
		  AliWarning(Form("Incorrect lookup table ! "));
		  fRawReader->AddMajorErrorLog(kIncorrectLUT);
		  correct=kFALSE;
		}
		if(correct){
		  hit=koefhits[koef];
		  if(hit>4) {  
		    AliDebug(10,Form("Too many hits for %i channel - %i ! ",koef,koefhits[koef] )); 
		    hit=4;
		  }
		  fAllData[koef][hit]=time; 
		  koefhits[koef]++;
		}
		word = GetNextWord();

		tdcTime =  AliBitPacking::UnpackWord(word,31,31);   
		
	      }
	    
	    uu = word&trm_chain_trailer;
	    if(uu != trm_chain_trailer )
	      {
		AliWarning(Form(" !!!! wrong CHAIN 0 trailer %x !!!!", word));
		fRawReader->AddMajorErrorLog(kWrongChain0Trailer,Form("w=%x",word));
		break;
	      }
	    if(fPrintout)
	      cout<<"chain trailer:: event counter "<< AliBitPacking::UnpackWord(word,16,27)<<endl;
	  }
            
	word = GetNextWord(); //TRM trailer
	if(fPrintout)	cout<<" TRM trailer "<<word<<endl;
	header = AliBitPacking::UnpackWord(word,28,31);
	if( header !=5 )
	  {
	    AliWarning(Form(" !!!! wrong TRM GLOBAL trailer  %x!!!!", word));
	    fRawReader->AddMajorErrorLog(kWrongTRMTrailer,Form("w=%x",word));
	    break;
	  }
	if(fPrintout)
	  cout<<"  TRM trailer :: event counter "<< AliBitPacking::UnpackWord(word,16,27)<<endl;
      } //TRM loop
    word = GetNextWord(); //
    if (word == filler )  word = GetNextWord(); 
     header = AliBitPacking::UnpackWord(word,28,31);
     if( header !=5 )
       {
	 AliWarning(Form(" !!!! wrong DRM GLOBAL trailer  %x!!!!", word));
	 fRawReader->AddFatalErrorLog(kWrongDRMTrailer,Form("w=%x",word));
      }
     if(fPrintout)
       cout<<" DRM trailer ::event counter "<< AliBitPacking::UnpackWord(word,4,15)<<endl;
     cout.setf( ios_base::dec, ios_base::basefield );
    
     return kTRUE;
}
//_____________________________________________________________________________
Int_t AliT0RawReader::GetPosition()
{
  // Sets the position in the
  // input stream
  if (((fRawReader->GetDataSize() * 8) % 32) != 0)
    AliFatal(Form("Incorrect raw data size ! %d words are found !",fRawReader->GetDataSize()));
  return (fRawReader->GetDataSize() * 8) / 32;
}
//_____________________________________________________________________________
UInt_t AliT0RawReader::GetNextWord()
{
  // Read the next 32 bit word in backward direction
  // The input stream access is given by fData and fPosition


  //   fPosition--;
  Int_t iBit = fPosition * 32;
  Int_t iByte = iBit / 8;

  UInt_t word = 0;
  word  = fData[iByte+3]<<24;
  word |= fData[iByte+2]<<16;
  word |= fData[iByte+1]<<8;
  word |= fData[iByte];
   fPosition++;

  return word;

}
Commit	Line	Data
f16935f7	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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	/* $Id: */
	17
	18	//____________________________________________________________________
	19	//
	20	// T0
	21	// Class for reading T0 RAW data in TOF data format
	22	//
dc7ca31d	23	#include "AliT0RawReader.h"
e0bba6cc	24	#include "AliT0Parameters.h"
dc7ca31d	25	#include "AliBitPacking.h"
	26	#include "TBits.h"
	27
0d82bd92	28	#include <Riostream.h>
	29	#include "TMath.h"
	30	#include "TH1F.h"
	31	#include "TArrayI.h"
dc7ca31d	32	#include "AliLog.h"
dc7ca31d	33
cdf48647	34	using std::cout;
	35	using std::endl;
	36	using std::ios_base;
dc7ca31d	37	ClassImp(AliT0RawReader)
dc7ca31d	38
4a6b40d0	39	AliT0RawReader::AliT0RawReader (AliRawReader *rawReader, Bool_t isOnline)
dc7ca31d	40	: TTask("T0RawReader","read raw T0 data"),
dc7ca31d	41	fRawReader(rawReader),
dc7ca31d	42	fData(NULL),
807a797f	43	fPosition(0),
f8bea420	44	fParam(NULL),
8f620945	45	fIsOnline(isOnline),
	46	fBunchID(0),
	47	fPrintout(kFALSE)
	48
dc7ca31d	49	{
	50	//
	51	// create an object to read T0raw digits
	52	AliDebug(1,"Start ");
dc7ca31d	53
	54	fRawReader->Reset();
	55	fRawReader->Select("T0");
29d3e0eb	56	fParam = AliT0Parameters::Instance();
29d3e0eb	57	if (fIsOnline)
f8bea420	58	fParam->InitIfOnline();
	59	else
	60	fParam->Init();
29d3e0eb	61
dc7ca31d	62	}
	63	AliT0RawReader::~AliT0RawReader ()
	64	{
	65	//
	66	}
0d82bd92	67	/*
	68	AliT0RawReader::AliT0RawReader(const AliT0RawReader& o): TTask(o),
	69	fRawReader(rawReader),
	70	fData(NULL),
	71	fPosition(0)
	72	{
	73	//
	74	}
	75	*/
c41ceaac	76
dc7ca31d	77
	78	Bool_t AliT0RawReader::Next()
	79	{
	80	// read the next raw digit
	81	// returns kFALSE if there is no digit left
	82	//"LookUpTable":
	83	// Amplitude LED TRM=0; chain=0; TDC 0 -5 channel 0,2,4,6
	84	// Time CFD TRM=0; chain=0; TDC 6 - 11 channel 0,2,4,6
	85	// mean time TRM=0; chain=0; TDC 12 channel 0
	86	// T0A TRM=0; chain=0; TDC 12 channel 2
	87	// T0C TRM=0; chain=0; TDC 12 channel 4
	88	// vertex TRM=0; chain=0; TDC 12 channel 6
	89	// mult QTC0 TRM=0; chain=0; TDC 13 channel 0
	90	// mult QTC1 TRM=0; chain=0; TDC 13 channel 2
	91
	92	// Charge QTC0 TRM=1; chain=0; TDC 0 -5 channel 0,2,4,6
	93	// Charge QTC1 TRM=1; chain=0; TDC 6 - 11 channel 0,2,4,6
	94	// T0A trigger TRM=1; chain=0; TDC 12 channel 0
	95	// T0C trigger TRM=1; chain=0; TDC 12 channel 2
	96	// vertex trigger TRM=1; chain=0; TDC 12 channel 4
	97	// trigger central TRM=1; chain=0; TDC 13 channel 0
	98	// tigger semicenral TRM=1; chain=0; TDC 13 channel 2
	99	//
	100	// allData array collect data from all channels in one :
	101	// allData[0] - allData[23] 24 CFD channels
	102	// allData[24] - allData[47] 24 LED channels
	103	// allData[48] mean (T0) signal
	104	// allData[49] time difference (vertex)
	105
	106	UInt_t word;
5325480c	107	Int_t time=0, itdc=0, ichannel=0, uu;
dc7ca31d	108	Int_t numberOfWordsInTRM=0, iTRM=0;
5325480c	109	Int_t tdcTime, koef,hit=0;
abc567b8	110	Int_t koefhits[220];
0d82bd92	111	Int_t trm_chain_header = 0x00000000;
0d82bd92	112	Int_t trm_chain_trailer = 0x10000000;
807a797f	113
a9ab7568	114	UInt_t filler = 0x70000000;
807a797f	115	Bool_t correct=kTRUE;
807a797f	116	Int_t header;
4a6b40d0	117
8f620945	118	Int_t fNTRM = fParam->GetNumberOfTRMs();
abc567b8	119	for ( Int_t k=0; k<220; k++) {
807a797f	120	koefhits[k]=0;
5ed41460	121	for ( Int_t jj=0; jj<5; jj++) {
807a797f	122	fAllData[k][jj]=0;
8f620945	123	}
	124	}
	125	do {
	126	if (!fRawReader->ReadNextData(fData)) return kFALSE;
	127	} while (fRawReader->GetDataSize() == 0);
	128
	129	fPosition = 0;
	130	// cout.setf( ios_base::hex, ios_base::basefield );
	131	if(fPrintout)
	132	cout<<" CDH :: BC ID "<< (fRawReader->GetBCID())<<
	133	" Event size"<<fRawReader->GetDataSize()<<
	134	" orbit ID "<<fRawReader->GetOrbitID()<<
	135	" event index "<<fRawReader->GetEventIndex()<<
	136	" event type " <<fRawReader->GetType()<<endl;
	137	//DRM header
5325480c	138	for (Int_t i=0; i<6; i++) {
5325480c	139	word = GetNextWord();
8f620945	140	if(fPrintout && i==0) cout<<" DRM header:: event words "<<AliBitPacking::UnpackWord(word,4, 20);
	141	// cout<<i<<" DRM header "<<word<<endl;
	142	if (fPrintout && i==4 ) cout<<" L0BC ID "<< AliBitPacking::UnpackWord(word,4, 15)<<endl;
807a797f	143	header = AliBitPacking::UnpackWord(word,28,31);
8f620945	144	if( header !=4 )
5325480c	145	{
29d3e0eb	146	AliWarning(Form(" !!!! wrong DRM header %x!!!!", word));
29d3e0eb	147	fRawReader->AddFatalErrorLog(kWrongDRMHeader,Form("w=%x",word));
5325480c	148	break;
807a797f	149	}
5325480c	150	}
0d82bd92	151	for (Int_t ntrm=0; ntrm< fNTRM; ntrm++)
807a797f	152	{
	153	//TRMheader
	154	word = GetNextWord();
ad83768c	155	if (word == filler ) word = GetNextWord();
8f620945	156	// cout<<" TRM "<<word<<endl;
29d3e0eb	157	header = AliBitPacking::UnpackWord(word,28,31);
	158	if ( header != 4 )
	159	{
	160	AliWarning(Form(" !!!! wrong TRM header %x!!!!", word));
	161	fRawReader->AddMajorErrorLog(kWrongTRMHeader,Form("w=%x",word));
	162	break;
	163	}
807a797f	164	numberOfWordsInTRM=AliBitPacking::UnpackWord(word,4,16);
8f620945	165	if(fPrintout) {
	166	cout<<" TRM header :: event words "<<numberOfWordsInTRM;
	167	cout<<" ACQ bits "<<AliBitPacking::UnpackWord(word,17,18);
	168	cout<<" L bit "<<AliBitPacking::UnpackWord(word,19,19)<<endl;
	169	}
807a797f	170	iTRM=AliBitPacking::UnpackWord(word,0,3);
807a797f	171	for( Int_t ichain=0; ichain<2; ichain++)
c41ceaac	172	{
807a797f	173	//chain header
807a797f	174	word = GetNextWord();
0d82bd92	175	uu = word & trm_chain_header;
0d82bd92	176	if(uu != trm_chain_header)
807a797f	177	{
29d3e0eb	178	AliWarning(Form(" !!!! wrong CHAIN 0 header %x!!!!", word));
29d3e0eb	179	fRawReader->AddMajorErrorLog(kWrongChain0Header,Form("w=%x",word));
807a797f	180	break;
807a797f	181	}
8f620945	182	fBunchID=AliBitPacking::UnpackWord(word,4,15);
	183	if(fPrintout)
	184	cout<<" chain "<< ichain<<" header:: BunchID "<<fBunchID;
807a797f	185	word = GetNextWord();
8f620945	186	// cout<<" next word "<<word<<endl;
807a797f	187	tdcTime = AliBitPacking::UnpackWord(word,31,31);
0d82bd92	188	// for (; tdcTime==1; tdcTime)
f16935f7	189	while(tdcTime==1)
807a797f	190	{
0d82bd92	191	correct = kTRUE;
807a797f	192	itdc=AliBitPacking::UnpackWord(word,24,27);
	193	ichannel=AliBitPacking::UnpackWord(word,21,23);
	194	time=AliBitPacking::UnpackWord(word,0,20);
	195
	196	koef = fParam->GetChannel(iTRM,itdc,ichain,ichannel);
f16935f7	197	if (koef != 0 )
abc567b8	198	if(fPrintout)
	199	cout<<"RawReader>> "<<"koef "<<koef<<" trm "<<iTRM<<
	200	" tdc "<<itdc<<" chain "<<ichain<<
	201	" channel "<<ichannel<<" time "<<time<<endl;
807a797f	202	if (koef ==-1 ){
29d3e0eb	203	AliWarning(Form("Incorrect lookup table ! "));
29d3e0eb	204	fRawReader->AddMajorErrorLog(kIncorrectLUT);
807a797f	205	correct=kFALSE;
	206	}
	207	if(correct){
	208	hit=koefhits[koef];
b0ab3f59	209	if(hit>4) {
68c759ae	210	AliDebug(10,Form("Too many hits for %i channel - %i ! ",koef,koefhits[koef] ));
b0ab3f59	211	hit=4;
c1469fdf	212	}
807a797f	213	fAllData[koef][hit]=time;
	214	koefhits[koef]++;
	215	}
f16935f7	216	word = GetNextWord();
8f620945	217
f16935f7	218	tdcTime = AliBitPacking::UnpackWord(word,31,31);
807a797f	219
f16935f7	220	}
c41ceaac	221
0d82bd92	222	uu = word&trm_chain_trailer;
0d82bd92	223	if(uu != trm_chain_trailer )
807a797f	224	{
29d3e0eb	225	AliWarning(Form(" !!!! wrong CHAIN 0 trailer %x !!!!", word));
f16935f7	226	fRawReader->AddMajorErrorLog(kWrongChain0Trailer,Form("w=%x",word));
807a797f	227	break;
807a797f	228	}
8f620945	229	if(fPrintout)
abc567b8	230	cout<<"chain trailer:: event counter "<< AliBitPacking::UnpackWord(word,16,27)<<endl;
807a797f	231	}
	232
	233	word = GetNextWord(); //TRM trailer
abc567b8	234	if(fPrintout) cout<<" TRM trailer "<<word<<endl;
807a797f	235	header = AliBitPacking::UnpackWord(word,28,31);
	236	if( header !=5 )
	237	{
29d3e0eb	238	AliWarning(Form(" !!!! wrong TRM GLOBAL trailer %x!!!!", word));
29d3e0eb	239	fRawReader->AddMajorErrorLog(kWrongTRMTrailer,Form("w=%x",word));
807a797f	240	break;
807a797f	241	}
8f620945	242	if(fPrintout)
8f620945	243	cout<<" TRM trailer :: event counter "<< AliBitPacking::UnpackWord(word,16,27)<<endl;
807a797f	244	} //TRM loop
807a797f	245	word = GetNextWord(); //
f16935f7	246	if (word == filler ) word = GetNextWord();
21ab892d	247	header = AliBitPacking::UnpackWord(word,28,31);
	248	if( header !=5 )
	249	{
	250	AliWarning(Form(" !!!! wrong DRM GLOBAL trailer %x!!!!", word));
	251	fRawReader->AddFatalErrorLog(kWrongDRMTrailer,Form("w=%x",word));
807a797f	252	}
8f620945	253	if(fPrintout)
8f620945	254	cout<<" DRM trailer ::event counter "<< AliBitPacking::UnpackWord(word,4,15)<<endl;
0d82bd92	255	cout.setf( ios_base::dec, ios_base::basefield );
0d82bd92	256
21ab892d	257	return kTRUE;
dc7ca31d	258	}
dc7ca31d	259	//_____________________________________________________________________________
dc7ca31d	260	Int_t AliT0RawReader::GetPosition()
	261	{
	262	// Sets the position in the
	263	// input stream
807a797f	264	if (((fRawReader->GetDataSize() * 8) % 32) != 0)
807a797f	265	AliFatal(Form("Incorrect raw data size ! %d words are found !",fRawReader->GetDataSize()));
dc7ca31d	266	return (fRawReader->GetDataSize() * 8) / 32;
	267	}
	268	//_____________________________________________________________________________
	269	UInt_t AliT0RawReader::GetNextWord()
	270	{
	271	// Read the next 32 bit word in backward direction
	272	// The input stream access is given by fData and fPosition
	273
	274
	275	// fPosition--;
	276	Int_t iBit = fPosition * 32;
	277	Int_t iByte = iBit / 8;
	278
	279	UInt_t word = 0;
	280	word = fData[iByte+3]<<24;
	281	word \|= fData[iByte+2]<<16;
	282	word \|= fData[iByte+1]<<8;
	283	word \|= fData[iByte];
	284	fPosition++;
	285
	286	return word;
	287
	288	}
	289