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