[u/mrichter/AliRoot.git] / START / AliSTARTRawData.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$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  START raw data conversion class                                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <Riostream.h>
#include <TTree.h>

#include "AliSTART.h"
#include "AliSTARTRawData.h"
#include "AliSTARTdigit.h"
#include "AliBitPacking.h"
#include "AliRawDataHeader.h"
#include "AliRawDataHeaderSim.h"
#include "AliBitPacking.h"
#include "AliFstream.h"
#include "AliRunLoader.h"

ClassImp(AliSTARTRawData)

//_____________________________________________________________________________
AliSTARTRawData::AliSTARTRawData():TObject()
{
  /*
-  48 channels (2 words each as in TOF DDL) for :
word 1 :0-5bit number of PMT; word 2: 0-7 error sign, 8-31 TDC
and the same but for amplified signal. Now I wrote the same time because
CDF are not ready and differences didn't measured yet.

-  48 channel for amplitude: very preliminary, QTC features are not
known now, preliminary i put as T1 time signal for this PMT in first
channel and T1+A in second, where A=Log(Amplitude);
and the same for amplified but A=Log(10*Amplitude).

- T0-A and T0-C 2 channels
- T0A-T0C vertex information
- Time Meaner where T0C TOF increase to the T0A TOF distance
- 6 multiplicity signals the same way as amplitude and with the same
uncertances
  */

  fIndex=-1;
  fDigits = NULL;

  fTimeCFD = new TArrayI(24);
  fADC1 = new TArrayI(24);
  fTimeLED = new TArrayI(24);
  fADC0 = new TArrayI(24);
  fFile = NULL;
  fDataHeaderPos = 0;
  fDRMDataHeaderPos = 0; 
  memset(fBuffer,0,512*sizeof(UInt_t));

  //open the output file
  char fileName[15];
  sprintf(fileName,"START_%d.ddl", 0xd00);
  fFile = new AliFstream(fileName);
  //get event number 
  AliRunLoader *runloader = AliRunLoader::GetRunLoader();
  if (runloader) {
    fEventNumber = runloader->GetEventNumber();
  }
}

//_____________________________________________________________________________
AliSTARTRawData::AliSTARTRawData(const AliSTARTRawData &r):TObject()
{
  //
  // AliSTARTrawData copy constructor
  //

  ((AliSTARTRawData &) r).Copy(*this);

}

//_____________________________________________________________________________
AliSTARTRawData::~AliSTARTRawData()
{
  //
  // Destructor
  //
  if (fDigits) {
    delete fDigits;
    fDigits = NULL;
  }
  delete fTimeCFD;
  delete fADC1;
  delete fTimeLED;
  delete fADC0;
}

//_____________________________________________________________________________
AliSTARTRawData &AliSTARTRawData::operator=(const AliSTARTRawData &r)
{
  //
  // Assignment operator
  //

  if (this != &r) ((AliSTARTRawData &) r).Copy(*this);
  return *this;

}

