[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 "AliSTART.h"
#include "AliSTARTRawData.h"
#include "AliSTARTdigit.h"
//#include "AliSTARTLoader.h"

#include <AliLoader.h>
#include <AliRunLoader.h>
#include <TClonesArray.h>
#include <TTree.h>
#include "AliRawDataHeader.h"

ClassImp(AliSTARTRawData)

//_____________________________________________________________________________
AliSTARTRawData::AliSTARTRawData():TObject()
{


  fIndex=-1;
  fDigits = NULL;

  ftimeTDC = new TArrayI(24);
  fADC = new TArrayI(24);
  ftimeTDCAmp = new TArrayI(24);
  fADCAmp = new TArrayI(24);
  fSumMult = new TArrayI(6);
   //   this->Dump();
  
}

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

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

}

//_____________________________________________________________________________
AliSTARTRawData::~AliSTARTRawData()
{
  //
  // Destructor
  //
  if (fDigits) {
    delete fDigits;
    fDigits = NULL;
  }
  delete ftimeTDC;
  delete fADC;
  delete ftimeTDCAmp;
  delete fADCAmp;
  delete fSumMult;
}

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

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

}

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

  //read START digits and fill TDC and ADC arrays


  UInt_t word;
  UInt_t baseWord=0;
  Int_t error=0;
    // Get the digits array

  fDigits->GetTime(*ftimeTDC);
  fDigits->GetADC(*fADC);
  fDigits->GetTimeAmp(*ftimeTDCAmp);
  fDigits->GetADCAmp(*fADCAmp);
  fDigits->GetSumMult(*fSumMult);
     
  // Loop through all PMT
 
  for (Int_t det = 0; det < 24; det++) {
    Int_t time=ftimeTDC->At(det);
    Int_t qtc=fADC->At(det);
    Int_t timeAmp=ftimeTDCAmp->At(det);
    Int_t qtcAmp=fADCAmp->At(det);

    //conver ADC to time (preliminary algorithm)

     // DDL 1 0-5 -#PMT, 6-31 - empty

     word=det;;
     PackWord(baseWord,word, 0, 5); 
     fIndex++;
     buf[fIndex]=baseWord;

     word=0;
     baseWord=0;

     //TDC    
     word=error;
     PackWord(baseWord,word,0, 7); // Error flag
     word=time;
     PackWord(baseWord,word,8,31); // time-of-flight
     fIndex++;
     buf[fIndex]=baseWord;

     word=0;
     baseWord=0;
    
    // DDL2 2 0-5 -#PMT, 6-31 - empty
     word=det;;
     PackWord(baseWord,word, 0, 5); // number of PMT on the right side
     fIndex++;
     buf[fIndex]=baseWord;
     word=0;
     baseWord=0;

     //  amplified TDC    
     word=error;
     PackWord(baseWord,word,0, 7); // Error flag
     word=timeAmp;
     PackWord(baseWord,word,8,31); // time-of-flight
     fIndex++;
     buf[fIndex]=baseWord;

     word=0;
     baseWord=0;

     // DDL 3
     word=det;;
     PackWord(baseWord,word, 0, 5); // number of PMT on the right side
     fIndex++;
     buf[fIndex]=baseWord;
     word=0;
     baseWord=0;

     // ADC -> TDC     
     word=error;
     PackWord(baseWord,word,0, 7); // Error flag
     word=time;
     PackWord(baseWord,word,8,31); // time-of-flight
     fIndex++;
     buf[fIndex]=baseWord;


     // ADC -> TDC :QTC 
     word=0;
     baseWord=0;

     word=det;;
     PackWord(baseWord,word, 0, 5); // number of PMT on the right side
     fIndex++;
     buf[fIndex]=baseWord;
     baseWord=0;
     word=error;
     PackWord(baseWord,word,0, 7); // Error flag
     word=time+qtc;
     PackWord(baseWord,word,8,31); // time-of-flight
     fIndex++;
     buf[fIndex]=baseWord;

     word=0;
     baseWord=0;

    // DDL 4 amplified QTC charge * 10
     word=det;;
     PackWord(baseWord,word, 0, 5); // number of PMT on the right side
     fIndex++;
     buf[fIndex]=baseWord;
     word=0;
     baseWord=0;

     // ADC -> TDC     
     word=error;
     PackWord(baseWord,word,0, 7); // Error flag
     word=timeAmp;
     PackWord(baseWord,word,8,31); // time-of-flight
     fIndex++;
     buf[fIndex]=baseWord;

     //Amplified  ADC -> TDC 
     word=0;
     baseWord=0;

     word=det;;
     PackWord(baseWord,word, 0, 5); // number of PMT on the right side
     fIndex++;
     buf[fIndex]=baseWord;
     baseWord=0;
     word=error;
     PackWord(baseWord,word,0, 7); // Error flag
     word=time+qtcAmp;
     PackWord(baseWord,word,8,31); // time-of-flight
     fIndex++;
     buf[fIndex]=baseWord;

     word=0;
     baseWord=0;
 }


  word=0;
  baseWord=0;
  fIndex++;
  word=25;
  PackWord(baseWord,word, 0, 5); // number of PMT on the right side
  word=fDigits->MeanTime();
  PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
  buf[fIndex]=baseWord;

  baseWord=0;
  word=error;
  PackWord(baseWord,word,0, 7); // Error flag
  word=fDigits->MeanTime();
  PackWord(baseWord,word,8,31); // time-of-flight
  fIndex++;
  buf[fIndex]=baseWord;


  // besttime right & left
  //  fIndex++;
  //  buf[fIndex]=baseWord;
  word=26;
  PackWord(baseWord,word, 0, 5); // number of PMT on the right side
  word=fDigits->BestTimeRight();
  PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
  fIndex++;
  buf[fIndex]=baseWord;

  baseWord=0;
  word=error;
  PackWord(baseWord,word,0, 7); // Error flag
  word=fDigits->BestTimeRight();
  PackWord(baseWord,word,8,31); // time-of-flight
  fIndex++;
  buf[fIndex]=baseWord;

  word=27;
  PackWord(baseWord,word, 0, 5); // number of PMT on the right side
  word=fDigits->BestTimeLeft();
  PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
  fIndex++;
  buf[fIndex]=baseWord;

  baseWord=0;

  word=error;
  PackWord(baseWord,word,0, 7); // Error flag
  word=fDigits->BestTimeLeft();
  PackWord(baseWord,word,8,31); // time-of-flight
  fIndex++;
  buf[fIndex]=baseWord;

  // time difference
  word=28;
  PackWord(baseWord,word, 0, 5); // number of PMT on the right side
  word=fDigits->TimeDiff();
  PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
  fIndex++;
  buf[fIndex]=baseWord;

  baseWord=0;

  word=error;
  PackWord(baseWord,word,0, 7); // Error flag
  word=fDigits->TimeDiff();
  PackWord(baseWord,word,8,31); // time-of-flight
  fIndex++;
  buf[fIndex]=baseWord;

  // multiplicity 

  for (Int_t i=0; i<6; i++)
    {
      Int_t mult=fSumMult->At(i);
      word=29+i;
      PackWord(baseWord,word, 0, 5); 
      word=mult;
      PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
      fIndex++;
      buf[fIndex]=baseWord;
      
      baseWord=0;
      word=error;
      PackWord(baseWord,word,0, 7); // Error flag
      word=mult;
      PackWord(baseWord,word,8,31); // time QTC
      fIndex++;
      buf[fIndex]=baseWord;
    }
  cout<<endl;
}

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

void AliSTARTRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
{
  //This method packs a word into the Baseword buffer starting form the "StartBit" 
  //and tacking StopBit-StartBit+1 bits
  UInt_t dummyWord,offSet;
  Int_t  length;
  UInt_t sum;
  //The BaseWord is being filled with 1 from StartBit to StopBit
  length=StopBit-StartBit+1;
  sum=(UInt_t)TMath::Power(2,length)-1;

  if(Word > sum){
    Error("PackWord", "Word to be filled is not within desired length\n"
	  "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
    return;
  }
  offSet=sum;
  offSet<<=StartBit;
  BaseWord=BaseWord|offSet;

  //The Word to be filled is shifted to the position StartBit
  //and the remaining  Left and Right bits are filled with 1
  sum=(UInt_t)TMath::Power(2,StartBit)-1;
  dummyWord=0xFFFFFFFF<<length;
  dummyWord +=Word;
  dummyWord<<=StartBit;
  dummyWord+=sum;
  BaseWord=BaseWord&dummyWord;

  return;
}
//---------------------------------------------------------------------------------------

Int_t AliSTARTRawData::RawDataSTART(AliSTARTdigit *fDigits){
  
  //This method creates the Raw data files for TOF detector
  const Int_t kSize=512; //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
  sprintf(fileName,"START_%d.ddl", 0xd00);
  //   sprintf(fileName,"START_0xd00.ddl"); //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=0;
    PackWord(baseWord,word,0, 31); // Number of DDL file

    fIndex++;
    buf[fIndex]=baseWord;
    GetDigits(fDigits,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;  
  
}
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>
	25
	26	#include "AliSTART.h"
	27	#include "AliSTARTRawData.h"
	28	#include "AliSTARTdigit.h"
db173afc	29	//#include "AliSTARTLoader.h"
e4da63c2	30
	31	#include <AliLoader.h>
	32	#include <AliRunLoader.h>
db173afc	33	#include <TClonesArray.h>
db173afc	34	#include <TTree.h>
19edf72f	35	#include "AliRawDataHeader.h"
e4da63c2	36
	37	ClassImp(AliSTARTRawData)
	38
	39	//_____________________________________________________________________________
	40	AliSTARTRawData::AliSTARTRawData():TObject()
	41	{
	42
	43
	44	fIndex=-1;
	45	fDigits = NULL;
db173afc	46
	47	ftimeTDC = new TArrayI(24);
	48	fADC = new TArrayI(24);
	49	ftimeTDCAmp = new TArrayI(24);
	50	fADCAmp = new TArrayI(24);
	51	fSumMult = new TArrayI(6);
	52	// this->Dump();
e4da63c2	53
	54	}
	55
	56	//_____________________________________________________________________________
	57	AliSTARTRawData::AliSTARTRawData(const AliSTARTRawData &r):TObject()
	58	{
	59	//
	60	// AliSTARTrawData copy constructor
	61	//
	62
	63	((AliSTARTRawData &) r).Copy(*this);
	64
	65	}
	66
	67	//_____________________________________________________________________________
	68	AliSTARTRawData::~AliSTARTRawData()
	69	{
	70	//
	71	// Destructor
	72	//
e4da63c2	73	if (fDigits) {
	74	delete fDigits;
	75	fDigits = NULL;
e4da63c2	76	}
db173afc	77	delete ftimeTDC;
	78	delete fADC;
	79	delete ftimeTDCAmp;
	80	delete fADCAmp;
	81	delete fSumMult;
e4da63c2	82	}
	83
	84	//_____________________________________________________________________________
	85	AliSTARTRawData &AliSTARTRawData::operator=(const AliSTARTRawData &r)
	86	{
	87	//
	88	// Assignment operator
	89	//
	90
	91	if (this != &r) ((AliSTARTRawData &) r).Copy(*this);
	92	return *this;
	93
	94	}
	95
	96	//_____________________________________________________________________________
	97	void AliSTARTRawData::GetDigits(AliSTARTdigit fDigits, UInt_t buf)
	98	{
	99
	100	//This method packs the START digits in a proper 32 bits structure
	101
	102	//read START digits and fill TDC and ADC arrays
	103
db173afc	104
e4da63c2	105	UInt_t word;
	106	UInt_t baseWord=0;
	107	Int_t error=0;
db173afc	108	// Get the digits array
e4da63c2	109
db173afc	110	fDigits->GetTime(*ftimeTDC);
	111	fDigits->GetADC(*fADC);
	112	fDigits->GetTimeAmp(*ftimeTDCAmp);
	113	fDigits->GetADCAmp(*fADCAmp);
	114	fDigits->GetSumMult(*fSumMult);
e4da63c2	115
	116	// Loop through all PMT
	117
e4da63c2	118	for (Int_t det = 0; det < 24; det++) {
e4da63c2	119	Int_t time=ftimeTDC->At(det);
db173afc	120	Int_t qtc=fADC->At(det);
	121	Int_t timeAmp=ftimeTDCAmp->At(det);
	122	Int_t qtcAmp=fADCAmp->At(det);
e4da63c2	123
db173afc	124	//conver ADC to time (preliminary algorithm)
e4da63c2	125
	126	// DDL 1 0-5 -#PMT, 6-31 - empty
	127
	128	word=det;;
	129	PackWord(baseWord,word, 0, 5);
	130	fIndex++;
	131	buf[fIndex]=baseWord;
	132
	133	word=0;
	134	baseWord=0;
	135
db173afc	136	//TDC
e4da63c2	137	word=error;
	138	PackWord(baseWord,word,0, 7); // Error flag
	139	word=time;
	140	PackWord(baseWord,word,8,31); // time-of-flight
	141	fIndex++;
	142	buf[fIndex]=baseWord;
db173afc	143
e4da63c2	144	word=0;
	145	baseWord=0;
	146
	147	// DDL2 2 0-5 -#PMT, 6-31 - empty
	148	word=det;;
	149	PackWord(baseWord,word, 0, 5); // number of PMT on the right side
	150	fIndex++;
	151	buf[fIndex]=baseWord;
	152	word=0;
	153	baseWord=0;
	154
	155	// amplified TDC
	156	word=error;
	157	PackWord(baseWord,word,0, 7); // Error flag
db173afc	158	word=timeAmp;
e4da63c2	159	PackWord(baseWord,word,8,31); // time-of-flight
	160	fIndex++;
	161	buf[fIndex]=baseWord;
db173afc	162
e4da63c2	163	word=0;
	164	baseWord=0;
	165
	166	// DDL 3
	167	word=det;;
	168	PackWord(baseWord,word, 0, 5); // number of PMT on the right side
	169	fIndex++;
	170	buf[fIndex]=baseWord;
	171	word=0;
	172	baseWord=0;
	173
	174	// ADC -> TDC
	175	word=error;
	176	PackWord(baseWord,word,0, 7); // Error flag
db173afc	177	word=time;
e4da63c2	178	PackWord(baseWord,word,8,31); // time-of-flight
	179	fIndex++;
	180	buf[fIndex]=baseWord;
	181
db173afc	182
db173afc	183	// ADC -> TDC :QTC
e4da63c2	184	word=0;
	185	baseWord=0;
	186
	187	word=det;;
	188	PackWord(baseWord,word, 0, 5); // number of PMT on the right side
	189	fIndex++;
	190	buf[fIndex]=baseWord;
	191	baseWord=0;
	192	word=error;
	193	PackWord(baseWord,word,0, 7); // Error flag
db173afc	194	word=time+qtc;
e4da63c2	195	PackWord(baseWord,word,8,31); // time-of-flight
	196	fIndex++;
	197	buf[fIndex]=baseWord;
db173afc	198
e4da63c2	199	word=0;
	200	baseWord=0;
	201
db173afc	202	// DDL 4 amplified QTC charge * 10
	203	word=det;;
	204	PackWord(baseWord,word, 0, 5); // number of PMT on the right side
	205	fIndex++;
	206	buf[fIndex]=baseWord;
	207	word=0;
	208	baseWord=0;
e4da63c2	209
db173afc	210	// ADC -> TDC
	211	word=error;
	212	PackWord(baseWord,word,0, 7); // Error flag
	213	word=timeAmp;
	214	PackWord(baseWord,word,8,31); // time-of-flight
	215	fIndex++;
	216	buf[fIndex]=baseWord;
	217
	218	//Amplified ADC -> TDC
	219	word=0;
	220	baseWord=0;
	221
	222	word=det;;
	223	PackWord(baseWord,word, 0, 5); // number of PMT on the right side
	224	fIndex++;
	225	buf[fIndex]=baseWord;
	226	baseWord=0;
	227	word=error;
	228	PackWord(baseWord,word,0, 7); // Error flag
	229	word=time+qtcAmp;
	230	PackWord(baseWord,word,8,31); // time-of-flight
	231	fIndex++;
	232	buf[fIndex]=baseWord;
	233
	234	word=0;
	235	baseWord=0;
e4da63c2	236	}
db173afc	237
	238
	239	word=0;
	240	baseWord=0;
e4da63c2	241	fIndex++;
e4da63c2	242	word=25;
e4da63c2	243	PackWord(baseWord,word, 0, 5); // number of PMT on the right side
db173afc	244	word=fDigits->MeanTime();
e4da63c2	245	PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
e4da63c2	246	buf[fIndex]=baseWord;
db173afc	247
e4da63c2	248	baseWord=0;
e4da63c2	249	word=error;
e4da63c2	250	PackWord(baseWord,word,0, 7); // Error flag
db173afc	251	word=fDigits->MeanTime();
e4da63c2	252	PackWord(baseWord,word,8,31); // time-of-flight
e4da63c2	253	fIndex++;
e4da63c2	254	buf[fIndex]=baseWord;
e4da63c2	255
db173afc	256
db173afc	257
e4da63c2	258	// besttime right & left
db173afc	259	// fIndex++;
db173afc	260	// buf[fIndex]=baseWord;
e4da63c2	261	word=26;
e4da63c2	262	PackWord(baseWord,word, 0, 5); // number of PMT on the right side
db173afc	263	word=fDigits->BestTimeRight();
e4da63c2	264	PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
e4da63c2	265	fIndex++;
e4da63c2	266	buf[fIndex]=baseWord;
db173afc	267
e4da63c2	268	baseWord=0;
e4da63c2	269	word=error;
e4da63c2	270	PackWord(baseWord,word,0, 7); // Error flag
db173afc	271	word=fDigits->BestTimeRight();
e4da63c2	272	PackWord(baseWord,word,8,31); // time-of-flight
e4da63c2	273	fIndex++;
e4da63c2	274	buf[fIndex]=baseWord;
db173afc	275
e4da63c2	276	word=27;
e4da63c2	277	PackWord(baseWord,word, 0, 5); // number of PMT on the right side
db173afc	278	word=fDigits->BestTimeLeft();
e4da63c2	279	PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
e4da63c2	280	fIndex++;
e4da63c2	281	buf[fIndex]=baseWord;
db173afc	282
e4da63c2	283	baseWord=0;
db173afc	284
e4da63c2	285	word=error;
e4da63c2	286	PackWord(baseWord,word,0, 7); // Error flag
db173afc	287	word=fDigits->BestTimeLeft();
e4da63c2	288	PackWord(baseWord,word,8,31); // time-of-flight
e4da63c2	289	fIndex++;
e4da63c2	290	buf[fIndex]=baseWord;
db173afc	291
	292	// time difference
	293	word=28;
	294	PackWord(baseWord,word, 0, 5); // number of PMT on the right side
	295	word=fDigits->TimeDiff();
	296	PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
	297	fIndex++;
	298	buf[fIndex]=baseWord;
	299
e4da63c2	300	baseWord=0;
db173afc	301
	302	word=error;
	303	PackWord(baseWord,word,0, 7); // Error flag
	304	word=fDigits->TimeDiff();
	305	PackWord(baseWord,word,8,31); // time-of-flight
	306	fIndex++;
	307	buf[fIndex]=baseWord;
	308
	309	// multiplicity
	310
	311	for (Int_t i=0; i<6; i++)
	312	{
	313	Int_t mult=fSumMult->At(i);
	314	word=29+i;
	315	PackWord(baseWord,word, 0, 5);
	316	word=mult;
	317	PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
	318	fIndex++;
	319	buf[fIndex]=baseWord;
	320
	321	baseWord=0;
	322	word=error;
	323	PackWord(baseWord,word,0, 7); // Error flag
	324	word=mult;
	325	PackWord(baseWord,word,8,31); // time QTC
	326	fIndex++;
	327	buf[fIndex]=baseWord;
	328	}
	329	cout<<endl;
e4da63c2	330	}
	331
	332	//-------------------------------------------------------------------------------------
	333
	334	void AliSTARTRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
	335	{
	336	//This method packs a word into the Baseword buffer starting form the "StartBit"
	337	//and tacking StopBit-StartBit+1 bits
	338	UInt_t dummyWord,offSet;
	339	Int_t length;
	340	UInt_t sum;
	341	//The BaseWord is being filled with 1 from StartBit to StopBit
	342	length=StopBit-StartBit+1;
	343	sum=(UInt_t)TMath::Power(2,length)-1;
	344
	345	if(Word > sum){
	346	Error("PackWord", "Word to be filled is not within desired length\n"
	347	"Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
	348	return;
	349	}
	350	offSet=sum;
	351	offSet<<=StartBit;
	352	BaseWord=BaseWord\|offSet;
	353
	354	//The Word to be filled is shifted to the position StartBit
	355	//and the remaining Left and Right bits are filled with 1
	356	sum=(UInt_t)TMath::Power(2,StartBit)-1;
	357	dummyWord=0xFFFFFFFF<<length;
	358	dummyWord +=Word;
	359	dummyWord<<=StartBit;
	360	dummyWord+=sum;
	361	BaseWord=BaseWord&dummyWord;
	362
	363	return;
	364	}
	365	//---------------------------------------------------------------------------------------
	366
	367	Int_t AliSTARTRawData::RawDataSTART(AliSTARTdigit *fDigits){
	368
	369	//This method creates the Raw data files for TOF detector
	370	const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector()
	371	//max number of digits per DDL file times 2
	372	UInt_t buf[kSize];
	373	UInt_t baseWord;
	374	UInt_t word;
	375
	376	fIndex=-1;
db173afc	377	// TClonesArray& digits = (TClonesArray**) branch->GetAddress();
e4da63c2	378
	379	char fileName[15];
	380	ofstream outfile; // logical name of the output file
	381	AliRawDataHeader header;
e4da63c2	382	//loop over TOF DDL files
db173afc	383	sprintf(fileName,"START_%d.ddl", 0xd00);
db173afc	384	// sprintf(fileName,"START_0xd00.ddl"); //The name of the output file
e4da63c2	385	#ifndef __DECCXX
	386	outfile.open(fileName,ios::binary);
	387	#else
	388	outfile.open(fileName);
	389	#endif
	390	//write Dummy DATA HEADER
	391	UInt_t dataHeaderPosition=outfile.tellp();
	392	outfile.write((char*)(&header),sizeof(header));
	393
	394	baseWord=0;
	395	word=0;
	396	PackWord(baseWord,word,0, 31); // Number of DDL file
	397
	398	fIndex++;
	399	buf[fIndex]=baseWord;
e4da63c2	400	GetDigits(fDigits,buf);
db173afc	401
db173afc	402	outfile.write((char )buf,((fIndex+1)sizeof(UInt_t)));
e4da63c2	403	for(Int_t ii=0;ii<(fIndex+1);ii++) buf[ii]=0;
db173afc	404	fIndex=-1;
e4da63c2	405
	406	//Write REAL DATA HEADER
	407	UInt_t currentFilePosition=outfile.tellp();
	408	outfile.seekp(dataHeaderPosition);
	409	header.fSize=currentFilePosition-dataHeaderPosition;
	410	header.SetAttribute(0); // valid data
	411	outfile.write((char*)(&header),sizeof(header));
	412	outfile.close();
	413
	414	//end for
	415
	416	return 0;
	417
	418	}