[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 "AliBitPacking.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);
  fADC = new TArrayI(24);
  fTimeLED = new TArrayI(24);
  fADC0 = new TArrayI(24);
   //   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 fTimeCFD;
  delete fADC;
  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, 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(*fTimeCFD);
  fDigits->GetADC(*fADC);
  fDigits->GetTimeAmp(*fTimeLED);
  fDigits->GetADCAmp(*fADC0);
     
  // Loop through all PMT
 
  for (Int_t det = 0; det < 24; det++) {
    Int_t timeLED=fTimeLED->At(det);
    //   if( timeLED > 0){
      // DDL 1 0-5 -#PMT, 6-31 - empty
      //LED
      word=det;;
      PackWord(baseWord,word, 0, 8); 
      fIndex++;
      buf[fIndex]=baseWord;
      
      word=0;
      baseWord=0;
      word=error;
      PackWord(baseWord,word,0, 7); // Error flag
      word=timeLED;
      PackWord(baseWord,word,8,31); // time-of-flight
      fIndex++;
      buf[fIndex]=baseWord;
      word=0;
      baseWord=0;
      //  }
  }
   for (Int_t det = 0; det < 24; det++) {
    //CDF
     Int_t timeCFD=fTimeCFD->At(det);
     //   if ( timeCFD >0 ) {
       // DDL2 2 0-5 -#PMT, 6-31 - empty
       word=0;
       baseWord=0;
       word=det+24;
       PackWord(baseWord,word, 0, 8); // number of PMT on the right side
       fIndex++;
       buf[fIndex]=baseWord;
       word=0;
       baseWord=0;
       word=error;
       PackWord(baseWord,word,0, 7); // Error flag
       word=timeCFD;
       PackWord(baseWord,word,8,31); // time-of-flight
       fIndex++;
       buf[fIndex]=baseWord;
        word=0;
       baseWord=0;
       //  }
   }
  for (Int_t det = 0; det < 24; det++) {
    //conver ADC to time (preliminary algorithm)
    Int_t qtc=fADC->At(det);
    //    if ( qtc > 0 )
    //  {
	word=det+48;
	PackWord(baseWord,word, 0, 8); // number of PMT on the right side
	fIndex++;
	buf[fIndex]=baseWord;
	baseWord=0;
	word=error;
	PackWord(baseWord,word,0, 7); // Error flag
	word=qtc;
	PackWord(baseWord,word,8,31); // Q->Time
	fIndex++;
	buf[fIndex]=baseWord;
 	word=0;
	baseWord=0;
	//     }
  }
  
  for (Int_t det = 0; det < 24; det++) {
    Int_t qtcAmp=fADC0->At(det);
    
    // DDL 4 amplified QTC charge * 10
    
     //Amplified  ADC -> TDC 
    
    word=det+72;
    PackWord(baseWord,word, 0, 8); // number of PMT on the right side
    fIndex++;
    buf[fIndex]=baseWord;
    baseWord=0;
    word=error;
    PackWord(baseWord,word,0, 7); // Error flag
    word=qtcAmp;
    PackWord(baseWord,word,8,31); // Q->T amplified
    fIndex++;
    buf[fIndex]=baseWord;
    
    word=0;
    baseWord=0;
  }


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


  // besttime right & left
  word=98;
  PackWord(baseWord,word, 0, 8); // T0-A sign
  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 T0-A
  fIndex++;
  buf[fIndex]=baseWord;

  word=99;
  PackWord(baseWord,word, 0, 8); // T0-C sign
  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 T0-C 
  fIndex++;
  buf[fIndex]=baseWord;

  // time difference
  word=100;
  PackWord(baseWord,word, 0, 8); // TVDS sign
  fIndex++;
  buf[fIndex]=baseWord;

  baseWord=0;

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


  // multiplicity 
  
  Int_t mult=fDigits->SumMult();
  word=101;
  PackWord(baseWord,word, 0, 8); 
  fIndex++;
  buf[fIndex]=baseWord;
  
  baseWord=0;
  word=error;
  PackWord(baseWord,word,0, 7); // Error flag
  word=mult;
  PackWord(baseWord,word,8,31); // time amplitude
  fIndex++;
  buf[fIndex]=baseWord;
  

  // trigger channels
   // besttime right & left
  word=102;
  PackWord(baseWord,word, 0, 8); // T0-A sign
  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 T0-A
  fIndex++;
  buf[fIndex]=baseWord;
 
  word=103;
  PackWord(baseWord,word, 0, 8); // T0-C sign
  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 T0-C 
  fIndex++;
  buf[fIndex]=baseWord;

  // time difference
  word=104;
  PackWord(baseWord,word, 0, 8); // TVDS sign
  fIndex++;
  buf[fIndex]=baseWord;

  baseWord=0;

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

  // multiplicity 
  
  mult=fDigits->SumMult();
  word=105;
  PackWord(baseWord,word, 0, 8); 
  fIndex++;
  buf[fIndex]=baseWord;
  
  baseWord=0;
  word=error;
  PackWord(baseWord,word,0, 7); // Error flag
  word=mult;
  PackWord(baseWord,word,8,31); // time amplitude
  fIndex++;
  buf[fIndex]=baseWord;
  
  // multiplicity 
  
  mult=fDigits->SumMult();
  word=106;
  PackWord(baseWord,word, 0, 8); 
  fIndex++;
  buf[fIndex]=baseWord;
  
  baseWord=0;
  word=error;
  PackWord(baseWord,word,0, 7); // Error flag
  word=mult;
  PackWord(baseWord,word,8,31); // time amplitude
  fIndex++;
  buf[fIndex]=baseWord;

}

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

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;

}

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

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 buf[kSize];
  UInt_t baseWord;
  UInt_t word;

  fIndex=-1;

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