//_____________________________________________________________________________
void AliSTARTRawData::GetDigits(AliSTARTdigit *fDigits)
{
 
  //This method packs the START digits in a proper 32 bits structure

  //read START digits and fill TDC and ADC arrays


  //  Int_t error=0;
  Int_t time,  positionOfTRMHeader;

    // Get the digits array

  fDigits->GetTime(*fTimeCFD);
  fDigits->GetADC(*fADC1);
  fDigits->GetTimeAmp(*fTimeLED);
  fDigits->GetADCAmp(*fADC0);
  Int_t meantime = fDigits->MeanTime(); 
  Int_t timediff = fDigits->TimeDiff(); 
  Int_t mult0=fDigits->SumMult();
  Int_t mult1=fDigits->SumMult();
  Int_t timeA = fDigits->BestTimeLeft();
  Int_t timeC = fDigits->BestTimeRight();


  TArrayI  *allData = new TArrayI(107);
  Int_t i=0;
  for (i=0; i<24; i++) {
    allData->AddAt(fTimeLED->At(i),i);
    allData->AddAt(fTimeCFD->At(i),i+24);
    allData->AddAt(fADC0->At(i),i+54);
    allData->AddAt(fADC1->At(i),i+78);
  }
    allData->AddAt(meantime,48);
    allData->AddAt(timediff,49);
    allData->AddAt(timediff,102); //trigger vertex
    allData->AddAt(timeA,50);
    allData->AddAt(timeA,103); //trigger T0A
    allData->AddAt(timeC,51);
    allData->AddAt(timeC,104); //trigger T0C
    allData->AddAt(mult0,52);
    allData->AddAt(mult1,105); //trigger central
    allData->AddAt(mult1,53);
    allData->AddAt(mult1,106); //trigger semi-central
  //space for DRM header
  fIndex += 4;

  //space for 1st TRM header
  fIndex ++;
  positionOfTRMHeader= fIndex;

  //space for chain  header
  fIndex ++;

  // Loop through all PMT
  Int_t chain=0; 
  Int_t iTDC = 0;
  Int_t channel=0;
  Int_t trm1words=0;
  Int_t fWordsIn1stTRM=0;
  //LED
  for (Int_t det = 0; det < 54; det++) {
    time = allData->At(det);

    if (time >0) { 
      FillTime(channel,  iTDC,  time); 
      trm1words++;   
     }
    if (channel < 6) channel +=2;
    else {
      channel = 0; 
      iTDC++;
      if (iTDC>15) { chain++; iTDC=0;}
    }
  }
  
  WriteTrailer(0,0,fEventNumber,1); // 1st chain trailer
  WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
  fWordsIn1stTRM = trm1words + 4;
  WriteTRMDataHeader(3, trm1words , positionOfTRMHeader);


  //space for 2st TRM header
  fIndex ++;
  positionOfTRMHeader= fIndex;

  //space for chain  header
  fIndex ++;


  chain=0; 
  iTDC = 0;
  channel=0;
  Int_t trm2words=0;
  for (Int_t det = 54; det < 107; det++) {
    time = allData->At(det);

    if (time >0) { 
      FillTime(channel,  iTDC,  time); 
      trm2words++;}
    if (channel < 6) channel +=2;
    else {
      channel = 0; 
      iTDC++;
      if (iTDC>15) { chain++; iTDC=0;}
    }
  }

  WriteTrailer(0,0,fEventNumber,1); // 1st chain trailer
  WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
  WriteTRMDataHeader(5,trm2words,positionOfTRMHeader);

  WriteTrailer(1,fEventNumber,0,5); //DRM trailer
  WriteDRMDataHeader();

}
//------------------------------------------------------------------------------
void AliSTARTRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
{
  
  // Build mask
  Int_t len=StopBit-StartBit+1;
  UInt_t mask=0;
  for(Int_t jb=0; jb<len; mask|=1<<jb++);
  // Check consistency
  if(Word > mask){
    Error("PackWord", "Word to be filled is not within desired length\n"
          "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
    return;
  }
  BaseWord=(BaseWord&~(mask<<StartBit))|Word<<StartBit;

}


//_____________________________________________________________________________

void  AliSTARTRawData::WriteDRMDataHeader()
{
//Write a (dummy or real) DDL DRM  data header, 
//set the compression bit if compressed
//  UInt_t drmheader[4];  
  UInt_t word;
  UInt_t baseWord=0;
  //fill DRM headers
  //DRM Global Header
  word = 1;
  PackWord(baseWord,word,0, 3); // 0001 
  word = fIndex ;

  PackWord(baseWord,word,4, 20); // event words 
  word=124;
  PackWord(baseWord,word,21,27); // DRM ID for T0 - 124
  word=4;
  PackWord(baseWord,word,28,31); // 0100 marks header
  fBuffer[0]=  baseWord;

  //DRM status header 1
  word = 1;
  PackWord(baseWord,word,0, 3); // 0001 
  word = 1;
  PackWord(baseWord,word,4, 14); // slotID now 0000000001
  word = 1;
  PackWord(baseWord,word,15, 15); //if 1  LHC clock is coorectly recieved from CPDM 
  word=0;
  PackWord(baseWord,word,16,27); // reserve for future use
  word=4;
  PackWord(baseWord,word,28,31); // 0100 marks header
   fBuffer[1] = baseWord;

  word=0;
  baseWord=0;

    //DRM status header 2
    word = 1;
    PackWord(baseWord,word, 0, 3); // 0001 
    word = 3;
    PackWord(baseWord,word, 4, 14); //enable slotID now 00000000011
    word = 0;
    PackWord(baseWord,word, 15, 15); // something
    word=0;
    PackWord(baseWord,word, 16, 27); // fault ID for simulation 0
    word=4;
    PackWord(baseWord,word,28,31); // 0100 marks header
    fBuffer[2]=  baseWord;

    
    word=0;
    baseWord=0;
    //DRM status header 3
    word = 1;
    PackWord(baseWord,word,0, 3); // 0001 
    word = 0;
    PackWord(baseWord,word,4, 27); // TTC event counter
    word=4;
    PackWord(baseWord,word,28,31); // 0100 marks header
    fBuffer[3]=  baseWord;


    word=0;
    baseWord=0;
    
}
  
//_____________________________________________________________________________

void  AliSTARTRawData::WriteTRMDataHeader(UInt_t slotID, Int_t nWordsInTRM,
					  Int_t  positionOfTRMHeader)
{
//Write a (dummy or real) DDL TRM  data header, 
//set the compression bit if compressed
//  UInt_t trmheader;  
  UInt_t word;
  UInt_t baseWord=0;
  //fill TRM headers
  //TRM Global Header
  word = slotID;
  PackWord(baseWord,word,0, 3); // slotID
  word = nWordsInTRM;
 //+this word - DRM header 

  PackWord(baseWord,word,4, 16); // event words 
  word=0;
  PackWord(baseWord,word,17,18); // ACQ
  word=0;
  PackWord(baseWord,word,19,19); //  L SEY inside LUT
  word=0;
  PackWord(baseWord,word,20,27); //  MBZ
  word=4;
  PackWord(baseWord,word,28,31); // 0100 marks header
  fBuffer[positionOfTRMHeader] =  baseWord;
   
  word=0; 
  baseWord=0;
     
}

//_____________________________________________________________________________

void  AliSTARTRawData::WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID)
{
//Write a (dummy or real) DDL Chain  data header, 
//set the compression bit if compressed
//  chainNumber 00 or 10
  UInt_t word;
  UInt_t baseWord=0;
  //fill TRM headers
  //TRM Global Header
  word = slotID; // ask Tatiana 7 or 9 
  PackWord(baseWord,word,0, 3); // slotID
  word = 0;
  PackWord(baseWord,word,4, 15); // bunchID
  word=0;
  PackWord(baseWord,word,16,23); // PB24 temperature
  word=0;
  PackWord(baseWord,word,24,26); //  PB24 ID
  word=0;
  PackWord(baseWord,word,27,27); //  TS
  word=chainNumber;
  PackWord(baseWord,word,28,31); // 0100 marks header
  fBuffer[4] =  baseWord;

  word=0;
  baseWord=0;     
  
}
//_____________________________________________________________________________

