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