new digitization and reconstruction corresponded to new data format
[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   AliBitPacking *pack ;
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      pack->PackWord(baseWord,word, 0, 5); 
136      fIndex++;
137      buf[fIndex]=baseWord;
138
139      word=0;
140      baseWord=0;
141      word=error;
142      pack->PackWord(baseWord,word,0, 7); // Error flag
143      word=timeLED;
144      cout<<det<<" led "<<timeLED<<" "<<word<<" ";
145     pack->PackWord(baseWord,word,8,31); // time-of-flight
146      fIndex++;
147      buf[fIndex]=baseWord;
148      word=0;
149      baseWord=0;
150   }
151   cout<<endl;
152    for (Int_t det = 0; det < 24; det++) {
153     //CDF
154     Int_t timeCFD=fTimeCFD->At(det);
155     // DDL2 2 0-5 -#PMT, 6-31 - empty
156      word=0;
157      baseWord=0;
158      word=det+24;
159      pack->PackWord(baseWord,word, 0, 5); // number of PMT on the right side
160      fIndex++;
161      buf[fIndex]=baseWord;
162      word=0;
163      baseWord=0;
164      word=error;
165     pack-> PackWord(baseWord,word,0, 7); // Error flag
166      word=timeCFD;
167      cout<<det<<" CFD "<<timeCFD<<" "<<word<<" ";
168      pack->PackWord(baseWord,word,8,31); // time-of-flight
169      fIndex++;
170      buf[fIndex]=baseWord;
171      word=0;
172      baseWord=0;
173    }
174    cout<<endl;
175   for (Int_t det = 0; det < 24; det++) {
176     //conver ADC to time (preliminary algorithm)
177     Int_t qtc=fADC->At(det);
178     word=det+48;
179     pack->PackWord(baseWord,word, 0, 5); // number of PMT on the right side
180     fIndex++;
181     buf[fIndex]=baseWord;
182     baseWord=0;
183     word=error;
184     pack->PackWord(baseWord,word,0, 7); // Error flag
185     word=qtc;
186     cout<<det<<" "<<fIndex<<" adc1 "<<word<<" ";
187     pack->PackWord(baseWord,word,8,31); // Q->Time
188     fIndex++;
189     buf[fIndex]=baseWord;
190     word=0;
191     baseWord=0;
192   }
193   cout<<endl;
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;
203     pack->PackWord(baseWord,word, 0, 5); // number of PMT on the right side
204     fIndex++;
205     buf[fIndex]=baseWord;
206     baseWord=0;
207     word=error;
208     pack->PackWord(baseWord,word,0, 7); // Error flag
209     word=qtcAmp;
210     cout<<det<<" "<<fIndex<<" adc2 "<<word<<" ";
211     pack->PackWord(baseWord,word,8,31); // Q->T amplified
212     fIndex++;
213     buf[fIndex]=baseWord;
214     
215     word=0;
216     baseWord=0;
217   }
218
219
220   word=0;
221   baseWord=0;
222   fIndex++;
223   word=97;
224   pack->PackWord(baseWord,word, 0, 5); // ?????????????????
225   buf[fIndex]=baseWord;
226   baseWord=0;
227   word=error;
228   pack->PackWord(baseWord,word,0, 7); // Error flag
229   word=fDigits->MeanTime();
230   cout<<fIndex<<" "<<" mean "<< word<<endl;
231   pack->PackWord(baseWord,word,8,31); // MEANER
232   fIndex++;
233   buf[fIndex]=baseWord;
234     cout<<fIndex<<" meaner "<<word<<" ";
235
236
237
238   // besttime right & left
239   word=98;
240  pack-> PackWord(baseWord,word, 0, 5); // T0-A sign
241   fIndex++;
242   buf[fIndex]=baseWord;
243
244   baseWord=0;
245   word=error;
246   pack->PackWord(baseWord,word,0, 7); // Error flag
247   word=fDigits->BestTimeRight();
248   pack-> PackWord(baseWord,word,8,31); // time-of-flight T0-A
249   fIndex++;
250   buf[fIndex]=baseWord;
251    cout<<fIndex<<" T0-A "<<word<<" ";
252
253   word=99;
254    pack->PackWord(baseWord,word, 0, 5); // T0-C sign
255   fIndex++;
256   buf[fIndex]=baseWord;
257
258   baseWord=0;
259
260   word=error;
261   pack->PackWord(baseWord,word,0, 7); // Error flag
262   word=fDigits->BestTimeLeft();
263  pack-> PackWord(baseWord,word,8,31); // time-of-flight T0-C 
264   fIndex++;
265   buf[fIndex]=baseWord;
266
267    cout<<fIndex<<" T0-C "<<word<<" ";
268   // time difference
269   word=100;
270  pack-> PackWord(baseWord,word, 0, 5); // TVDS sign
271   word=fDigits->TimeDiff();
272  pack-> PackWord(baseWord,word, 6, 31); // T0 vertex 
273   fIndex++;
274   buf[fIndex]=baseWord;
275
276   baseWord=0;
277
278   word=error;
279   pack->PackWord(baseWord,word,0, 7); // Error flag
280   word=fDigits->TimeDiff();
281   pack->PackWord(baseWord,word,8,31); // T0verex
282   fIndex++;
283   buf[fIndex]=baseWord;
284   cout<<fIndex<<" diff "<<word<<endl;
285
286   // multiplicity 
287   
288    Int_t mult=fDigits->SumMult();
289   word=100;
290  pack-> PackWord(baseWord,word, 0, 5); 
291   word=mult;
292  pack-> PackWord(baseWord,word, 6, 31); // sum amplitude
293   fIndex++;
294   buf[fIndex]=baseWord;
295   
296   baseWord=0;
297   word=error;
298  pack-> PackWord(baseWord,word,0, 7); // Error flag
299   word=mult;
300  pack-> PackWord(baseWord,word,8,31); // time amplitude
301   fIndex++;
302   buf[fIndex]=baseWord;
303   
304   cout<<endl;
305
306   // trigger channels
307    // besttime right & left
308   word=101;
309   pack->PackWord(baseWord,word, 0, 5); // T0-A sign
310   fIndex++;
311   buf[fIndex]=baseWord;
312
313   baseWord=0;
314   word=error;
315  pack-> PackWord(baseWord,word,0, 7); // Error flag
316   word=fDigits->BestTimeRight();
317  pack-> PackWord(baseWord,word,8,31); // time-of-flight T0-A
318   fIndex++;
319   buf[fIndex]=baseWord;
320    cout<<fIndex<<" T0-A "<<word<<" ";
321
322   word=102;
323  pack-> PackWord(baseWord,word, 0, 5); // T0-C sign
324   fIndex++;
325   buf[fIndex]=baseWord;
326
327   baseWord=0;
328
329   word=error;
330  pack-> PackWord(baseWord,word,0, 7); // Error flag
331   word=fDigits->BestTimeLeft();
332  pack-> PackWord(baseWord,word,8,31); // time-of-flight T0-C 
333   fIndex++;
334   buf[fIndex]=baseWord;
335
336    cout<<fIndex<<" T0-C "<<word<<" ";
337   // time difference
338   word=103;
339  pack-> PackWord(baseWord,word, 0, 5); // TVDS sign
340   word=fDigits->TimeDiff();
341  pack-> PackWord(baseWord,word, 6, 31); // T0 vertex 
342   fIndex++;
343   buf[fIndex]=baseWord;
344
345   baseWord=0;
346
347   word=error;
348  pack-> PackWord(baseWord,word,0, 7); // Error flag
349   word=fDigits->TimeDiff();
350  pack-> PackWord(baseWord,word,8,31); // T0verex
351   fIndex++;
352   buf[fIndex]=baseWord;
353   cout<<fIndex<<" diff "<<word<<endl;
354
355   // multiplicity 
356   
357    mult=fDigits->SumMult();
358   word=104;
359  pack-> PackWord(baseWord,word, 0, 5); 
360   word=mult;
361 pack->  PackWord(baseWord,word, 6, 31); // sum amplitude
362   fIndex++;
363   buf[fIndex]=baseWord;
364   
365   baseWord=0;
366   word=error;
367  pack-> PackWord(baseWord,word,0, 7); // Error flag
368   word=mult;
369  pack-> PackWord(baseWord,word,8,31); // time amplitude
370   fIndex++;
371   buf[fIndex]=baseWord;
372   
373   // multiplicity 
374   
375    mult=fDigits->SumMult();
376   word=105;
377  pack-> PackWord(baseWord,word, 0, 5); 
378   word=mult;
379  pack-> PackWord(baseWord,word, 6, 31); // sum amplitude
380   fIndex++;
381   buf[fIndex]=baseWord;
382   
383   baseWord=0;
384   word=error;
385  pack-> PackWord(baseWord,word,0, 7); // Error flag
386   word=mult;
387  pack-> PackWord(baseWord,word,8,31); // time amplitude
388   fIndex++;
389   buf[fIndex]=baseWord;
390   cout<<endl;
391  
392
393 }
394
395 //-------------------------------------------------------------------------------------
396 /*
397 void AliSTARTRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
398 {
399   //This method packs a word into the Baseword buffer starting form the "StartBit" 
400   //and tacking StopBit-StartBit+1 bits
401   UInt_t dummyWord,offSet;
402   Int_t  length;
403   UInt_t sum;
404   //The BaseWord is being filled with 1 from StartBit to StopBit
405   length=StopBit-StartBit+1;
406   sum=(UInt_t)TMath::Power(2,length)-1;
407
408   if(Word > sum){
409     Error("PackWord", "Word to be filled is not within desired length\n"
410           "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
411     return;
412   }
413   offSet=sum;
414   offSet<<=StartBit;
415   BaseWord=BaseWord|offSet;
416
417   //The Word to be filled is shifted to the position StartBit
418   //and the remaining  Left and Right bits are filled with 1
419   sum=(UInt_t)TMath::Power(2,StartBit)-1;
420   dummyWord=0xFFFFFFFF<<length;
421   dummyWord +=Word;
422   dummyWord<<=StartBit;
423   dummyWord+=sum;
424   BaseWord=BaseWord&dummyWord;
425
426   return;
427 }
428 */
429 //---------------------------------------------------------------------------------------
430
431 Int_t AliSTARTRawData::RawDataSTART(AliSTARTdigit *fDigits)
432 {
433    //This method creates the Raw data files for START detector
434
435
436   const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector() 
437                           //max number of digits per DDL file times 2
438   UInt_t buf[kSize];
439   UInt_t baseWord;
440   UInt_t word;
441
442   fIndex=-1;
443
444   char fileName[15];
445   ofstream outfile;         // logical name of the output file 
446   AliRawDataHeader header;
447   AliBitPacking *pack ;
448   //loop over TOF DDL files
449   sprintf(fileName,"START_%d.ddl", 0xd00);
450   //   sprintf(fileName,"START_0xd00.ddl"); //The name of the output file
451 #ifndef __DECCXX
452     outfile.open(fileName,ios::binary);
453 #else
454     outfile.open(fileName);
455 #endif
456     //write Dummy DATA HEADER
457     UInt_t dataHeaderPosition=outfile.tellp();
458     outfile.write((char*)(&header),sizeof(header));
459
460     baseWord=0;
461     word=0;
462     pack-> PackWord(baseWord,word,0, 31); // Number of DDL file
463
464     fIndex++;
465     buf[fIndex]=baseWord;
466     GetDigits(fDigits,buf);
467
468     outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
469     for(Int_t ii=0;ii<(fIndex+1);ii++) buf[ii]=0;
470     fIndex=-1;
471     
472     //Write REAL DATA HEADER
473     UInt_t currentFilePosition=outfile.tellp();
474     outfile.seekp(dataHeaderPosition);
475     header.fSize=currentFilePosition-dataHeaderPosition;
476     header.SetAttribute(0);  // valid data
477     outfile.write((char*)(&header),sizeof(header));
478     outfile.close();
479
480  //end for
481    
482   return 0;  
483   
484 }