void  AliSTARTRawData::WriteDataHeader(Bool_t dummy, Bool_t compressed)
{
//Write a (dummy or real) DDL data header, 
//set the compression bit if compressed

  AliRawDataHeaderSim header;
  
  if (dummy) {
    //if size=0 it means that this data header is a dummy data header
    fDataHeaderPos = fFile->Tellp();
    fFile->WriteBuffer((char*)(&header), sizeof(header));
  } else {
    UInt_t currentFilePos = fFile->Tellp();
    fFile->Seekp(fDataHeaderPos);
    header.fSize = currentFilePos-fDataHeaderPos;
    header.SetAttribute(0);  // valid data
    if (compressed) header.SetAttribute(1); 
    fFile->WriteBuffer((char*)(&header), sizeof(header));
    fFile->Seekp(currentFilePos);
  }
  
}

//___ __________________________________________________________________________


void  AliSTARTRawData::WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t word3)
{

  UInt_t word;
  UInt_t baseWord=0;
  word = slot;
  PackWord(baseWord,word,0, 3); // 0001 
  word=word1;
  PackWord(baseWord,word,4, 15); // CRC ?
  word = word2;
  PackWord(baseWord,word,16,27); // event counter
  word=word3;
  PackWord(baseWord,word,28,31); //  marks trailer
  fIndex++;
  fBuffer[fIndex] =  baseWord;
  
  word=0;
  baseWord=0;

}

