all time measurements perfomed as difference with case vertex=0
[u/mrichter/AliRoot.git] / T0 / AliT0RawData.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 //  T0 raw data conversion class                                            //
21 //                                                                           //
22 ///////////////////////////////////////////////////////////////////////////////
23
24 #include <Riostream.h>
25 #include <TTree.h>
26
27 #include "AliT0.h"
28 #include "AliT0RawData.h"
29 #include "AliT0digit.h"
30 #include "AliBitPacking.h"
31 #include "AliRawDataHeader.h"
32 #include "AliRawDataHeaderSim.h"
33 #include "AliBitPacking.h"
34 #include "AliFstream.h"
35 #include "AliRunLoader.h"
36 #include "AliDAQ.h"
37
38 ClassImp(AliT0RawData)
39
40 //_____________________________________________________________________________
41   AliT0RawData::AliT0RawData():TObject(),
42  fVerbose(0),      
43  fIndex(-1) ,     
44  fEventNumber(0), 
45  fTimeCFD(new TArrayI(24)),    
46  fADC1( new TArrayI(24)),     
47  fTimeLED( new TArrayI(24)), 
48  fADC0( new TArrayI(24)),     
49  fFile(0x0),   
50  fDataHeaderPos(0),
51  fDRMDataHeaderPos(0),
52  fTRMDataHeaderPos(0),
53  fDigits(0)  
54
55 {
56   /*
57 -  48 channels (2 words each as in TOF DDL) for :
58 word 1 :0-5bit number of PMT; word 2: 0-7 error sign, 8-31 TDC
59 and the same but for amplified signal. Now I wrote the same time because
60 CDF are not ready and differences didn't measured yet.
61
62 -  48 channel for amplitude: very preliminary, QTC features are not
63 known now, preliminary i put as T1 time signal for this PMT in first
64 channel and T1+A in second, where A=Log(Amplitude);
65 and the same for amplified but A=Log(10*Amplitude).
66
67 - T0-A and T0-C 2 channels
68 - T0A-T0C vertex information
69 - Time Meaner where T0C TOF increase to the T0A TOF distance
70 - 6 multiplicity signals the same way as amplitude and with the same
71 uncertances
72   */
73
74   //open the output file
75   char fileName[15];
76   strcpy(fileName,AliDAQ::DdlFileName("T0",0)); //The name of the output file
77   fFile = new AliFstream(fileName);
78   memset(fBuffer,0,512*sizeof(UInt_t));
79
80   //get event number 
81   AliRunLoader *runloader = AliRunLoader::GetRunLoader();
82   if (runloader) {
83     fEventNumber = runloader->GetEventNumber();
84   }
85 }
86
87 //_____________________________________________________________________________
88
89 AliT0RawData::AliT0RawData(const AliT0RawData &r):TObject(),
90  fVerbose(0),      
91  fIndex(-1) ,     
92  fEventNumber(0), 
93  fTimeCFD(new TArrayI(24)),    
94  fADC1( new TArrayI(24)),     
95  fTimeLED( new TArrayI(24)), 
96  fADC0( new TArrayI(24)),     
97  fFile(0x0),   
98  fDataHeaderPos(0),
99  fDRMDataHeaderPos(0),
100  fTRMDataHeaderPos(0),
101  fDigits(0)  
102
103 {
104   //
105   // AliT0rawData copy constructor
106   //
107
108   ((AliT0RawData &) r).Copy(*this);
109
110 }
111
112 //_____________________________________________________________________________
113 AliT0RawData::~AliT0RawData()
114 {
115   //
116   // Destructor
117   //
118   if (fDigits) {
119     delete fDigits;
120     fDigits = NULL;
121   }
122   delete fTimeCFD;
123   delete fADC1;
124   delete fTimeLED;
125   delete fADC0;
126 }
127
128 //_____________________________________________________________________________
129 AliT0RawData &AliT0RawData::operator=(const AliT0RawData &r)
130 {
131   //
132   // Assignment operator
133   //
134
135   if (this != &r) ((AliT0RawData &) r).Copy(*this);
136   return *this;
137
138 }
139
140 //_____________________________________________________________________________
141 void AliT0RawData::GetDigits(AliT0digit *fDigits)
142 {
143  
144   //This method packs the T0 digits in a proper 32 bits structure
145
146   //read T0 digits and fill TDC and ADC arrays
147
148
149   //  Int_t error=0;
150   Int_t time,  positionOfTRMHeader;
151   
152   // Get the digits array
153   
154   fDigits->GetTimeCFD(*fTimeCFD);
155   fDigits->GetQT0(*fADC1);
156   fDigits->GetTimeLED(*fTimeLED);
157   fDigits->GetQT1(*fADC0);
158   Int_t meantime = fDigits->MeanTime(); 
159   Int_t timediff = fDigits->TimeDiff(); 
160   Int_t mult0=fDigits->SumMult();
161   Int_t mult1=fDigits->SumMult();
162   Int_t timeA = fDigits->BestTimeC();
163   Int_t timeC = fDigits->BestTimeA();
164   
165   
166   TArrayI  *allData = new TArrayI(110);
167   Int_t i=0;
168   allData->AddAt(0,0);
169   for (i=1; i<25; i++) {
170     allData->AddAt(fTimeLED->At(i-1),i);
171     allData->AddAt(fTimeCFD->At(i-1),i+24);
172     allData->AddAt(fADC0->At(i-1),i+54);
173     allData->AddAt(fADC1->At(i-1),i+78);
174
175   }
176   allData->AddAt(meantime,49);
177   allData->AddAt(timediff,50);
178   allData->AddAt(timediff,103); //trigger vertex
179   allData->AddAt(timeA,51);
180   allData->AddAt(timeA,104); //trigger T0A
181   allData->AddAt(timeC,52);
182   allData->AddAt(timeC,105); //trigger T0C
183   allData->AddAt(mult0,53);
184   allData->AddAt(mult1,106); //trigger central
185   allData->AddAt(mult1,54);
186   allData->AddAt(mult1,107); //trigger semi-central
187
188   // cout.setf( ios_base::hex, ios_base::basefield );
189   
190   //space for DRM header
191   fIndex += 6;
192
193   Int_t startTRM=fIndex;
194   //space for 1st TRM header
195   fIndex ++;
196   positionOfTRMHeader= fIndex;
197
198   //space for chain  header
199   fIndex ++;
200   WriteChainDataHeader(0, 0); // 
201   // Loop through all PMT
202   Int_t chain=0; 
203   Int_t iTDC = 0;
204   Int_t channel=0;
205   Int_t trm1words=0;
206
207   //LED
208   for (Int_t det = 0; det < 55; det++) {
209     time = allData->At(det);
210     if (time >0)  
211       FillTime(channel,  iTDC,  time); 
212     if (channel < 6) channel +=2;
213     else {
214       channel = 0; 
215       iTDC++;
216       if (iTDC>15) { chain++; iTDC=0;}
217     }
218   }
219   
220
221   WriteChainDataTrailer(1); // 1st chain trailer
222   fIndex++;
223   WriteChainDataHeader(2, 1); // 
224   WriteChainDataTrailer(3); // 2st chain trailer
225   WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
226   trm1words = fIndex - startTRM;
227   WriteTRMDataHeader(0, trm1words , positionOfTRMHeader);
228
229
230   //space for 2st TRM header
231   startTRM=fIndex;
232   fIndex ++;
233   positionOfTRMHeader= fIndex;
234  
235   // chain  header
236   fIndex ++;
237   WriteChainDataHeader(0, 0); // 
238   chain=0; 
239   iTDC = 0;
240   channel=0;
241
242   for (Int_t det = 55; det < 108; det++) {
243     time = allData->At(det);
244     
245     if (time >0)  
246       FillTime(channel,  iTDC,  time); 
247      
248     if (channel < 6) channel +=2;
249     else {
250       channel = 0; 
251       iTDC++;
252       if (iTDC>15) { chain++; iTDC=0;}
253     }
254     
255     
256   }
257     WriteChainDataTrailer(1); // 1st chain trailer
258     fIndex++;
259     WriteChainDataHeader(2, 1); // 
260     WriteChainDataTrailer(3); // 2st chain trailer
261     WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
262     trm1words = fIndex - startTRM;
263     WriteTRMDataHeader(1, trm1words , positionOfTRMHeader);
264     //DRM trailer
265     WriteTrailer(1,0,fEventNumber,5); // 1st TRM trailer
266     
267     WriteDRMDataHeader();
268
269     delete allData;
270
271 }
272 //------------------------------------------------------------------------------
273 void AliT0RawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
274 {
275   
276   // Build mask
277   Int_t len=StopBit-StartBit+1;
278   UInt_t mask=0;
279   for(Int_t jb=0; jb<len; mask|=1<<jb++);
280   // Check consistency
281   if(Word > mask){
282     Error("PackWord", "Word to be filled is not within desired length\n"
283           "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
284     return;
285   }
286   BaseWord=(BaseWord&~(mask<<StartBit))|Word<<StartBit;
287
288 }
289
290
291 //_____________________________________________________________________________
292
293 void  AliT0RawData::WriteDRMDataHeader()
294 {
295 //Write a (dummy or real) DDL DRM  data header, 
296 //set the compression bit if compressed
297 //  UInt_t drmheader[4];  
298   UInt_t word;
299   UInt_t baseWord=0;
300   //fill DRM headers
301   //DRM Global Header
302   word = 1;
303   PackWord(baseWord,word,0, 3); // 0001 
304   word = fIndex ;
305
306   PackWord(baseWord,word,4, 20); // event words 
307   word=124;
308   PackWord(baseWord,word,21,27); // DRM ID for T0 - 124
309   word=4;
310   PackWord(baseWord,word,28,31); // 0100 marks header
311   fBuffer[0]=  baseWord;
312
313
314   //DRM status header 1
315   word = 1;
316   PackWord(baseWord,word,0, 3); // 0001 
317   word = 1;
318   PackWord(baseWord,word,4, 14); // slotID now 0000000001
319   word = 1;
320   PackWord(baseWord,word,15, 15); //if 1  LHC clock is coorectly recieved from CPDM 
321   word=0;
322   PackWord(baseWord,word,16,27); // reserve for future use
323   word=4;
324   PackWord(baseWord,word,28,31); // 0100 marks header
325    fBuffer[1] = baseWord;
326
327
328    word=0;
329    baseWord=0;
330
331     //DRM status header 2
332     word = 1;
333     PackWord(baseWord,word, 0, 3); // 0001 
334     word = 3;
335     PackWord(baseWord,word, 4, 14); //enable slotID now 00000000011
336     word = 0;
337     PackWord(baseWord,word, 15, 15); // something
338     word=0;
339     PackWord(baseWord,word, 16, 27); // fault ID for simulation 0
340     word=4;
341     PackWord(baseWord,word,28,31); // 0100 marks header
342     fBuffer[2]=  baseWord;
343  
344
345     
346     word=0;
347     baseWord=0;
348     //DRM status header 3
349     word = 1;
350     PackWord(baseWord,word,0, 3); // 0001 
351     word = 0;
352     PackWord(baseWord,word,4, 27); // TTC event counter
353     word=4;
354     PackWord(baseWord,word,28,31); // 0100 marks header
355     fBuffer[3]=  baseWord;
356
357     // new DRM format
358     fBuffer[4]=  baseWord;
359     fBuffer[5]=  baseWord;
360     
361     word=0;
362     baseWord=0;
363     
364 }
365   
366 //_____________________________________________________________________________
367
368 void  AliT0RawData::WriteTRMDataHeader(UInt_t slotID, Int_t nWordsInTRM,
369                                           Int_t  positionOfTRMHeader)
370 {
371 //Write a (dummy or real) DDL TRM  data header, 
372 //set the compression bit if compressed
373 //  UInt_t trmheader;  
374   UInt_t word;
375   UInt_t baseWord=0;
376   //fill TRM headers
377   //TRM Global Header
378   word = slotID;
379   PackWord(baseWord,word,0, 3); // slotID
380   word = nWordsInTRM;
381  //+this word - DRM header 
382
383   PackWord(baseWord,word,4, 16); // event words 
384   word=0;
385   PackWord(baseWord,word,17,18); // ACQ
386   word=0;
387   PackWord(baseWord,word,19,19); //  L SEY inside LUT
388   word=0;
389   PackWord(baseWord,word,20,27); //  MBZ
390   word=4;
391   PackWord(baseWord,word,28,31); // 0100 marks header
392   fBuffer[positionOfTRMHeader] =  baseWord;
393
394   word=0; 
395   baseWord=0;
396      
397 }
398
399 //_____________________________________________________________________________
400
401 void  AliT0RawData::WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID)
402 {
403 //Write a (dummy or real) DDL Chain  data header, 
404 //set the compression bit if compressed
405 //  chainNumber 00 or 10
406   UInt_t word;
407   UInt_t baseWord=0;
408   //fill TRM headers
409   //TRM Global Header
410   word = slotID; // ask Tatiana 7 or 9 
411   PackWord(baseWord,word,0, 3); // slotID
412   word = 0;
413   PackWord(baseWord,word,4, 15); // bunchID
414   word=0;
415   PackWord(baseWord,word,16,23); // PB24 temperature
416   word=0;
417   PackWord(baseWord,word,24,26); //  PB24 ID
418   word=0;
419   PackWord(baseWord,word,27,27); //  TS
420   word=chainNumber;
421   PackWord(baseWord,word,28,31); // 0100 marks header
422   fBuffer[fIndex] =  baseWord;
423
424   word=0;
425   baseWord=0;     
426   
427 }
428 //_____________________________________________________________________________
429
430 void  AliT0RawData::WriteChainDataTrailer(UInt_t chainNumber )
431 {
432 //Write a (dummy or real) DDL Chain  data trailer 
433 //set the compression bit if compressed
434 //  chainNumber 00 or 10
435   UInt_t word;
436   UInt_t baseWord=0;
437   word = 0; // ask Tatiana 7 or 9 
438   PackWord(baseWord,word,0, 3); // status
439   word = 0;
440   PackWord(baseWord,word,4, 15); // MBZ
441   word=fEventNumber;
442   PackWord(baseWord,word,16,27); // event counter
443   word=chainNumber;
444   PackWord(baseWord,word,28,31); // chain number
445   fIndex++;
446   fBuffer[fIndex] =  baseWord;
447
448   word=0;
449   baseWord=0;     
450   
451 }
452 //_____________________________________________________________________________
453
454 void  AliT0RawData::WriteDataHeader(Bool_t dummy, Bool_t compressed)
455 {
456 //Write a (dummy or real) DDL data header, 
457 //set the compression bit if compressed
458
459   AliRawDataHeaderSim header;
460   
461   if (dummy) {
462     //if size=0 it means that this data header is a dummy data header
463     fDataHeaderPos = fFile->Tellp();
464     fFile->WriteBuffer((char*)(&header), sizeof(header));
465   } else {
466     UInt_t currentFilePos = fFile->Tellp();
467     fFile->Seekp(fDataHeaderPos);
468     header.fSize = currentFilePos-fDataHeaderPos;
469     header.SetAttribute(0);  // valid data
470     if (compressed) header.SetAttribute(1); 
471     fFile->WriteBuffer((char*)(&header), sizeof(header));
472     fFile->Seekp(currentFilePos);
473   }
474   
475 }
476
477 //___ __________________________________________________________________________
478
479
480 void  AliT0RawData::WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t word3)
481 {
482
483   UInt_t word;
484   UInt_t baseWord=0;
485   word = slot;
486   PackWord(baseWord,word,0, 3); // 0001 
487   word=word1;
488   PackWord(baseWord,word,4, 15); // CRC ?
489   word = word2;
490   PackWord(baseWord,word,16,27); // event counter
491   word=word3;
492   PackWord(baseWord,word,28,31); //  marks trailer
493   fIndex++;
494   fBuffer[fIndex] =  baseWord;
495
496   word=0;
497   baseWord=0;
498
499 }
500
501 //---------------------------------------------------------------------------------------
502 //---------------------------------------------------------------------------------------
503 void  AliT0RawData::FillTime(Int_t ch, Int_t iTDC, Int_t time)
504 {
505   UInt_t word;
506   UInt_t baseWord=0;
507
508   word=time;
509   PackWord(baseWord,word, 0, 20); // Time 
510
511   word=ch;
512   PackWord(baseWord,word, 21, 23); // number of channel 
513   word=iTDC;
514   PackWord(baseWord,word, 24, 27); // TDC ID
515
516   word=0;
517   PackWord(baseWord,word, 28, 28); // E = 0 in simulation
518   word=0;
519   PackWord(baseWord,word, 29, 30); // PS bit data 00
520   word=1;
521   PackWord(baseWord,word, 31, 31); // 1
522   fIndex++;
523   fBuffer[fIndex]=baseWord;
524   word=0;
525   baseWord=0;
526         
527 }
528 //---------------------------------------------------------------------------------------
529
530 Int_t AliT0RawData::RawDataT0(AliT0digit *fDigits)
531 {
532    //This method creates the Raw data files for T0 detector
533
534
535   // const Int_t kSize=512; //2*AliTOFGeometry::NpadXSector() 
536                           //max number of digits per DDL file times 2
537   //  UInt_t fBuffer[kSize];
538   //  UInt_t baseWord;
539   // UInt_t word;
540
541   fIndex=-1;
542  
543
544    WriteDataHeader(kTRUE, kFALSE);
545   GetDigits(fDigits);
546   //write packing digits
547   
548   
549   fFile->WriteBuffer((char*) fBuffer,((fIndex+1)*sizeof(UInt_t)));
550   //write real data header on its place
551    WriteDataHeader(kFALSE, kFALSE);
552   
553   
554   //end for
555   
556   return 0;  
557   
558 }