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