//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------
void  AliSTARTRawData::FillTime(Int_t ch, Int_t iTDC, Int_t time)
{
  UInt_t word;
  UInt_t baseWord=0;

  word=time;
  PackWord(baseWord,word, 0, 20); // Time 

  word=ch;
  PackWord(baseWord,word, 21, 23); // number of channel 
  word=iTDC;
  PackWord(baseWord,word, 24, 27); // TDC ID

  word=0;
  PackWord(baseWord,word, 28, 28); // E = 0 in simulation
  word=0;
  PackWord(baseWord,word, 29, 30); // PS bit data 00
  word=1;
  PackWord(baseWord,word, 31, 31); // 1
  fIndex++;
  fBuffer[fIndex]=baseWord;
  word=0;
  baseWord=0;
	
}
//---------------------------------------------------------------------------------------

Int_t AliSTARTRawData::RawDataSTART(AliSTARTdigit *fDigits)
{
   //This method creates the Raw data files for START detector


  // const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector() 
                          //max number of digits per DDL file times 2
  //  UInt_t fBuffer[kSize];
  //  UInt_t baseWord;
  // UInt_t word;

  fIndex=-1;
 
  AliRawDataHeaderSim header;
  //loop over TOF DDL files
    //write Dummy DATA HEADER
   WriteDataHeader(kTRUE, kFALSE);
  GetDigits(fDigits);
  //write packing digits
  fFile->WriteBuffer((char*) fBuffer,((fIndex+1)*sizeof(UInt_t)));
  //write real data header on its place
   WriteDataHeader(kFALSE, kFALSE);
  
  
  //end for
  
  return 0;  
  
}
Commit	Line	Data
e4da63c2	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	// START raw data conversion class //
	21	// //
	22	///////////////////////////////////////////////////////////////////////////////
	23
	24	#include <Riostream.h>
460b4363	25	#include <TTree.h>
e4da63c2	26
	27	#include "AliSTART.h"
	28	#include "AliSTARTRawData.h"
	29	#include "AliSTARTdigit.h"
