[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;
  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 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
e4da63c2	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;
4c7da157	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
e4da63c2	296
460b4363	297	// trigger channels
460b4363	298	// besttime right & left
0cd34ffa	299	word=102;
4c7da157	300	PackWord(baseWord,word, 0, 8); // T0-A sign
e4da63c2	301	fIndex++;
e4da63c2	302	buf[fIndex]=baseWord;
db173afc	303
e4da63c2	304	baseWord=0;
e4da63c2	305	word=error;
4c7da157	306	PackWord(baseWord,word,0, 7); // Error flag
db173afc	307	word=fDigits->BestTimeRight();
4c7da157	308	PackWord(baseWord,word,8,31); // time-of-flight T0-A
e4da63c2	309	fIndex++;
e4da63c2	310	buf[fIndex]=baseWord;
4c7da157	311
0cd34ffa	312	word=103;
4c7da157	313	PackWord(baseWord,word, 0, 8); // T0-C sign
e4da63c2	314	fIndex++;
e4da63c2	315	buf[fIndex]=baseWord;
db173afc	316
e4da63c2	317	baseWord=0;
db173afc	318
e4da63c2	319	word=error;
4c7da157	320	PackWord(baseWord,word,0, 7); // Error flag
db173afc	321	word=fDigits->BestTimeLeft();
4c7da157	322	PackWord(baseWord,word,8,31); // time-of-flight T0-C
e4da63c2	323	fIndex++;
e4da63c2	324	buf[fIndex]=baseWord;
db173afc	325
db173afc	326	// time difference
0cd34ffa	327	word=104;
4c7da157	328	PackWord(baseWord,word, 0, 8); // TVDS sign
db173afc	329	fIndex++;
	330	buf[fIndex]=baseWord;
	331
e4da63c2	332	baseWord=0;
db173afc	333
db173afc	334	word=error;
4c7da157	335	PackWord(baseWord,word,0, 7); // Error flag
db173afc	336	word=fDigits->TimeDiff();
4c7da157	337	PackWord(baseWord,word,8,31); // T0verex
db173afc	338	fIndex++;
	339	buf[fIndex]=baseWord;
	340
	341	// multiplicity
460b4363	342
4c7da157	343	mult=fDigits->SumMult();
0cd34ffa	344	word=105;
4c7da157	345	PackWord(baseWord,word, 0, 8);
460b4363	346	fIndex++;
	347	buf[fIndex]=baseWord;
	348
	349	baseWord=0;
	350	word=error;
66425afd	351	PackWord(baseWord,word,0, 7); // Error flag
460b4363	352	word=mult;
66425afd	353	PackWord(baseWord,word,8,31); // time amplitude
460b4363	354	fIndex++;
	355	buf[fIndex]=baseWord;
	356
	357	// multiplicity
	358
66425afd	359	mult=fDigits->SumMult();
0cd34ffa	360	word=106;
4c7da157	361	PackWord(baseWord,word, 0, 8);
460b4363	362	fIndex++;
	363	buf[fIndex]=baseWord;
	364
	365	baseWord=0;
	366	word=error;
4c7da157	367	PackWord(baseWord,word,0, 7); // Error flag
460b4363	368	word=mult;
4c7da157	369	PackWord(baseWord,word,8,31); // time amplitude
460b4363	370	fIndex++;
460b4363	371	buf[fIndex]=baseWord;
db173afc	372	cout<<endl;
e4da63c2	373	}
e4da63c2	374
4c7da157	375	//-----------------------------------------------------------------------------------
4c7da157	376
e4da63c2	377	void AliSTARTRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
e4da63c2	378	{
4c7da157	379	//This method packs a word into the Baseword buffer starting form the "StartBit"
e4da63c2	380	//and tacking StopBit-StartBit+1 bits
	381	UInt_t dummyWord,offSet;
	382	Int_t length;
	383	UInt_t sum;
	384	//The BaseWord is being filled with 1 from StartBit to StopBit
	385	length=StopBit-StartBit+1;
	386	sum=(UInt_t)TMath::Power(2,length)-1;
	387
	388	if(Word > sum){
	389	Error("PackWord", "Word to be filled is not within desired length\n"
4c7da157	390	"Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
e4da63c2	391	return;
	392	}
	393	offSet=sum;
	394	offSet<<=StartBit;
	395	BaseWord=BaseWord\|offSet;
	396
	397	//The Word to be filled is shifted to the position StartBit
	398	//and the remaining Left and Right bits are filled with 1
	399	sum=(UInt_t)TMath::Power(2,StartBit)-1;
	400	dummyWord=0xFFFFFFFF<<length;
	401	dummyWord +=Word;
	402	dummyWord<<=StartBit;
	403	dummyWord+=sum;
	404	BaseWord=BaseWord&dummyWord;
e4da63c2	405	return;
e4da63c2	406	}
4c7da157	407
e4da63c2	408	//---------------------------------------------------------------------------------------
e4da63c2	409
06fb27f4	410	Int_t AliSTARTRawData::RawDataSTART(AliSTARTdigit *fDigits)
	411	{
	412	//This method creates the Raw data files for START detector
	413
	414
e4da63c2	415	const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector()
	416	//max number of digits per DDL file times 2
	417	UInt_t buf[kSize];
	418	UInt_t baseWord;
	419	UInt_t word;
	420
	421	fIndex=-1;
	422
	423	char fileName[15];
	424	ofstream outfile; // logical name of the output file
	425	AliRawDataHeader header;
e4da63c2	426	//loop over TOF DDL files
db173afc	427	sprintf(fileName,"START_%d.ddl", 0xd00);
db173afc	428	// sprintf(fileName,"START_0xd00.ddl"); //The name of the output file
e4da63c2	429	#ifndef __DECCXX
	430	outfile.open(fileName,ios::binary);
	431	#else
	432	outfile.open(fileName);
	433	#endif
	434	//write Dummy DATA HEADER
	435	UInt_t dataHeaderPosition=outfile.tellp();
	436	outfile.write((char*)(&header),sizeof(header));
	437
	438	baseWord=0;
	439	word=0;
66425afd	440	PackWord(baseWord,word,0, 31); // Number of DDL file
e4da63c2	441
	442	fIndex++;
	443	buf[fIndex]=baseWord;
e4da63c2	444	GetDigits(fDigits,buf);
db173afc	445
db173afc	446	outfile.write((char )buf,((fIndex+1)sizeof(UInt_t)));
e4da63c2	447	for(Int_t ii=0;ii<(fIndex+1);ii++) buf[ii]=0;
db173afc	448	fIndex=-1;
e4da63c2	449
	450	//Write REAL DATA HEADER
	451	UInt_t currentFilePosition=outfile.tellp();
	452	outfile.seekp(dataHeaderPosition);
	453	header.fSize=currentFilePosition-dataHeaderPosition;
	454	header.SetAttribute(0); // valid data
	455	outfile.write((char*)(&header),sizeof(header));
	456	outfile.close();
	457
	458	//end for
	459
	460	return 0;
	461
	462	}