additional RecPoints implemented
[u/mrichter/AliRoot.git] / START / AliSTARTRawData.cxx
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 #include <TTree.h>
26
27 #include "AliSTART.h"
28 #include "AliSTARTRawData.h"
29 #include "AliSTARTdigit.h"
30 #include "AliBitPacking.h"
31 #include "AliRawDataHeader.h"
32 #include "AliBitPacking.h"
33
34 ClassImp(AliSTARTRawData)
35
36 //_____________________________________________________________________________
37 AliSTARTRawData::AliSTARTRawData():TObject()
38 {
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
45 -  48 channel for amplitude: very preliminary, QTC features are not
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   */
56
57   fIndex=-1;
58   fDigits = NULL;
59
60   fTimeCFD = new TArrayI(24);
61   fADC = new TArrayI(24);
62   fTimeLED = new TArrayI(24);
63   fADC0 = new TArrayI(24);
64    //   this->Dump();
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   //
85   if (fDigits) {
86     delete fDigits;
87     fDigits = NULL;
88   }
89   delete fTimeCFD;
90   delete fADC;
91   delete fTimeLED;
92   delete fADC0;
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
115
116   UInt_t word;
117   UInt_t baseWord=0;
118   Int_t error=0;
119
120     // Get the digits array
121
122   fDigits->GetTime(*fTimeCFD);
123   fDigits->GetADC(*fADC);
124   fDigits->GetTimeAmp(*fTimeLED);
125   fDigits->GetADCAmp(*fADC0);
126      
127   // Loop through all PMT
128  
129   for (Int_t det = 0; det < 24; det++) {
130     Int_t timeLED=fTimeLED->At(det);
131
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   }
150   cout<<endl;
151    for (Int_t det = 0; det < 24; det++) {
152     //CDF
153     Int_t timeCFD=fTimeCFD->At(det);
154     // DDL2 2 0-5 -#PMT, 6-31 - empty
155      word=0;
156      baseWord=0;
157      word=det+24;
158      PackWord(baseWord,word, 0, 8); // number of PMT on the right side
159      fIndex++;
160      buf[fIndex]=baseWord;
161      word=0;
162      baseWord=0;
163      word=error;
164      PackWord(baseWord,word,0, 7); // Error flag
165      word=timeCFD;
166      PackWord(baseWord,word,8,31); // time-of-flight
167      fIndex++;
168      buf[fIndex]=baseWord;
169      word=0;
170      baseWord=0;
171    }
172    cout<<endl;
173   for (Int_t det = 0; det < 24; det++) {
174     //conver ADC to time (preliminary algorithm)
175     Int_t qtc=fADC->At(det);
176     word=det+48;
177      PackWord(baseWord,word, 0, 8); // number of PMT on the right side
178     fIndex++;
179     buf[fIndex]=baseWord;
180     baseWord=0;
181     word=error;
182     PackWord(baseWord,word,0, 7); // Error flag
183     word=qtc;
184     PackWord(baseWord,word,8,31); // Q->Time
185     fIndex++;
186     buf[fIndex]=baseWord;
187     word=0;
188     baseWord=0;
189   }
190   cout<<endl;
191   
192   for (Int_t det = 0; det < 24; det++) {
193     Int_t qtcAmp=fADC0->At(det);
194     
195     // DDL 4 amplified QTC charge * 10
196     
197      //Amplified  ADC -> TDC 
198     
199     word=det+72;
200     PackWord(baseWord,word, 0, 8); // number of PMT on the right side
201     fIndex++;
202     buf[fIndex]=baseWord;
203     baseWord=0;
204     word=error;
205     PackWord(baseWord,word,0, 7); // Error flag
206     word=qtcAmp;
207     PackWord(baseWord,word,8,31); // Q->T amplified
208     fIndex++;
209     buf[fIndex]=baseWord;
210     
211     word=0;
212     baseWord=0;
213   }
214
215
216   word=0;
217   baseWord=0;
218   fIndex++;
219   word=97;
220   PackWord(baseWord,word, 0, 8); // ?????????????????
221   buf[fIndex]=baseWord;
222   baseWord=0;
223   word=error;
224   PackWord(baseWord,word,0, 7); // Error flag
225   word=fDigits->MeanTime();
226   PackWord(baseWord,word,8,31); // MEANER
227   fIndex++;
228   buf[fIndex]=baseWord;
229
230
231
232   // besttime right & left
233   word=98;
234   PackWord(baseWord,word, 0, 8); // T0-A sign
235   fIndex++;
236   buf[fIndex]=baseWord;
237
238   baseWord=0;
239   word=error;
240   PackWord(baseWord,word,0, 7); // Error flag
241   word=fDigits->BestTimeRight();
242   PackWord(baseWord,word,8,31); // time-of-flight T0-A
243   fIndex++;
244   buf[fIndex]=baseWord;
245
246   word=99;
247   PackWord(baseWord,word, 0, 8); // T0-C sign
248   fIndex++;
249   buf[fIndex]=baseWord;
250
251   baseWord=0;
252
253   word=error;
254   PackWord(baseWord,word,0, 7); // Error flag
255   word=fDigits->BestTimeLeft();
256   PackWord(baseWord,word,8,31); // time-of-flight T0-C 
257   fIndex++;
258   buf[fIndex]=baseWord;
259
260  
261   // time difference
262   word=100;
263   PackWord(baseWord,word, 0, 8); // TVDS sign
264   word=fDigits->TimeDiff();
265   //  PackWord(baseWord,word, 6, 31); // T0 vertex 
266   fIndex++;
267   buf[fIndex]=baseWord;
268
269   baseWord=0;
270
271   word=error;
272   PackWord(baseWord,word,0, 7); // Error flag
273   word=fDigits->TimeDiff();
274   PackWord(baseWord,word,8,31); // T0verex
275   fIndex++;
276   buf[fIndex]=baseWord;
277
278   // multiplicity 
279   
280   Int_t mult=fDigits->SumMult();
281   word=100;
282   PackWord(baseWord,word, 0, 8); 
283   word=mult;
284   PackWord(baseWord,word, 6, 31); // sum amplitude
285   fIndex++;
286   buf[fIndex]=baseWord;
287   
288   baseWord=0;
289   word=error;
290   PackWord(baseWord,word,0, 7); // Error flag
291   word=mult;
292   PackWord(baseWord,word,8,31); // time amplitude
293   fIndex++;
294   buf[fIndex]=baseWord;
295   
296   cout<<endl;
297
298   // trigger channels
299    // besttime right & left
300   word=101;
301   PackWord(baseWord,word, 0, 8); // T0-A sign
302   fIndex++;
303   buf[fIndex]=baseWord;
304
305   baseWord=0;
306   word=error;
307   PackWord(baseWord,word,0, 7); // Error flag
308   word=fDigits->BestTimeRight();
309   PackWord(baseWord,word,8,31); // time-of-flight T0-A
310   fIndex++;
311   buf[fIndex]=baseWord;
312  
313   word=102;
314   PackWord(baseWord,word, 0, 8); // T0-C sign
315   fIndex++;
316   buf[fIndex]=baseWord;
317
318   baseWord=0;
319
320   word=error;
321   PackWord(baseWord,word,0, 7); // Error flag
322   word=fDigits->BestTimeLeft();
323   PackWord(baseWord,word,8,31); // time-of-flight T0-C 
324   fIndex++;
325   buf[fIndex]=baseWord;
326
327   // time difference
328   word=103;
329   PackWord(baseWord,word, 0, 8); // TVDS sign
330   word=fDigits->TimeDiff();
331    PackWord(baseWord,word, 6, 31); // T0 vertex 
332   fIndex++;
333   buf[fIndex]=baseWord;
334
335   baseWord=0;
336
337   word=error;
338   PackWord(baseWord,word,0, 7); // Error flag
339   word=fDigits->TimeDiff();
340   PackWord(baseWord,word,8,31); // T0verex
341   fIndex++;
342   buf[fIndex]=baseWord;
343
344   // multiplicity 
345   
346   mult=fDigits->SumMult();
347   word=104;
348   PackWord(baseWord,word, 0, 8); 
349   word=mult;
350   PackWord(baseWord,word, 6, 31); // sum amplitude
351   fIndex++;
352   buf[fIndex]=baseWord;
353   
354   baseWord=0;
355   word=error;
356  PackWord(baseWord,word,0, 7); // Error flag
357   word=mult;
358  PackWord(baseWord,word,8,31); // time amplitude
359   fIndex++;
360   buf[fIndex]=baseWord;
361   
362   // multiplicity 
363   
364    mult=fDigits->SumMult();
365   word=105;
366   PackWord(baseWord,word, 0, 8); 
367   word=mult;
368   PackWord(baseWord,word, 6, 31); // sum amplitude
369   fIndex++;
370   buf[fIndex]=baseWord;
371   
372   baseWord=0;
373   word=error;
374   PackWord(baseWord,word,0, 7); // Error flag
375   word=mult;
376   PackWord(baseWord,word,8,31); // time amplitude
377   fIndex++;
378   buf[fIndex]=baseWord;
379   cout<<endl;
380 }
381
382 //-----------------------------------------------------------------------------------
383
384 void AliSTARTRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
385 {
386   //This method packs a word into the Baseword buffer starting form the "StartBit"
387   //and tacking StopBit-StartBit+1 bits
388   UInt_t dummyWord,offSet;
389   Int_t  length;
390   UInt_t sum;
391   //The BaseWord is being filled with 1 from StartBit to StopBit
392   length=StopBit-StartBit+1;
393   sum=(UInt_t)TMath::Power(2,length)-1;
394
395   if(Word > sum){
396     Error("PackWord", "Word to be filled is not within desired length\n"
397           "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
398     return;
399   }
400   offSet=sum;
401   offSet<<=StartBit;
402   BaseWord=BaseWord|offSet;
403
404   //The Word to be filled is shifted to the position StartBit
405   //and the remaining  Left and Right bits are filled with 1
406   sum=(UInt_t)TMath::Power(2,StartBit)-1;
407   dummyWord=0xFFFFFFFF<<length;
408   dummyWord +=Word;
409   dummyWord<<=StartBit;
410   dummyWord+=sum;
411   BaseWord=BaseWord&dummyWord;
412   return;
413 }
414
415 //---------------------------------------------------------------------------------------
416
417 Int_t AliSTARTRawData::RawDataSTART(AliSTARTdigit *fDigits)
418 {
419    //This method creates the Raw data files for START detector
420
421
422   const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector() 
423                           //max number of digits per DDL file times 2
424   UInt_t buf[kSize];
425   UInt_t baseWord;
426   UInt_t word;
427
428   fIndex=-1;
429
430   char fileName[15];
431   ofstream outfile;         // logical name of the output file 
432   AliRawDataHeader header;
433   AliBitPacking *pack ;
434   //loop over TOF DDL files
435   sprintf(fileName,"START_%d.ddl", 0xd00);
436   //   sprintf(fileName,"START_0xd00.ddl"); //The name of the output file
437 #ifndef __DECCXX
438     outfile.open(fileName,ios::binary);
439 #else
440     outfile.open(fileName);
441 #endif
442     //write Dummy DATA HEADER
443     UInt_t dataHeaderPosition=outfile.tellp();
444     outfile.write((char*)(&header),sizeof(header));
445
446     baseWord=0;
447     word=0;
448     pack-> PackWord(baseWord,word,0, 31); // Number of DDL file
449
450     fIndex++;
451     buf[fIndex]=baseWord;
452     GetDigits(fDigits,buf);
453
454     outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
455     for(Int_t ii=0;ii<(fIndex+1);ii++) buf[ii]=0;
456     fIndex=-1;
457     
458     //Write REAL DATA HEADER
459     UInt_t currentFilePosition=outfile.tellp();
460     outfile.seekp(dataHeaderPosition);
461     header.fSize=currentFilePosition-dataHeaderPosition;
462     header.SetAttribute(0);  // valid data
463     outfile.write((char*)(&header),sizeof(header));
464     outfile.close();
465
466  //end for
467    
468   return 0;  
469   
470 }