460b4363	30	#include "AliBitPacking.h"
19edf72f	31	#include "AliRawDataHeader.h"
61be8c4a	32	#include "AliRawDataHeaderSim.h"
460b4363	33	#include "AliBitPacking.h"
61be8c4a	34	#include "AliFstream.h"
61be8c4a	35	#include "AliRunLoader.h"
e4da63c2	36
	37	ClassImp(AliSTARTRawData)
	38
	39	//_____________________________________________________________________________
	40	AliSTARTRawData::AliSTARTRawData():TObject()
	41	{
06fb27f4	42	/*
	43	- 48 channels (2 words each as in TOF DDL) for :
	44	word 1 :0-5bit number of PMT; word 2: 0-7 error sign, 8-31 TDC
	45	and the same but for amplified signal. Now I wrote the same time because
	46	CDF are not ready and differences didn't measured yet.
	47
460b4363	48	- 48 channel for amplitude: very preliminary, QTC features are not
06fb27f4	49	known now, preliminary i put as T1 time signal for this PMT in first
	50	channel and T1+A in second, where A=Log(Amplitude);
	51	and the same for amplified but A=Log(10*Amplitude).
	52
	53	- T0-A and T0-C 2 channels
	54	- T0A-T0C vertex information
	55	- Time Meaner where T0C TOF increase to the T0A TOF distance
	56	- 6 multiplicity signals the same way as amplitude and with the same
	57	uncertances
	58	*/
e4da63c2	59
	60	fIndex=-1;
	61	fDigits = NULL;
db173afc	62
460b4363	63	fTimeCFD = new TArrayI(24);
61be8c4a	64	fADC1 = new TArrayI(24);
460b4363	65	fTimeLED = new TArrayI(24);
460b4363	66	fADC0 = new TArrayI(24);
61be8c4a	67	fFile = NULL;
	68	fDataHeaderPos = 0;
	69	fDRMDataHeaderPos = 0;
	70	memset(fBuffer,0,512*sizeof(UInt_t));
	71
	72	//open the output file
	73	char fileName[15];
	74	sprintf(fileName,"START_%d.ddl", 0xd00);
	75	fFile = new AliFstream(fileName);
	76	//get event number
	77	AliRunLoader *runloader = AliRunLoader::GetRunLoader();
	78	if (runloader) {
	79	fEventNumber = runloader->GetEventNumber();
	80	}
e4da63c2	81	}
	82
	83	//_____________________________________________________________________________
	84	AliSTARTRawData::AliSTARTRawData(const AliSTARTRawData &r):TObject()
	85	{
	86	//
	87	// AliSTARTrawData copy constructor
	88	//
	89
	90	((AliSTARTRawData &) r).Copy(*this);
	91
	92	}
	93
	94	//_____________________________________________________________________________
	95	AliSTARTRawData::~AliSTARTRawData()
	96	{
	97	//
	98	// Destructor
	99	//
e4da63c2	100	if (fDigits) {
	101	delete fDigits;
	102	fDigits = NULL;
e4da63c2	103	}
460b4363	104	delete fTimeCFD;
61be8c4a	105	delete fADC1;
460b4363	106	delete fTimeLED;
460b4363	107	delete fADC0;
e4da63c2	108	}
	109
	110	//_____________________________________________________________________________
	111	AliSTARTRawData &AliSTARTRawData::operator=(const AliSTARTRawData &r)
	112	{
	113	//
	114	// Assignment operator
	115	//
	116
	117	if (this != &r) ((AliSTARTRawData &) r).Copy(*this);
	118	return *this;
	119
	120	}
	121
	122	//_____________________________________________________________________________
