[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 "AliRawDataHeader.h"

ClassImp(AliSTARTRawData)

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


  fIndex=-1;
  fDigits = NULL;
  
  ftimeTDC = new TArrayI(24); 
   fADC = 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 ftimeTDC;
    delete fADC;
  }

}

//_____________________________________________________________________________
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

  cout<<"GetDigits(AliSTARTdigit *fDigits, UInt_t *buf) "<<endl;
  UInt_t word;
  UInt_t baseWord=0;
  Int_t error=0;

    fDigits->Print();

   // Get the digits array

      fDigits->GetTime(*ftimeTDC);
      fDigits->GetADC(*fADC);
      fBestTimeRight=fDigits->GetBestTimeRight();
      fBestTimeLeft=fDigits->GetBestTimeLeft();
      fMeanTime = fDigits-> GetMeanTime();

     
  // Loop through all PMT
 

  for (Int_t det = 0; det < 24; det++) {
    Int_t time=ftimeTDC->At(det);
    Int_t ADC=fADC->At(det);
    printf(" right det %x time %x ADC %x \n",det,time,ADC);
    //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=time;
     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=ADC;
     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=ADC;
     PackWord(baseWord,word,8,31); // time-of-flight
     fIndex++;
     buf[fIndex]=baseWord;
     word=0;
     baseWord=0;


 }
  /*
  //timemean
  fIndex++;
  buf[fIndex]=baseWord;
  word=25;
  PackWord(baseWord,word, 0, 5); // number of PMT on the right side
  word=fMeanTime;
  PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
  printf("meantime buf[%i]=%x\n",fIndex,buf[fIndex]);
  
  fIndex++;
  buf[fIndex]=baseWord;
  
  baseWord=0;
  
  word=error;
  PackWord(baseWord,word,0, 7); // Error flag
  word=fMeanTime;
  PackWord(baseWord,word,8,31); // time-of-flight
  
  fIndex++;
  buf[fIndex]=baseWord;
  
  printf("meantime buf[%i]=%x\n",fIndex,buf[fIndex]);

     
  // besttime right & left
  fIndex++;
  cout<<" left "<<fBestTimeLeft<<" right "<<fBestTimeRight<<endl;
  buf[fIndex]=baseWord;
  word=26;
  PackWord(baseWord,word, 0, 5); // number of PMT on the right side
  word=fBestTimeRight;
  PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
  printf("best buf[%i]=%x\n",fIndex,buf[fIndex]);
  
  fIndex++;
  buf[fIndex]=baseWord;
  
  baseWord=0;
  
  word=error;
  PackWord(baseWord,word,0, 7); // Error flag
  word=fBestTimeRight;
  PackWord(baseWord,word,8,31); // time-of-flight
  
  fIndex++;
  buf[fIndex]=baseWord;
  
  printf("4 right buf[%i]=%x\n",fIndex,buf[fIndex]);
  
  word=27;
  PackWord(baseWord,word, 0, 5); // number of PMT on the right side
  word=fBestTimeLeft;
  PackWord(baseWord,word, 6, 31); // TDC on the right side from Marin
  printf("5 left buf[%i]=%x\n",fIndex,buf[fIndex]);
  
  fIndex++;
  buf[fIndex]=baseWord;
  
  baseWord=0;
  
  word=error;
  PackWord(baseWord,word,0, 7); // Error flag
  word=fBestTimeLeft;
  PackWord(baseWord,word,8,31); // time-of-flight
  
  fIndex++;
  buf[fIndex]=baseWord;
  
  printf("5 left buf[%i]=%x\n",fIndex,buf[fIndex]);
  */   
  word=0;
  baseWord=0;
   
}

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

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;

  char fileName[15];
  ofstream outfile;         // logical name of the output file 
  AliRawDataHeader header;
  cout<<" AliRawDataHeader header; start "<<endl;
  //loop over TOF DDL files
     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;

    //   branch->GetEvent();

    //For each DDL file, buf contains the array of data words in Binary format
    //fIndex gives the number of 32 bits words in the buffer for each DDL file
    cout<<" AliSTARTRawData::RawDataSTART "<<fDigits<<endl;

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