61be8c4a	123	void AliSTARTRawData::GetDigits(AliSTARTdigit *fDigits)
e4da63c2	124	{
	125
	126	//This method packs the START digits in a proper 32 bits structure
	127
	128	//read START digits and fill TDC and ADC arrays
	129
db173afc	130
61be8c4a	131	// Int_t error=0;
61be8c4a	132	Int_t time, positionOfTRMHeader;
4c7da157	133
db173afc	134	// Get the digits array
e4da63c2	135
460b4363	136	fDigits->GetTime(*fTimeCFD);
61be8c4a	137	fDigits->GetADC(*fADC1);
460b4363	138	fDigits->GetTimeAmp(*fTimeLED);
460b4363	139	fDigits->GetADCAmp(*fADC0);
90c070c8	140	Int_t meantime = fDigits->MeanTime();
90c070c8	141	Int_t timediff = fDigits->TimeDiff();
61be8c4a	142	Int_t mult0=fDigits->SumMult();
	143	Int_t mult1=fDigits->SumMult();
	144	Int_t timeA = fDigits->BestTimeLeft();
	145	Int_t timeC = fDigits->BestTimeRight();
	146
	147
	148	TArrayI *allData = new TArrayI(107);
	149	Int_t i=0;
	150	for (i=0; i<24; i++) {
	151	allData->AddAt(fTimeLED->At(i),i);
	152	allData->AddAt(fTimeCFD->At(i),i+24);
	153	allData->AddAt(fADC0->At(i),i+54);
	154	allData->AddAt(fADC1->At(i),i+78);
460b4363	155	}
61be8c4a	156	allData->AddAt(meantime,48);
	157	allData->AddAt(timediff,49);
	158	allData->AddAt(timediff,102); //trigger vertex
	159	allData->AddAt(timeA,50);
	160	allData->AddAt(timeA,103); //trigger T0A
	161	allData->AddAt(timeC,51);
	162	allData->AddAt(timeC,104); //trigger T0C
	163	allData->AddAt(mult0,52);
	164	allData->AddAt(mult1,105); //trigger central
	165	allData->AddAt(mult1,53);
	166	allData->AddAt(mult1,106); //trigger semi-central
	167	//space for DRM header
	168	fIndex += 4;
	169
	170	//space for 1st TRM header
	171	fIndex ++;
	172	positionOfTRMHeader= fIndex;
	173
	174	//space for chain header
	175	fIndex ++;
	176
	177	// Loop through all PMT
	178	Int_t chain=0;
	179	Int_t iTDC = 0;
	180	Int_t channel=0;
	181	Int_t trm1words=0;
	182	Int_t fWordsIn1stTRM=0;
	183	//LED
	184	for (Int_t det = 0; det < 54; det++) {
	185	time = allData->At(det);
	186
	187	if (time >0) {
	188	FillTime(channel, iTDC, time);
	189	trm1words++;
	190	}
	191	if (channel < 6) channel +=2;
	192	else {
	193	channel = 0;
	194	iTDC++;
	195	if (iTDC>15) { chain++; iTDC=0;}
	196	}
460b4363	197	}
460b4363	198
61be8c4a	199	WriteTrailer(0,0,fEventNumber,1); // 1st chain trailer
	200	WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
	201	fWordsIn1stTRM = trm1words + 4;
	202	WriteTRMDataHeader(3, trm1words , positionOfTRMHeader);
	203
	204
	205	//space for 2st TRM header
	206	fIndex ++;
	207	positionOfTRMHeader= fIndex;
	208
	209	//space for chain header
	210	fIndex ++;
	211
	212
	213	chain=0;
	214	iTDC = 0;
	215	channel=0;
	216	Int_t trm2words=0;
	217	for (Int_t det = 54; det < 107; det++) {
	218	time = allData->At(det);
	219
	220	if (time >0) {
	221	FillTime(channel, iTDC, time);
	222	trm2words++;}
	223	if (channel < 6) channel +=2;
	224	else {
	225	channel = 0;
	226	iTDC++;
	227	if (iTDC>15) { chain++; iTDC=0;}
	228	}
460b4363	229	}
e4da63c2	230
61be8c4a	231	WriteTrailer(0,0,fEventNumber,1); // 1st chain trailer
	232	WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
	233	WriteTRMDataHeader(5,trm2words,positionOfTRMHeader);
db173afc	234
61be8c4a	235	WriteTrailer(1,fEventNumber,0,5); //DRM trailer
61be8c4a	236	WriteDRMDataHeader();
db173afc	237
61be8c4a	238	}
	239	//------------------------------------------------------------------------------
	240	void AliSTARTRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
	241	{
	242
	243	// Build mask
	244	Int_t len=StopBit-StartBit+1;
	245	UInt_t mask=0;
	246	for(Int_t jb=0; jb<len; mask\|=1<<jb++);
	247	// Check consistency
	248	if(Word > mask){
	249	Error("PackWord", "Word to be filled is not within desired length\n"
	250	"Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
	251	return;
	252	}
	253	BaseWord=(BaseWord&~(mask<<StartBit))\|Word<<StartBit;
e4da63c2	254
61be8c4a	255	}
db173afc	256
db173afc	257
61be8c4a	258	//_____________________________________________________________________________
2e57e601	259
61be8c4a	260	void AliSTARTRawData::WriteDRMDataHeader()
	261	{
	262	//Write a (dummy or real) DDL DRM data header,
	263	//set the compression bit if compressed
	264	// UInt_t drmheader[4];
	265	UInt_t word;
	266	UInt_t baseWord=0;
	267	//fill DRM headers
	268	//DRM Global Header
	269	word = 1;
	270	PackWord(baseWord,word,0, 3); // 0001
	271	word = fIndex ;
	272
	273	PackWord(baseWord,word,4, 20); // event words
	274	word=124;
	275	PackWord(baseWord,word,21,27); // DRM ID for T0 - 124
	276	word=4;
	277	PackWord(baseWord,word,28,31); // 0100 marks header
	278	fBuffer[0]= baseWord;
	279
	280	//DRM status header 1
	281	word = 1;
	282	PackWord(baseWord,word,0, 3); // 0001
	283	word = 1;
	284	PackWord(baseWord,word,4, 14); // slotID now 0000000001
	285	word = 1;
	286	PackWord(baseWord,word,15, 15); //if 1 LHC clock is coorectly recieved from CPDM
	287	word=0;
	288	PackWord(baseWord,word,16,27); // reserve for future use
	289	word=4;
	290	PackWord(baseWord,word,28,31); // 0100 marks header
	291	fBuffer[1] = baseWord;
db173afc	292
61be8c4a	293	word=0;
db173afc	294	baseWord=0;
460b4363	295
61be8c4a	296	//DRM status header 2
	297	word = 1;
	298	PackWord(baseWord,word, 0, 3); // 0001
	299	word = 3;
	300	PackWord(baseWord,word, 4, 14); //enable slotID now 00000000011
	301	word = 0;
	302	PackWord(baseWord,word, 15, 15); // something
	303	word=0;
	304	PackWord(baseWord,word, 16, 27); // fault ID for simulation 0
	305	word=4;
	306	PackWord(baseWord,word,28,31); // 0100 marks header
	307	fBuffer[2]= baseWord;
0cd34ffa	308
61be8c4a	309
	310	word=0;
	311	baseWord=0;
	312	//DRM status header 3
	313	word = 1;
	314	PackWord(baseWord,word,0, 3); // 0001
	315	word = 0;
	316	PackWord(baseWord,word,4, 27); // TTC event counter
	317	word=4;
	318	PackWord(baseWord,word,28,31); // 0100 marks header
	319	fBuffer[3]= baseWord;
0cd34ffa	320
db173afc	321
61be8c4a	322	word=0;
	323	baseWord=0;
	324
	325	}
	326
	327	//_____________________________________________________________________________
db173afc	328
61be8c4a	329	void AliSTARTRawData::WriteTRMDataHeader(UInt_t slotID, Int_t nWordsInTRM,
	330	Int_t positionOfTRMHeader)
	331	{
	332	//Write a (dummy or real) DDL TRM data header,
	333	//set the compression bit if compressed
	334	// UInt_t trmheader;
	335	UInt_t word;
	336	UInt_t baseWord=0;
	337	//fill TRM headers
	338	//TRM Global Header
	339	word = slotID;
	340	PackWord(baseWord,word,0, 3); // slotID
	341	word = nWordsInTRM;
	342	//+this word - DRM header
	343
	344	PackWord(baseWord,word,4, 16); // event words
	345	word=0;
	346	PackWord(baseWord,word,17,18); // ACQ
	347	word=0;
	348	PackWord(baseWord,word,19,19); // L SEY inside LUT
	349	word=0;
	350	PackWord(baseWord,word,20,27); // MBZ
	351	word=4;
	352	PackWord(baseWord,word,28,31); // 0100 marks header
	353	fBuffer[positionOfTRMHeader] = baseWord;
	354
	355	word=0;
e4da63c2	356	baseWord=0;
61be8c4a	357
61be8c4a	358	}
db173afc	359
61be8c4a	360	//_____________________________________________________________________________
db173afc	361
61be8c4a	362	void AliSTARTRawData::WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID)
	363	{
	364	//Write a (dummy or real) DDL Chain data header,
	365	//set the compression bit if compressed
	366	// chainNumber 00 or 10
	367	UInt_t word;
	368	UInt_t baseWord=0;
	369	//fill TRM headers
	370	//TRM Global Header
	371	word = slotID; // ask Tatiana 7 or 9
	372	PackWord(baseWord,word,0, 3); // slotID
	373	word = 0;
	374	PackWord(baseWord,word,4, 15); // bunchID
	375	word=0;
	376	PackWord(baseWord,word,16,23); // PB24 temperature
	377	word=0;
	378	PackWord(baseWord,word,24,26); // PB24 ID
	379	word=0;
	380	PackWord(baseWord,word,27,27); // TS
	381	word=chainNumber;
	382	PackWord(baseWord,word,28,31); // 0100 marks header
	383	fBuffer[4] = baseWord;
db173afc	384
61be8c4a	385	word=0;
	386	baseWord=0;
	387
	388	}
	389	//_____________________________________________________________________________
db173afc	390
61be8c4a	391	void AliSTARTRawData::WriteDataHeader(Bool_t dummy, Bool_t compressed)
	392	{
	393	//Write a (dummy or real) DDL data header,
	394	//set the compression bit if compressed
db173afc	395
61be8c4a	396	AliRawDataHeaderSim header;
460b4363	397
61be8c4a	398	if (dummy) {
	399	//if size=0 it means that this data header is a dummy data header
	400	fDataHeaderPos = fFile->Tellp();
	401	fFile->WriteBuffer((char*)(&header), sizeof(header));
	402	} else {
	403	UInt_t currentFilePos = fFile->Tellp();
	404	fFile->Seekp(fDataHeaderPos);
	405	header.fSize = currentFilePos-fDataHeaderPos;
	406	header.SetAttribute(0); // valid data
	407	if (compressed) header.SetAttribute(1);
	408	fFile->WriteBuffer((char*)(&header), sizeof(header));
	409	fFile->Seekp(currentFilePos);
	410	}
460b4363	411
61be8c4a	412	}
	413
	414	//___ __________________________________________________________________________
	415
	416
	417	void AliSTARTRawData::WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t word3)
	418	{
	419
	420	UInt_t word;
	421	UInt_t baseWord=0;
	422	word = slot;
	423	PackWord(baseWord,word,0, 3); // 0001
	424	word=word1;
	425	PackWord(baseWord,word,4, 15); // CRC ?
	426	word = word2;
	427	PackWord(baseWord,word,16,27); // event counter
	428	word=word3;
	429	PackWord(baseWord,word,28,31); // marks trailer
460b4363	430	fIndex++;
61be8c4a	431	fBuffer[fIndex] = baseWord;
460b4363	432
61be8c4a	433	word=0;
460b4363	434	baseWord=0;
2e57e601	435
e4da63c2	436	}
e4da63c2	437
61be8c4a	438	//---------------------------------------------------------------------------------------
	439	//---------------------------------------------------------------------------------------
	440	void AliSTARTRawData::FillTime(Int_t ch, Int_t iTDC, Int_t time)
e4da63c2	441	{
61be8c4a	442	UInt_t word;
61be8c4a	443	UInt_t baseWord=0;
2e57e601	444
61be8c4a	445	word=time;
61be8c4a	446	PackWord(baseWord,word, 0, 20); // Time
2e57e601	447
61be8c4a	448	word=ch;
	449	PackWord(baseWord,word, 21, 23); // number of channel
	450	word=iTDC;
	451	PackWord(baseWord,word, 24, 27); // TDC ID
4c7da157	452
61be8c4a	453	word=0;
	454	PackWord(baseWord,word, 28, 28); // E = 0 in simulation
	455	word=0;
	456	PackWord(baseWord,word, 29, 30); // PS bit data 00
	457	word=1;
	458	PackWord(baseWord,word, 31, 31); // 1
	459	fIndex++;
	460	fBuffer[fIndex]=baseWord;
	461	word=0;
	462	baseWord=0;
	463
	464	}
e4da63c2	465	//---------------------------------------------------------------------------------------
e4da63c2	466
06fb27f4	467	Int_t AliSTARTRawData::RawDataSTART(AliSTARTdigit *fDigits)
	468	{
	469	//This method creates the Raw data files for START detector
	470
	471
61be8c4a	472	// const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector()
e4da63c2	473	//max number of digits per DDL file times 2
61be8c4a	474	// UInt_t fBuffer[kSize];
	475	// UInt_t baseWord;
	476	// UInt_t word;
e4da63c2	477
e4da63c2	478	fIndex=-1;
61be8c4a	479
61be8c4a	480	AliRawDataHeaderSim header;
e4da63c2	481	//loop over TOF DDL files
e4da63c2	482	//write Dummy DATA HEADER
61be8c4a	483	WriteDataHeader(kTRUE, kFALSE);
	484	GetDigits(fDigits);
	485	//write packing digits
	486	fFile->WriteBuffer((char) fBuffer,((fIndex+1)sizeof(UInt_t)));
	487	//write real data header on its place
	488	WriteDataHeader(kFALSE, kFALSE);
	489
	490
	491	//end for
	492
e4da63c2	493	return 0;
	494
	495	}