Revert "Fix for coverity (AdC)"
[u/mrichter/AliRoot.git] / TOF / AliTOFDDLRawData.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-2003, 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 /*
17 $Log$
18 Revision 1.19  2007/06/22 11:37:47  cvetan
19 Fixes in order to write correct raw-data on big-endian platforms (Marco)
20
21 Revision 1.18  2007/05/21 13:26:19  decaro
22 Correction on matching_window control and bug fixing (R.Preghenella)
23
24 Revision 1.17  2007/05/10 09:29:34  hristov
25 Last moment fixes and changes from v4-05-Release (Silvia)
26
27 Revision 1.16  2007/05/03 09:07:22  decaro
28 Double digit in the same TDC channel. Wrong sequence during the raw data writing in unpacked mode: solved
29
30 Revision 1.15  2007/04/23 16:51:39  decaro
31 Digits-to-raw_data conversion: correction for a more real description (A.De Caro, R.Preghenella)
32
33 Revision 1.14  2007/03/28 10:50:33  decaro
34 Rounding off problem in rawData coding/decoding: solved
35
36 Revision 1.13  2007/02/20 15:57:00  decaro
37 Raw data update: to read the TOF raw data defined in UNPACKED mode
38
39 Revision 1.12  2006/08/22 13:29:42  arcelli
40 removal of effective c++ warnings (C.Zampolli)
41
42 Revision 1.11  2006/08/10 14:46:54  decaro
43 TOF raw data format: updated version
44
45 Revision 1.10.1  2006/06/28 A.De Caro
46         Update TOF raw data format
47                according to the final version
48                (see ALICE internal note in preparation
49                 'ALICE TOF raw data format')
50
51 Revision 0.02  2005/7/25 A.De Caro
52         Update number of bits allocated for time-of-flight
53                and 'charge' measurements
54
55 Revision 0.01  2004/6/11 A.De Caro, S.B.Sellitto, R.Silvestri
56         First implementation: global methods RawDataTOF
57                                              GetDigits
58 */
59
60 ////////////////////////////////////////////////////////////////////
61 //                                                                //
62 // This class contains the methods to create the Raw Data files   //
63 // for the TOF detector starting from the Digits.                 //
64 // In this implementation, we defined the structure               //
65 // of the ALICE-TOF raw data (according to the                    //
66 // ALICE technical note, in preparation)                          //
67 // starting from the TOF digit format.                            //
68 //                                                                //
69 ////////////////////////////////////////////////////////////////////
70
71 #include "Riostream.h"
72
73 #include "TBranch.h"
74 #include "TClonesArray.h"
75 #include "TMath.h"
76 #include "TRandom.h"
77
78 #include "AliBitPacking.h"
79 #include "AliDAQ.h"
80 #include "AliLog.h"
81 //#include "AliRawDataHeader.h"
82 #include "AliRawDataHeaderSim.h"
83 #include "AliFstream.h"
84
85 #include "AliTOFDDLRawData.h"
86 #include "AliTOFDigitMap.h"
87 #include "AliTOFdigit.h"
88 #include "AliTOFGeometry.h"
89 #include "AliTOFRawStream.h"
90 //#include "AliTOFCableLengthMap.h"
91
92 extern TRandom *gRandom;
93
94 using std::ofstream;
95 using std::endl;
96 using std::cout;
97 using std::ios;
98 ClassImp(AliTOFDDLRawData)
99
100 //---------------------------------------------------------------------------
101 AliTOFDDLRawData::AliTOFDDLRawData():
102   TObject(),
103   fVerbose(0),
104   fIndex(-1),
105   fPackedAcquisition(kFALSE),
106   fFakeOrphaneProduction(kFALSE),
107   fMatchingWindow(8192),
108   fTOFdigitMap(new AliTOFDigitMap()),
109   fTOFdigitArray(0x0),
110   fWordsPerDRM(0),
111   fWordsPerTRM(0),
112   fWordsPerChain(0)
113 {
114   //Default constructor
115 }
116 //----------------------------------------------------------------------------
117 AliTOFDDLRawData::AliTOFDDLRawData(const AliTOFDDLRawData &source) :
118   TObject(source),
119   fVerbose(source.fVerbose),
120   fIndex(source.fIndex),
121   fPackedAcquisition(source.fPackedAcquisition),
122   fFakeOrphaneProduction(source.fFakeOrphaneProduction),
123   fMatchingWindow(source.fMatchingWindow),
124   fTOFdigitMap(source.fTOFdigitMap),
125   fTOFdigitArray(source.fTOFdigitArray),
126   fWordsPerDRM(source.fWordsPerDRM),
127   fWordsPerTRM(source.fWordsPerTRM),
128   fWordsPerChain(source.fWordsPerChain)
129  {
130   //Copy Constructor
131   return;
132 }
133
134 //----------------------------------------------------------------------------
135 AliTOFDDLRawData& AliTOFDDLRawData::operator=(const AliTOFDDLRawData &source) {
136   //Assigment operator
137
138   if (this == &source)
139     return *this;
140
141   TObject::operator=(source);
142   fIndex=source.fIndex;
143   fVerbose=source.fVerbose;
144   fPackedAcquisition=source.fPackedAcquisition;
145   fFakeOrphaneProduction=source.fFakeOrphaneProduction;
146   fMatchingWindow=source.fMatchingWindow;
147   fTOFdigitMap=source.fTOFdigitMap;
148   fTOFdigitArray=source.fTOFdigitArray;
149   fWordsPerDRM=source.fWordsPerDRM;
150   fWordsPerTRM=source.fWordsPerTRM;
151   fWordsPerChain=source.fWordsPerChain;
152   return *this;
153 }
154
155 //----------------------------------------------------------------------------
156 AliTOFDDLRawData::~AliTOFDDLRawData()
157 {
158   // dtr
159
160   delete fTOFdigitMap;
161 }
162 //----------------------------------------------------------------------------
163 Int_t AliTOFDDLRawData::RawDataTOF(TBranch* branch)
164 {
165   //
166   // This method creates the Raw data files for TOF detector
167   //
168
169   const Int_t kSize = 5000; // max number of digits per DDL file times 2
170
171   UInt_t buf[kSize];
172
173   // To clear the digit indices map for each event
174   fTOFdigitMap->Clear();
175
176   fIndex = -1;
177
178   fTOFdigitArray = * (TClonesArray**) branch->GetAddress();
179
180   AliFstream* outfile;      // logical name of the output file 
181
182   AliRawDataHeaderSim header;
183
184   UInt_t sizeRawData = 0;
185
186   branch->GetEvent();
187   
188   GetDigits();
189
190   //if (!fPackedAcquisition) fMatchingWindow = 2097152;//AdC
191
192   Int_t jj = -1;
193   Int_t iDDL = -1;
194   Int_t nDDL = -1;
195   Int_t nTRM =  0;
196   Int_t iChain = -1;
197
198   //loop over TOF DDL files
199   for (nDDL=0; nDDL<AliDAQ::NumberOfDdls("TOF"); nDDL++) {
200
201     char fileName[256]="";
202     strncpy(fileName,AliDAQ::DdlFileName("TOF",nDDL),255); //The name of the output file
203
204     outfile = new AliFstream(fileName);
205     iDDL = AliTOFRawStream::GetDDLnumberPerSector(nDDL);
206
207     // write Dummy DATA HEADER
208     UInt_t dataHeaderPosition = outfile->Tellp();
209     outfile->WriteBuffer((char*)(&header),sizeof(header));
210
211     // DRM section: trailer
212     MakeDRMtrailer(buf);
213
214     // loop on TRM number per DRM
215     for (nTRM=AliTOFGeometry::NTRM(); nTRM>=3; nTRM--) {
216
217       fWordsPerTRM = 0;
218
219       // the slot number 3 of the even DRM (i.e. right) doesn't contain TDC digit data
220       if (iDDL%2==0 && nTRM==3) continue;
221
222       // loop on TRM chain number per TRM
223       for (iChain=AliTOFGeometry::NChain()-1; iChain>=0; iChain--) {
224
225         // TRM chain trailer
226         MakeTRMchainTrailer(iChain, buf); fWordsPerTRM++;
227
228         // TRM TDC digits
229         MakeTDCdigits(nDDL, nTRM, iChain, buf);
230
231         // TRM chain header
232         MakeTRMchainHeader(nTRM, iChain, buf); fWordsPerTRM++;
233
234       } // end loop on iChain
235
236       // TRM global header
237       MakeTRMheader(nTRM, buf); fWordsPerTRM++;
238
239       // TRM filler in case where TRM data number is odd
240       if ((fWordsPerTRM+1)%2!=0) {
241         MakeTRMfiller(buf); fWordsPerTRM++;
242       }
243
244       MakeTRMtrailer(buf); fWordsPerDRM++;
245
246       fWordsPerDRM += fWordsPerTRM;
247
248     } // end loop on nTRM
249
250
251     // LTM section
252     //fIndex++;
253     //buf[fIndex] = MakeFiller(); fWordsPerDRM++; // valid till when LTM word number was 33
254     MakeLTMtrailer(buf); fWordsPerDRM++;
255     MakeLTMdata(buf); fWordsPerDRM+=48;
256     MakeLTMheader(buf); fWordsPerDRM++;
257
258     // DRM section: in
259     MakeDRMheader(nDDL, buf);
260
261     ReverseArray(buf, fIndex+1);
262
263     outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t)));
264
265     for (jj=0; jj<(fIndex+1); jj++) buf[jj]=0;
266     fIndex = -1;
267     
268     //Write REAL DATA HEADER
269     UInt_t currentFilePosition = outfile->Tellp();
270     sizeRawData = currentFilePosition - dataHeaderPosition - sizeof(header);
271     header.fSize = currentFilePosition - dataHeaderPosition;
272     header.SetAttribute(0);  // valid data
273     outfile->Seekp(dataHeaderPosition);
274     outfile->WriteBuffer((char*)(&header),sizeof(header));
275     outfile->Seekp(currentFilePosition);
276
277     delete outfile;
278
279   } //end loop on DDL file number
280
281   return 0;
282
283 }
284
285 //----------------------------------------------------------------------------
286 void AliTOFDDLRawData::GetDigits()
287 {
288   //
289   // Fill the TOF volumes' map with the TOF digit indices
290   //
291
292   Int_t vol[5] = {-1,-1,-1,-1,-1};
293
294   Int_t digit = -1;
295   Int_t ndigits = fTOFdigitArray->GetEntries();
296   AliDebug(2, Form(" Number of read digits = %d",ndigits));
297   AliTOFdigit *digs;
298
299   // loop on TOF digits
300   for (digit=0; digit<ndigits; digit++) {
301     digs = (AliTOFdigit*)fTOFdigitArray->UncheckedAt(digit);
302
303     vol[0] = digs->GetSector(); // Sector Number (0-17)
304     vol[1] = digs->GetPlate();  // Plate Number (0-4)
305     vol[2] = digs->GetStrip();  // Strip Number (0-14/18)
306     vol[3] = digs->GetPadx();   // Pad Number in x direction (0-47)
307     vol[4] = digs->GetPadz();   // Pad Number in z direction (0-1)
308
309     fTOFdigitMap->AddDigit(vol, digit);
310
311   } // close loop on digit del TOF
312   AliDebug(2,Form(" Number of mapped digits = %d",fTOFdigitMap->GetFilledCellNumber()));
313 }
314
315 //----------------------------------------------------------------------------
316 void AliTOFDDLRawData::MakeDRMheader(Int_t nDDL, UInt_t *buf)
317 {
318   //
319   // DRM global header
320   //
321
322   //Int_t iDDL = fTOFrawStream->GetDDLnumberPerSector(nDDL);
323   Int_t iDDL = AliTOFRawStream::GetDDLnumberPerSector(nDDL);
324
325   //Int_t iSector = fTOFrawStream->GetSectorNumber(nDDL);
326   Int_t iSector = AliTOFRawStream::GetSectorNumber(nDDL);
327
328   UInt_t baseWord=0;
329   UInt_t word;
330
331   // DRM event CRC
332   baseWord=0;
333   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
334   AliBitPacking::PackWord(word,baseWord, 0, 3);
335   word = 0; // event CRC --> CHANGED
336   AliBitPacking::PackWord(word,baseWord, 4,19);
337   word = 0; // reserved for future use
338   AliBitPacking::PackWord(word,baseWord,20,27);
339   word = 4; // 0100 -> DRM header ID
340   AliBitPacking::PackWord(word,baseWord,28,31);
341   fIndex++;
342   buf[fIndex]=baseWord;
343
344   // DRM status header 4
345   baseWord=0;
346   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
347   AliBitPacking::PackWord(word,baseWord, 0, 3);
348   word = 0; // temperature
349   AliBitPacking::PackWord(word,baseWord, 4,13);
350   word = 0; // zero
351   AliBitPacking::PackWord(word,baseWord, 14,14);
352   word = 0; // ACK
353   AliBitPacking::PackWord(word,baseWord, 15,15);
354   word = 0; // Sens AD
355   AliBitPacking::PackWord(word,baseWord, 16,18);
356   word = 0; // zero
357   AliBitPacking::PackWord(word,baseWord, 19,19);
358   word = 0; // reserved for future use
359   AliBitPacking::PackWord(word,baseWord, 20,27);
360   word = 4; // 0100 -> DRM header ID
361   AliBitPacking::PackWord(word,baseWord,28,31);
362   fIndex++;
363   buf[fIndex]=baseWord;
364
365   // DRM status header 3
366   baseWord=0;
367   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
368   AliBitPacking::PackWord(word,baseWord, 0, 3);
369   word = 0; // L0 BCID
370   AliBitPacking::PackWord(word,baseWord, 4,15);
371   word = 0; // Run Time info
372   AliBitPacking::PackWord(word,baseWord, 16,27);
373   word = 4; // 0100 -> DRM header ID
374   AliBitPacking::PackWord(word,baseWord,28,31);
375   fIndex++;
376   buf[fIndex]=baseWord;
377
378   // DRM status header 2
379   baseWord=0;
380   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
381   AliBitPacking::PackWord(word,baseWord, 0, 3);
382
383   if (iDDL%2==1) {
384     word = 2047; // enable ID: [00000000000;11111111111] for odd
385                  // (i.e. right) crates
386     AliBitPacking::PackWord(word,baseWord, 4,14);
387   } else {
388     word = 2045; // enable ID: [00000000000;11111111101] for even
389                  // (i.e. left) crates
390     AliBitPacking::PackWord(word,baseWord, 4,14);
391   }
392
393   word = 0; //
394   AliBitPacking::PackWord(word,baseWord,15,15);
395   word = 0; // fault ID
396   AliBitPacking::PackWord(word,baseWord,16,26);
397   word = 0; // RTO
398   AliBitPacking::PackWord(word,baseWord,27,27);
399   word = 4; // 0100 -> DRM header ID
400   AliBitPacking::PackWord(word,baseWord,28,31);
401   fIndex++;
402   buf[fIndex]=baseWord;
403   
404   // DRM status header 1
405   baseWord=0;
406   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
407   AliBitPacking::PackWord(word,baseWord, 0, 3);
408
409   if (iDDL%2==1) {
410     word = 2047; // slot ID: [00000000000;11111111111] for odd
411                  // (i.e. right) crates
412     AliBitPacking::PackWord(word,baseWord, 4,14);
413   } else {
414     word = 2045; // slot ID: [00000000000;11111111101] for even
415                  // (i.e. left) crates
416     AliBitPacking::PackWord(word,baseWord, 4,14);
417   }
418       
419   word = 1; // LHC clock status: 1/0
420   AliBitPacking::PackWord(word,baseWord,15,15);
421   word = 0; // Vers ID
422   AliBitPacking::PackWord(word,baseWord,16,20);
423   word = 0; // DRMH size
424   AliBitPacking::PackWord(word,baseWord,21,24);
425   word = 0; // reserved for future use
426   AliBitPacking::PackWord(word,baseWord,25,27);
427   word = 4; // 0100 -> DRM header ID
428   AliBitPacking::PackWord(word,baseWord,28,31);
429   fIndex++;
430   buf[fIndex]=baseWord;
431
432   // DRM global header
433   baseWord=0;
434   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
435   AliBitPacking::PackWord(word,baseWord, 0, 3);
436   word = fIndex+1 + 1; // event words
437   AliBitPacking::PackWord(word,baseWord, 4,20);
438   word = iDDL; // crate ID [0;3]
439   AliBitPacking::PackWord(word,baseWord,21,22);
440   word = iSector; // sector ID [0;17]
441   AliBitPacking::PackWord(word,baseWord,23,27);
442   word = 4; // 0100 -> DRM header ID
443   AliBitPacking::PackWord(word,baseWord,28,31);
444   fIndex++;
445   buf[fIndex]=baseWord;
446
447 }
448
449 //----------------------------------------------------------------------------
450 void AliTOFDDLRawData::MakeDRMtrailer(UInt_t *buf)
451 {
452   //
453   // DRM global trailer
454   //
455   
456   UInt_t baseWord;
457   UInt_t word;
458   
459   baseWord=0;
460   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
461   AliBitPacking::PackWord(word,baseWord, 0, 3);
462   word = 0; // local event counter --> TO BE CHANGED IN fWordsPerDRM+5
463   AliBitPacking::PackWord(word,baseWord, 4,15);
464   word = 0; // reserved for future use
465   AliBitPacking::PackWord(word,baseWord,16,27);
466   word = 5; // 0101 -> DRM trailer ID
467   AliBitPacking::PackWord(word,baseWord,28,31);
468   fIndex++;
469   buf[fIndex]=baseWord;
470
471 }
472
473 //----------------------------------------------------------------------------
474 void AliTOFDDLRawData::MakeLTMheader(UInt_t *buf)
475 {
476   //
477   // LTM header
478   //
479
480   UInt_t baseWord;
481   UInt_t word;
482   
483   baseWord=0;
484   word = 2; // 0010 -> LTM data are coming from the VME slot number 2
485   AliBitPacking::PackWord(word,baseWord, 0, 3);
486   word = 35; // event words
487   AliBitPacking::PackWord(word,baseWord, 4,16);
488   word = 0; // crc error
489   AliBitPacking::PackWord(word,baseWord,17,17);
490   word = 0; // fault
491   AliBitPacking::PackWord(word,baseWord,18,23);
492   word = 0;
493   AliBitPacking::PackWord(word,baseWord,24,27);
494   word = 4; // 0100 -> LTM header ID
495   AliBitPacking::PackWord(word,baseWord,28,31);
496   fIndex++;
497   buf[fIndex]=baseWord;
498
499 }
500
501 //----------------------------------------------------------------------------
502 void AliTOFDDLRawData::MakeLTMdata(UInt_t *buf)
503 {
504   //
505   // LTM data
506   //
507
508   UInt_t baseWord;
509   UInt_t word;
510
511   baseWord=0;
512   word = 0;
513   AliBitPacking::PackWord(word,baseWord,0,9);
514   word = 0;
515   AliBitPacking::PackWord(word,baseWord,10,19);
516   word = 0;
517   AliBitPacking::PackWord(word,baseWord,20,29);
518   word = 0;
519   AliBitPacking::PackWord(word,baseWord,30,30);
520   word = 0;
521   AliBitPacking::PackWord(word,baseWord,31,31);
522
523
524   // OR45, OR46, OR47
525   fIndex++;
526   buf[fIndex]=baseWord;
527
528   // OR42, OR43, OR44
529   fIndex++;
530   buf[fIndex]=baseWord;
531
532   // OR39, OR40, OR41
533   fIndex++;
534   buf[fIndex]=baseWord;
535
536   // OR36, OR37, OR38
537   fIndex++;
538   buf[fIndex]=baseWord;
539
540   // OR33, OR34, OR35
541   fIndex++;
542   buf[fIndex]=baseWord;
543
544   // OR30, OR31, OR32
545   fIndex++;
546   buf[fIndex]=baseWord;
547
548   // OR27, OR28, OR29
549   fIndex++;
550   buf[fIndex]=baseWord;
551
552   // OR24, OR25, OR26
553   fIndex++;
554   buf[fIndex]=baseWord;
555
556   // OR21, OR22, OR23
557   fIndex++;
558   buf[fIndex]=baseWord;
559
560   // OR18, OR19, OR20
561   fIndex++;
562   buf[fIndex]=baseWord;
563
564   // OR15, OR16, OR17
565   fIndex++;
566   buf[fIndex]=baseWord;
567
568   // OR12, OR12, OR24
569   fIndex++;
570   buf[fIndex]=baseWord;
571
572   // OR9, OR10, OR11
573   fIndex++;
574   buf[fIndex]=baseWord;
575
576   // OR6, OR7, OR8
577   fIndex++;
578   buf[fIndex]=baseWord;
579
580   // OR3, OR4, OR5
581   fIndex++;
582   buf[fIndex]=baseWord;
583
584   // OR0, OR1, OR2
585   fIndex++;
586   buf[fIndex]=baseWord;
587
588
589   
590   baseWord=0;
591   word = 100; // Local temperature in LTM11 -> 4 X 25 degree (environment temperature)
592   AliBitPacking::PackWord(word,baseWord, 0, 9);
593   word = 100; // Local temperature in LTM10 -> 4 X 25 degree (environment temperature)
594   AliBitPacking::PackWord(word,baseWord,10,19);
595   word = 100; // Local temperature in LTM9 -> 4 X 25 degree (environment temperature)
596   AliBitPacking::PackWord(word,baseWord,20,29);
597   word = 0;
598   AliBitPacking::PackWord(word,baseWord,30,30);
599   word = 0;
600   AliBitPacking::PackWord(word,baseWord,31,31);
601
602   fIndex++;
603   buf[fIndex]=baseWord;
604
605   // Local temperature in LTM8, LMT7, LTM6 -> 4 X 25 degree (environment temperature)
606   fIndex++;
607   buf[fIndex]=baseWord;
608
609   // Local temperature in LTM5, LMT4, LTM3 -> 4 X 25 degree (environment temperature)
610   fIndex++;
611   buf[fIndex]=baseWord;
612
613   // Local temperature in LTM2, LMT1, LTM0 -> 4 X 25 degree (environment temperature)
614   fIndex++;
615   buf[fIndex]=baseWord;
616
617
618
619   // Local temperature in T7, T6, T5 -> 4 X 25 degree (environment temperature)
620   fIndex++;
621   buf[fIndex]=baseWord;
622
623   // Local temperature in T4, T3, T2 -> 4 X 25 degree (environment temperature)
624   fIndex++;
625   buf[fIndex]=baseWord;
626
627   // Local temperature in T1, T0 -> 4 X 25 degree (environment temperature)
628   // Local temperature in VTH15 -> Thereshould voltage for FEAC15
629   fIndex++;
630   buf[fIndex]=baseWord;
631
632   baseWord=0;
633   word = 0; // VTH13 -> Thereshould voltage for FEAC16
634   AliBitPacking::PackWord(word,baseWord, 0, 9);
635   word = 0; // VTH14 -> Thereshould voltage for FEAC14
636   AliBitPacking::PackWord(word,baseWord,10,19);
637   word = 0; // GND-FEAC7 -> Voltage drop between GND and FEAC7
638   AliBitPacking::PackWord(word,baseWord,20,29);
639   word = 0;
640   AliBitPacking::PackWord(word,baseWord,30,30);
641   word = 0;
642   AliBitPacking::PackWord(word,baseWord,31,31);
643
644   fIndex++;
645   buf[fIndex]=baseWord;
646
647   // VTH11 -> Thereshould voltage for FEAC11
648   // VTH12 -> Thereshould voltage for FEAC12
649   // GND-FEAC6 -> Voltage drop between GND and FEAC6
650   fIndex++;
651   buf[fIndex]=baseWord;
652
653   // VTH9 -> Thereshould voltage for FEAC11
654   // VTH10 -> Thereshould voltage for FEAC12
655   // GND-FEAC5 -> Voltage drop between GND and FEAC6
656   fIndex++;
657   buf[fIndex]=baseWord;
658
659   // VTH7 -> Thereshould voltage for FEAC11
660   // VTH8 -> Thereshould voltage for FEAC12
661   // GND-FEAC4 -> Voltage drop between GND and FEAC6
662   fIndex++;
663   buf[fIndex]=baseWord;
664
665   // VTH5 -> Thereshould voltage for FEAC11
666   // VTH6 -> Thereshould voltage for FEAC12
667   // GND-FEAC3 -> Voltage drop between GND and FEAC6
668   fIndex++;
669   buf[fIndex]=baseWord;
670
671   // VTH3 -> Thereshould voltage for FEAC11
672   // VTH4 -> Thereshould voltage for FEAC12
673   // GND-FEAC2 -> Voltage drop between GND and FEAC6
674   fIndex++;
675   buf[fIndex]=baseWord;
676
677   // VTH1 -> Thereshould voltage for FEAC11
678   // VTH2 -> Thereshould voltage for FEAC12
679   // GND-FEAC1 -> Voltage drop between GND and FEAC6
680   fIndex++;
681   buf[fIndex]=baseWord;
682
683   // LV15
684   // VTH0 -> Thereshould voltage for FEAC12
685   // GND-FEAC0 -> Voltage drop between GND and FEAC6
686   fIndex++;
687   buf[fIndex]=baseWord;
688
689   // LV15
690   // VTH0 -> Thereshould voltage for FEAC12
691   // GND-FEAC0 -> Voltage drop between GND and FEAC6
692   fIndex++;
693   buf[fIndex]=baseWord;
694
695   // LV12
696   // LV13
697   // LV14
698   fIndex++;
699   buf[fIndex]=baseWord;
700
701   // LV9
702   // LV10
703   // LV11
704   fIndex++;
705   buf[fIndex]=baseWord;
706
707   // LV6
708   // LV7
709   // LV8
710   fIndex++;
711   buf[fIndex]=baseWord;
712
713   // LV3
714   // LV4
715   // LV5
716   fIndex++;
717   buf[fIndex]=baseWord;
718
719   // LV0
720   // LV1
721   // LV2
722   fIndex++;
723   buf[fIndex]=baseWord;
724
725
726
727   baseWord=0;
728   word = 0; // PDL45 -> Delay Line setting for PDL41
729   AliBitPacking::PackWord(word,baseWord, 0, 7);
730   word = 0; // PDL46 -> Delay Line setting for PDL42
731   AliBitPacking::PackWord(word,baseWord, 8,15);
732   word = 0; // PDL47 -> Delay Line setting for PDL43
733   AliBitPacking::PackWord(word,baseWord,16,23);
734   word = 0; // PDL48 -> Delay Line setting for PDL44
735   AliBitPacking::PackWord(word,baseWord,24,31);
736   fIndex++;
737   buf[fIndex]=baseWord;
738
739   // Delay Line setting for PDL37, PDL38, PDL39, PDL40
740   fIndex++;
741   buf[fIndex]=baseWord;
742
743   // Delay Line setting for PDL33, PDL34, PDL35, PDL36
744   fIndex++;
745   buf[fIndex]=baseWord;
746
747   // Delay Line setting for PDL29, PDL30, PDL31, PDL32
748   fIndex++;
749   buf[fIndex]=baseWord;
750
751   // Delay Line setting for PDL25, PDL26, PDL27, PDL28
752   fIndex++;
753   buf[fIndex]=baseWord;
754
755   // Delay Line setting for PDL21, PDL22, PDL23, PDL24
756   fIndex++;
757   buf[fIndex]=baseWord;
758
759   // Delay Line setting for PDL17, PDL18, PDL19, PDL20
760   fIndex++;
761   buf[fIndex]=baseWord;
762
763   // Delay Line setting for PDL13, PDL14, PDL15, PDL16
764   fIndex++;
765   buf[fIndex]=baseWord;
766
767   // Delay Line setting for PDL9, PDL10, PDL11, PDL12
768   fIndex++;
769   buf[fIndex]=baseWord;
770
771   // Delay Line setting for PDL5, PDL6, PDL7, PDL8
772   fIndex++;
773   buf[fIndex]=baseWord;
774
775   // Delay Line setting for PDL1, PDL2, PDL3, PDL4
776   fIndex++;
777   buf[fIndex]=baseWord;
778
779 }
780
781 //----------------------------------------------------------------------------
782 void AliTOFDDLRawData::MakeLTMtrailer(UInt_t *buf)
783 {
784   //
785   // LTM trailer
786   //
787  
788   UInt_t baseWord;
789   UInt_t word;
790   
791   baseWord=0;
792   word = 2; // 0010 -> LTM data are coming from the VME slot number 2
793   AliBitPacking::PackWord(word,baseWord, 0, 3);
794   word = 0; // event crc
795   AliBitPacking::PackWord(word,baseWord, 4,15);
796   word = 0; // event number
797   AliBitPacking::PackWord(word,baseWord,16,27);
798   word = 5; // 0101 -> LTM trailer ID
799   AliBitPacking::PackWord(word,baseWord,28,31);
800   fIndex++;
801   buf[fIndex]=baseWord;
802
803 }
804
805 //----------------------------------------------------------------------------
806 void AliTOFDDLRawData::MakeTRMheader(Int_t nTRM, UInt_t *buf)
807 {
808   //
809   // TRM header for the TRM number nTRM [ 3;12]
810   //
811
812   if (nTRM<3 || nTRM>12) {
813     AliWarning(Form(" TRM number is out of the right range [3;12] (nTRM = %3i",nTRM));
814     return;
815   }
816
817   UInt_t baseWord;
818   UInt_t word;
819
820   baseWord = 0;
821   word = nTRM; // TRM data coming from the VME slot number nTRM
822   AliBitPacking::PackWord(word,baseWord, 0, 3);
823   word = 0; // event words
824   AliBitPacking::PackWord(word,baseWord, 4,16);
825
826   if (fPackedAcquisition)
827     word = 0; // ACQuisition mode: [0;3] see document
828   else
829     word = 3; // ACQuisition mode: [0;3] see document
830   AliBitPacking::PackWord(word,baseWord,17,18);
831   word = 0; // description of a SEU inside LUT tables for INL compensation;
832             // the data are unaffected
833   AliBitPacking::PackWord(word,baseWord,19,19);
834   word = 0; // Must Be Zero (MBZ)
835   AliBitPacking::PackWord(word,baseWord,20,27);
836   word = 4; // 0100 -> TRM header ID
837   AliBitPacking::PackWord(word,baseWord,28,31);
838   fIndex++;
839   buf[fIndex]=baseWord;
840
841 }
842
843 //----------------------------------------------------------------------------
844 void AliTOFDDLRawData::MakeTRMtrailer(UInt_t *buf)
845 {
846   //
847   // Set TRM Global Trailer
848   // with the calculated CRC
849   //
850
851   UInt_t baseWord;
852   UInt_t word;
853
854   baseWord=0;
855   word = 15; // 1111 -> TRM trailer ID 1
856   AliBitPacking::PackWord(word,baseWord, 0, 3);
857
858   UInt_t trmCRC=0x0;
859   for (Int_t ii=fIndex-(fWordsPerTRM-1); ii<fIndex; ii++)
860     trmCRC ^= buf[ii];
861   //PH  printf(" A trmCRC=%d\n",trmCRC);
862
863   word = 0x0;
864   word ^= ( (trmCRC & 0x00000fff) >>  0);
865   word ^= ( (trmCRC & 0x00fff000) >> 12);
866   word ^= ( (trmCRC & 0xff000000) >> 24);
867
868   //PH  printf(" B trmCRC=%d\n",word);
869
870   AliBitPacking::PackWord(word,baseWord, 4,15); // event CRC --> CHANGED
871
872   word = 0; // local event counter == DRM local event counter --> TO BE CHANGED
873   AliBitPacking::PackWord(word,baseWord,16,27);
874   word = 5; // 0101 -> TRM trailer ID 2
875   AliBitPacking::PackWord(word,baseWord,28,31);
876
877   fIndex++;
878   for (Int_t ii=fIndex; ii>fIndex-fWordsPerTRM; ii--)
879     buf[ii]=buf[ii-1];
880
881   buf[fIndex-fWordsPerTRM] = baseWord;
882
883 }
884   
885 //----------------------------------------------------------------------------
886 void AliTOFDDLRawData::MakeTRMchainHeader(Int_t nTRM, Int_t iChain,
887                                           UInt_t *buf)
888 {
889   //
890   // TRM chain header
891   //
892   
893   UInt_t baseWord;
894   UInt_t word;
895
896   if (nTRM<3 || nTRM>12) {
897     AliWarning(Form(" TRM number is out of the right range [3;12] (nTRM = %3i", nTRM));
898     return;
899   }
900   
901   if (iChain<0 || iChain>1) {
902     AliWarning(Form(" Chain number is out of the right range [0;1] (iChain = %3i", iChain));
903     return;
904   }
905
906   baseWord=0;
907   word = nTRM; // TRM data coming from the VME slot ID nTRM
908   AliBitPacking::PackWord(word,baseWord, 0, 3);
909   word = 0; // bunch ID
910   AliBitPacking::PackWord(word,baseWord, 4,15);
911   word = 0;//100; // PB24 temperature -> 4 X 25 degree (environment temperature)
912   AliBitPacking::PackWord(word,baseWord,16,23);
913   word = 0;//(Int_t)(5 * gRandom->Rndm()); // PB24 ID [0;4]
914   AliBitPacking::PackWord(word,baseWord,24,26);
915   word = 0; // TS
916   AliBitPacking::PackWord(word,baseWord,27,27);
917   switch (iChain) {
918     case 0:
919       word = 0; // 0000 -> TRM chain 0 ID
920       break;
921     case 1:
922       word = 2; // 0010 -> TRM chain 1 ID
923       break;
924     }
925   AliBitPacking::PackWord(word,baseWord,28,31);
926   fIndex++;
927   buf[fIndex]=baseWord;
928             
929 }
930
931 //----------------------------------------------------------------------------
932 void AliTOFDDLRawData::MakeTRMfiller(UInt_t *buf)
933 {
934   //
935   // TRM filler
936   //
937
938   Int_t jj = -1;
939
940   fIndex++;
941   for (jj=fIndex; jj>fIndex-fWordsPerTRM; jj--)
942     buf[jj] = buf[jj-1];
943
944   buf[fIndex-fWordsPerTRM] = MakeFiller();
945
946 }
947   
948 //----------------------------------------------------------------------------
949 UInt_t AliTOFDDLRawData::MakeFiller() const
950 {
951   //
952   // Filler word definition: to make even the number of words per TRM/LTM
953   //
954
955   UInt_t baseWord;
956   UInt_t word;
957
958   baseWord=0;
959   word = 0; // 0000 -> filler ID 1
960   AliBitPacking::PackWord(word,baseWord, 0, 3);
961   word = 0; // MBZ
962   AliBitPacking::PackWord(word,baseWord, 4,27);
963   word = 7; // 0111 -> filler ID 2
964   AliBitPacking::PackWord(word,baseWord, 28,31);
965   
966   return baseWord;
967
968 }
969
970 //----------------------------------------------------------------------------
971 void AliTOFDDLRawData::MakeTRMchainTrailer(Int_t iChain, UInt_t *buf)
972 {
973   //
974   // TRM chain trailer
975   //
976
977   if (iChain<0 || iChain>1) {
978     AliWarning(Form(" Chain number is out of the right range [0;1] (iChain = %3i", iChain));
979     return;
980   }
981
982   UInt_t baseWord;
983   UInt_t word;
984   
985   baseWord=0;
986   word = 0; // status
987   AliBitPacking::PackWord(word,baseWord, 0, 3);
988   word = 0; // MBZ
989   AliBitPacking::PackWord(word,baseWord, 4,15);
990   word = 0; // event counter --> TO BE CHANGED
991   AliBitPacking::PackWord(word,baseWord,16,27);
992   switch (iChain) {
993     case 0:
994       word = 1; // 0001 -> TRM chain 0 trailer ID
995       break;
996     case 1:
997       word = 3; // 0011 -> TRM chain 1 trailer ID
998       break;
999     }
1000   AliBitPacking::PackWord(word,baseWord,28,31);
1001   fIndex++;
1002   buf[fIndex]=baseWord;
1003
1004 }
1005
1006 //----------------------------------------------------------------------------
1007 void AliTOFDDLRawData::MakeTDCdigits(Int_t nDDL, Int_t nTRM, Int_t iChain, UInt_t *buf)
1008 {
1009   //
1010   // TRM TDC digit
1011   //
1012
1013   const Double_t kOneMoreFilledCell = 1./(AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors());
1014   Double_t percentFilledCells = Double_t(fTOFdigitMap->GetFilledCellNumber())/(AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors());
1015
1016   if (nDDL<0 || nDDL>71) {
1017     AliWarning(Form(" DDL number is out of the right range [0;71] (nDDL = %3i", nDDL));
1018     return;
1019   }
1020   
1021   if (nTRM<3 || nTRM>12) {
1022     AliWarning(Form(" TRM number is out of the right range [3;12] (nTRM = %3i", nTRM));
1023     return;
1024   }
1025   
1026   if (iChain<0 || iChain>1) {
1027     AliWarning(Form(" Chain number is out of the right range [0;1] (iChain = %3i", iChain));
1028     return;
1029   }
1030   
1031   Int_t psArray[1000];
1032   UInt_t localBuffer[1000];
1033   Int_t localIndex = -1;
1034
1035   Int_t iDDL = nDDL%AliTOFGeometry::NDDL();
1036
1037   Int_t volume[5] = {-1, -1, -1, -1, -1};
1038   Int_t indexDigit[3] = {-1, -1, -1};
1039
1040   Int_t totCharge = -1;
1041   Int_t timeOfFlight = -1;
1042
1043   Int_t trailingSpurious = -1;
1044   Int_t leadingSpurious = -1;
1045
1046   AliTOFdigit *digs;
1047
1048   UInt_t baseWord=0;
1049   UInt_t word=0;
1050
1051   Int_t jj = -1;
1052   Int_t nTDC = -1;
1053   Int_t iCH = -1;
1054
1055   //Int_t numberOfMeasuresPerChannel = 0;
1056   //Int_t maxMeasuresPerChannelInTDC = 0;
1057
1058   Bool_t outOut = HeadOrTail();
1059
1060   ofstream ftxt;
1061
1062   if (fVerbose==2) ftxt.open("TOFdigits.txt",ios::app);
1063
1064   for (jj=0; jj<5; jj++) volume[jj] = -1;
1065
1066   // loop on TDC number
1067   for (nTDC=AliTOFGeometry::NTdc()-1; nTDC>=0; nTDC--) {
1068
1069     // the DRM odd (i.e. left) slot number 3 doesn't contain TDC digit data
1070     // for TDC numbers 3-14
1071     if (iDDL%2==1 && nTRM==3 && (Int_t)(nTDC/3)!=0) continue;
1072
1073     // loop on TDC channel number
1074     for (iCH=AliTOFGeometry::NCh()-1; iCH>=0; iCH--) {
1075
1076       //numberOfMeasuresPerChannel = 0;
1077
1078       for (Int_t aa=0; aa<5; aa++) volume[aa]=-1;
1079       AliTOFRawStream::EquipmentId2VolumeId(nDDL, nTRM, iChain, nTDC, iCH, volume);
1080         
1081       AliDebug(3,Form(" volume -> %2d %1d %2d %2d %1d",volume[0],volume[1],volume[2],volume[3],volume[4]));
1082
1083       if (volume[0]==-1 || volume[1]==-1 || volume[2]==-1 ||
1084           volume[3]==-1 || volume[4]==-1) continue;
1085
1086       AliDebug(3,Form(" ====== %2d %1d %2d %2d %1d",volume[0],volume[1],volume[2],volume[3],volume[4]));
1087
1088       for (jj=0; jj<3; jj++) indexDigit[jj] = -1;
1089
1090       fTOFdigitMap->GetDigitIndex(volume, indexDigit);
1091
1092       if (indexDigit[0]<0) {
1093
1094         trailingSpurious = Int_t(2097152*gRandom->Rndm());
1095         leadingSpurious = Int_t(2097152*gRandom->Rndm());
1096
1097         if ( fFakeOrphaneProduction &&
1098              ( ( fPackedAcquisition && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) ||
1099                (!fPackedAcquisition && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) )  )  ) {
1100
1101           percentFilledCells+=kOneMoreFilledCell;
1102
1103           Int_t dummyPS = 0;
1104
1105           if (outOut) {
1106             word = trailingSpurious; // trailing edge measurement
1107             dummyPS = 2;
1108           }
1109           else {
1110             word = leadingSpurious; // leading edge measurement
1111             dummyPS = 1;
1112           }
1113
1114           if (fVerbose==2) {
1115             if (nDDL<10) ftxt << "  " << nDDL;
1116             else         ftxt << " " << nDDL;
1117             if (nTRM<10) ftxt << "  " << nTRM;
1118             else         ftxt << " " << nTRM;
1119             ftxt << "  " << iChain;
1120             if (nTDC<10) ftxt << "  " << nTDC;
1121             else         ftxt << " " << nTDC;
1122             ftxt << "  " << iCH;
1123             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1124             else              ftxt  << "  -> " << volume[0];
1125             ftxt << "  " << volume[1];
1126             if (volume[2]<10) ftxt << "  " << volume[2];
1127             else              ftxt << " " << volume[2];
1128             ftxt << "  " << volume[4];
1129             if (volume[3]<10) ftxt << "  " << volume[3];
1130             else              ftxt << " " << volume[3];
1131             ftxt << "   " << -1;
1132             if (word<10)                           ftxt << "        " << word;
1133             else if (word>=10     && word<100)     ftxt << "       " << word;
1134             else if (word>=100    && word<1000)    ftxt << "      " << word;
1135             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1136             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1137             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1138             else                                   ftxt << "  " << word;
1139             ftxt << "   " << dummyPS << endl;
1140           }
1141
1142           AliBitPacking::PackWord(word,baseWord, 0,20);
1143           word = iCH; // TDC channel ID [0;7]
1144           AliBitPacking::PackWord(word,baseWord,21,23);
1145           word = nTDC; // TDC ID [0;14]
1146           AliBitPacking::PackWord(word,baseWord,24,27);
1147           word = 0; // error flag
1148           AliBitPacking::PackWord(word,baseWord,28,28);
1149           word = dummyPS; // Packing Status [0;3]
1150           AliBitPacking::PackWord(word,baseWord,29,30);
1151           word = 1; // TRM TDC digit ID
1152           AliBitPacking::PackWord(word,baseWord,31,31);
1153
1154           localIndex++; fWordsPerTRM++;
1155           localBuffer[localIndex]=baseWord;
1156           psArray[localIndex]=dummyPS;
1157
1158           baseWord=0;
1159
1160         } // if ( fFakeOrphaneProduction && ( ( fPackedAcquisition && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) or ... ) )
1161       } // if (indexDigit[0]<0)
1162
1163       for (jj=0; jj<3;jj++) {
1164
1165         if (indexDigit[jj]<0) continue;
1166
1167         AliDebug(3,Form(" ====== %2d %1d %2d %2d %1d -> %1d %d",volume[0],volume[1],volume[2],volume[3],volume[4],jj,indexDigit[jj]));
1168
1169         digs = (AliTOFdigit*)fTOFdigitArray->UncheckedAt(indexDigit[jj]);
1170           
1171         if (digs->GetSector()!=volume[0] ||
1172             digs->GetPlate() !=volume[1] ||
1173             digs->GetStrip() !=volume[2] ||
1174             digs->GetPadx()  !=volume[3] ||
1175             digs->GetPadz()  !=volume[4]) AliWarning(Form(" --- ERROR --- %2i (%2i)  %1i (%1i)  %2i (%2i)  %2i (%2i)  %1i (%1i)",
1176                                                           digs->GetSector(), volume[0],
1177                                                           digs->GetPlate(), volume[1],
1178                                                           digs->GetStrip(), volume[2],
1179                                                           digs->GetPadx(), volume[3],
1180                                                           digs->GetPadz(), volume[4])
1181                                                      );
1182
1183         timeOfFlight = (Int_t)(digs->GetTdc());
1184         /*+
1185           fTOFCableLengthMap->GetCableTimeShiftBin(nDDL, nTRM, iChain, nTDC)*/;
1186
1187         //if (timeOfFlight>=fMatchingWindow+1000) continue; // adc
1188         //if (timeOfFlight>=fMatchingWindow) continue; // adc
1189         if (digs->GetTdcND()>=fMatchingWindow) {
1190           AliDebug(2,"Out of matching window.");
1191           continue; // adc
1192         }
1193         else AliDebug(2,"In matching window");
1194
1195         //numberOfMeasuresPerChannel++;
1196
1197         // totCharge = (Int_t)digs->GetAdc(); //Use realistic ToT, for Standard production with no miscalibration/Slewing it == fAdC in digit (see AliTOFDigitizer)
1198         totCharge = (Int_t)(digs->GetToT());
1199         // temporary control
1200         if (totCharge<0) totCharge = 0;//TMath::Abs(totCharge);
1201
1202         if (fPackedAcquisition) {
1203
1204         if (fVerbose==2) {
1205           if (nDDL<10) ftxt << "  " << nDDL;
1206           else         ftxt << " " << nDDL;
1207           if (nTRM<10) ftxt << "  " << nTRM;
1208           else         ftxt << " " << nTRM;
1209           ftxt << "  " << iChain;
1210           if (nTDC<10) ftxt << "  " << nTDC;
1211           else         ftxt << " " << nTDC;
1212           ftxt << "  " << iCH;
1213           if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1214           else              ftxt  << "  -> " << volume[0];
1215           ftxt << "  " << volume[1];
1216           if (volume[2]<10) ftxt << "  " << volume[2];
1217           else              ftxt << " " << volume[2];
1218           ftxt << "  " << volume[4];
1219           if (volume[3]<10) ftxt << "  " << volume[3];
1220           else              ftxt << " " << volume[3];
1221           if (totCharge<10)                        ftxt << "    " << totCharge;
1222           else if (totCharge>=10 && totCharge<100) ftxt << "   " << totCharge;
1223           else                                     ftxt << "  " << totCharge;
1224           if (timeOfFlight<10)                             ftxt << "     " << timeOfFlight << endl;
1225           else if (timeOfFlight>=10  && timeOfFlight<100)  ftxt << "    " << timeOfFlight << endl;
1226           else if (timeOfFlight>=100 && timeOfFlight<1000) ftxt << "   " << timeOfFlight << endl;
1227           else                                             ftxt << "  " << timeOfFlight << endl;
1228         }
1229
1230         word = timeOfFlight%8192; // time-of-fligth measurement
1231         AliBitPacking::PackWord(word,baseWord, 0,12);
1232
1233         if (totCharge>=256) totCharge = 255;
1234         word = totCharge; // time-over-threshould measurement
1235         AliBitPacking::PackWord(word,baseWord,13,20);
1236
1237         word = iCH; // TDC channel ID [0;7]
1238         AliBitPacking::PackWord(word,baseWord,21,23);
1239         word = nTDC; // TDC ID [0;14]
1240         AliBitPacking::PackWord(word,baseWord,24,27);
1241         word = 0; // error flag
1242         AliBitPacking::PackWord(word,baseWord,28,28);
1243         word = 0; // Packing Status [0;3]
1244         AliBitPacking::PackWord(word,baseWord,29,30);
1245         word = 1; // TRM TDC digit ID
1246         AliBitPacking::PackWord(word,baseWord,31,31);
1247
1248         localIndex++; fWordsPerTRM++;
1249         localBuffer[localIndex]=baseWord;
1250
1251         baseWord=0;
1252
1253         if ( fFakeOrphaneProduction &&
1254              percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) {
1255
1256           percentFilledCells+=kOneMoreFilledCell;
1257
1258           trailingSpurious = Int_t(2097152*gRandom->Rndm());
1259           leadingSpurious = Int_t(2097152*gRandom->Rndm());
1260
1261           Int_t dummyPS = 0;
1262
1263           if (outOut) {
1264             word = trailingSpurious; // trailing edge measurement
1265             dummyPS = 2;
1266           }
1267           else {
1268             word = leadingSpurious; // leading edge measurement
1269             dummyPS = 1;
1270           }
1271
1272           if (fVerbose==2) {
1273             if (nDDL<10) ftxt << "  " << nDDL;
1274             else         ftxt << " " << nDDL;
1275             if (nTRM<10) ftxt << "  " << nTRM;
1276             else         ftxt << " " << nTRM;
1277             ftxt << "  " << iChain;
1278             if (nTDC<10) ftxt << "  " << nTDC;
1279             else         ftxt << " " << nTDC;
1280             ftxt << "  " << iCH;
1281             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1282             else              ftxt  << "  -> " << volume[0];
1283             ftxt << "  " << volume[1];
1284             if (volume[2]<10) ftxt << "  " << volume[2];
1285             else              ftxt << " " << volume[2];
1286             ftxt << "  " << volume[4];
1287             if (volume[3]<10) ftxt << "  " << volume[3];
1288             else              ftxt << " " << volume[3];
1289             ftxt << "   " << -1;
1290             if (word<10)                           ftxt << "        " << word;
1291             else if (word>=10     && word<100)     ftxt << "       " << word;
1292             else if (word>=100    && word<1000)    ftxt << "      " << word;
1293             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1294             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1295             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1296             else                                   ftxt << "  " << word;
1297             ftxt << "   " << dummyPS << endl;
1298           }
1299
1300           AliBitPacking::PackWord(word,baseWord, 0,20);
1301           word = iCH; // TDC channel ID [0;7]
1302           AliBitPacking::PackWord(word,baseWord,21,23);
1303           word = nTDC; // TDC ID [0;14]
1304           AliBitPacking::PackWord(word,baseWord,24,27);
1305           word = 0; // error flag
1306           AliBitPacking::PackWord(word,baseWord,28,28);
1307           word = dummyPS; // Packing Status [0;3]
1308           AliBitPacking::PackWord(word,baseWord,29,30);
1309           word = 1; // TRM TDC digit ID
1310           AliBitPacking::PackWord(word,baseWord,31,31);
1311
1312           localIndex++; fWordsPerTRM++;
1313           localBuffer[localIndex]=baseWord;
1314           psArray[localIndex]=dummyPS;
1315
1316           baseWord=0;
1317
1318         } // if ( fFakeOrphaneProduction && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) )
1319
1320
1321         } // if (fPackedAcquisition)
1322         else { // if (!fPackedAcquisition)
1323
1324         if ( fFakeOrphaneProduction &&
1325              percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && outOut ) {
1326
1327           percentFilledCells+=kOneMoreFilledCell;
1328
1329           trailingSpurious = Int_t(2097152*gRandom->Rndm());
1330           word = trailingSpurious;
1331           Int_t dummyPS = 2;
1332
1333           if (fVerbose==2) {
1334             if (nDDL<10) ftxt << "  " << nDDL;
1335             else         ftxt << " " << nDDL;
1336             if (nTRM<10) ftxt << "  " << nTRM;
1337             else         ftxt << " " << nTRM;
1338             ftxt << "  " << iChain;
1339             if (nTDC<10) ftxt << "  " << nTDC;
1340             else         ftxt << " " << nTDC;
1341             ftxt << "  " << iCH;
1342             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1343             else              ftxt  << "  -> " << volume[0];
1344             ftxt << "  " << volume[1];
1345             if (volume[2]<10) ftxt << "  " << volume[2];
1346             else              ftxt << " " << volume[2];
1347             ftxt << "  " << volume[4];
1348             if (volume[3]<10) ftxt << "  " << volume[3];
1349             else              ftxt << " " << volume[3];
1350             ftxt << "   " << -1;
1351             if (word<10)                           ftxt << "        " << word;
1352             else if (word>=10     && word<100)     ftxt << "       " << word;
1353             else if (word>=100    && word<1000)    ftxt << "      " << word;
1354             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1355             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1356             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1357             else                                   ftxt << "  " << word;
1358             ftxt << "   " << dummyPS << endl;
1359           }
1360
1361           AliBitPacking::PackWord(word,baseWord, 0,20);
1362           word = iCH; // TDC channel ID [0;7]
1363           AliBitPacking::PackWord(word,baseWord,21,23);
1364           word = nTDC; // TDC ID [0;14]
1365           AliBitPacking::PackWord(word,baseWord,24,27);
1366           word = 0; // error flag
1367           AliBitPacking::PackWord(word,baseWord,28,28);
1368           word = dummyPS; // Packing Status [0;3]
1369           AliBitPacking::PackWord(word,baseWord,29,30);
1370           word = 1; // TRM TDC digit ID
1371           AliBitPacking::PackWord(word,baseWord,31,31);
1372
1373           localIndex++; fWordsPerTRM++;
1374           localBuffer[localIndex]=baseWord;
1375           psArray[localIndex]=dummyPS;
1376
1377           baseWord=0;
1378
1379         } // if ( fFakeOrphaneProduction && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells)  && outOut )
1380
1381
1382         word = (timeOfFlight + Int_t(totCharge*AliTOFGeometry::ToTBinWidth()/AliTOFGeometry::TdcBinWidth()))%2097152; // trailing edge measurement
1383
1384         if (fVerbose==2) {
1385           if (nDDL<10) ftxt << "  " << nDDL;
1386           else         ftxt << " " << nDDL;
1387           if (nTRM<10) ftxt << "  " << nTRM;
1388           else         ftxt << " " << nTRM;
1389           ftxt << "  " << iChain;
1390           if (nTDC<10) ftxt << "  " << nTDC;
1391           else         ftxt << " " << nTDC;
1392           ftxt << "  " << iCH;
1393           if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1394           else              ftxt  << "  -> " << volume[0];
1395           ftxt << "  " << volume[1];
1396           if (volume[2]<10) ftxt << "  " << volume[2];
1397           else              ftxt << " " << volume[2];
1398           ftxt << "  " << volume[4];
1399           if (volume[3]<10) ftxt << "  " << volume[3];
1400           else              ftxt << " " << volume[3];
1401           ftxt << "   " << -1;
1402           if (word<10)                           ftxt << "        " << word;
1403           else if (word>=10     && word<100)     ftxt << "       " << word;
1404           else if (word>=100    && word<1000)    ftxt << "      " << word;
1405           else if (word>=1000   && word<10000)   ftxt << "     " << word;
1406           else if (word>=10000  && word<100000)  ftxt << "    " << word;
1407           else if (word>=100000 && word<1000000) ftxt << "   " << word;
1408           else                                   ftxt << "  " << word;
1409           ftxt << "   " << 2 << endl;
1410         }
1411
1412         AliBitPacking::PackWord(word,baseWord, 0,20);
1413
1414         word = iCH; // TDC channel ID [0;7]
1415         AliBitPacking::PackWord(word,baseWord,21,23);
1416         word = nTDC; // TDC ID [0;14]
1417         AliBitPacking::PackWord(word,baseWord,24,27);
1418         word = 0; // error flag
1419         AliBitPacking::PackWord(word,baseWord,28,28);
1420         word = 2; // Packing Status [0;3]
1421         AliBitPacking::PackWord(word,baseWord,29,30);
1422         word = 1; // TRM TDC digit ID
1423         AliBitPacking::PackWord(word,baseWord,31,31);
1424
1425         localIndex++; fWordsPerTRM++;
1426         localBuffer[localIndex]=baseWord;
1427         psArray[localIndex]=2;
1428
1429         baseWord=0;
1430
1431         word = timeOfFlight%2097152; // leading edge measurement
1432
1433         if (fVerbose==2) {
1434           if (nDDL<10) ftxt << "  " << nDDL;
1435           else         ftxt << " " << nDDL;
1436           if (nTRM<10) ftxt << "  " << nTRM;
1437           else         ftxt << " " << nTRM;
1438           ftxt << "  " << iChain;
1439           if (nTDC<10) ftxt << "  " << nTDC;
1440           else         ftxt << " " << nTDC;
1441           ftxt << "  " << iCH;
1442           if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1443           else              ftxt  << "  -> " << volume[0];
1444           ftxt << "  " << volume[1];
1445           if (volume[2]<10) ftxt << "  " << volume[2];
1446           else              ftxt << " " << volume[2];
1447           ftxt << "  " << volume[4];
1448           if (volume[3]<10) ftxt << "  " << volume[3];
1449           else              ftxt << " " << volume[3];
1450           ftxt << "   " << -1;
1451           if (word<10)                           ftxt << "        " << word;
1452           else if (word>=10     && word<100)     ftxt << "       " << word;
1453           else if (word>=100    && word<1000)    ftxt << "      " << word;
1454           else if (word>=1000   && word<10000)   ftxt << "     " << word;
1455           else if (word>=10000  && word<100000)  ftxt << "    " << word;
1456           else if (word>=100000 && word<1000000) ftxt << "   " << word;
1457           else                                   ftxt << "  " << word;
1458           ftxt << "   " << 1 << endl;
1459         }
1460
1461         AliBitPacking::PackWord(word,baseWord, 0,20);
1462
1463         word = iCH; // TDC channel ID [0;7]
1464         AliBitPacking::PackWord(word,baseWord,21,23);
1465         word = nTDC; // TDC ID [0;14]
1466         AliBitPacking::PackWord(word,baseWord,24,27);
1467         word = 0; // error flag
1468         AliBitPacking::PackWord(word,baseWord,28,28);
1469         word = 1; // Packing Status [0;3]
1470         AliBitPacking::PackWord(word,baseWord,29,30);
1471         word = 1; // TRM TDC digit ID
1472         AliBitPacking::PackWord(word,baseWord,31,31);
1473
1474         localIndex++; fWordsPerTRM++;
1475         localBuffer[localIndex]=baseWord;
1476         psArray[localIndex]=1;
1477
1478         baseWord=0;
1479
1480
1481         if ( fFakeOrphaneProduction &&
1482              percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && !outOut ) {
1483
1484           percentFilledCells+=kOneMoreFilledCell;
1485
1486           leadingSpurious = Int_t(2097152*gRandom->Rndm());
1487           word = leadingSpurious;
1488           Int_t dummyPS = 1;
1489
1490           if (fVerbose==2) {
1491             if (nDDL<10) ftxt << "  " << nDDL;
1492             else         ftxt << " " << nDDL;
1493             if (nTRM<10) ftxt << "  " << nTRM;
1494             else         ftxt << " " << nTRM;
1495             ftxt << "  " << iChain;
1496             if (nTDC<10) ftxt << "  " << nTDC;
1497             else         ftxt << " " << nTDC;
1498             ftxt << "  " << iCH;
1499             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1500             else              ftxt  << "  -> " << volume[0];
1501             ftxt << "  " << volume[1];
1502             if (volume[2]<10) ftxt << "  " << volume[2];
1503             else              ftxt << " " << volume[2];
1504             ftxt << "  " << volume[4];
1505             if (volume[3]<10) ftxt << "  " << volume[3];
1506             else              ftxt << " " << volume[3];
1507             ftxt << "   " << -1;
1508             if (word<10)                           ftxt << "        " << word;
1509             else if (word>=10     && word<100)     ftxt << "       " << word;
1510             else if (word>=100    && word<1000)    ftxt << "      " << word;
1511             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1512             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1513             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1514             else                                   ftxt << "  " << word;
1515             ftxt << "   " << dummyPS << endl;
1516           }
1517
1518           AliBitPacking::PackWord(word,baseWord, 0,20);
1519           word = iCH; // TDC channel ID [0;7]
1520           AliBitPacking::PackWord(word,baseWord,21,23);
1521           word = nTDC; // TDC ID [0;14]
1522           AliBitPacking::PackWord(word,baseWord,24,27);
1523           word = 0; // error flag
1524           AliBitPacking::PackWord(word,baseWord,28,28);
1525           word = dummyPS; // Packing Status [0;3]
1526           AliBitPacking::PackWord(word,baseWord,29,30);
1527           word = 1; // TRM TDC digit ID
1528           AliBitPacking::PackWord(word,baseWord,31,31);
1529
1530           localIndex++; fWordsPerTRM++;
1531           localBuffer[localIndex]=baseWord;
1532           psArray[localIndex]=dummyPS;
1533
1534           baseWord=0;
1535
1536         } // if ( fFakeOrphaneProduction && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && !outOut )
1537
1538
1539         } // if (!fPackedAcquisition)
1540
1541       } //end loop on digits in the same volume
1542
1543       //if (numberOfMeasuresPerChannel>maxMeasuresPerChannelInTDC)
1544       //maxMeasuresPerChannelInTDC = numberOfMeasuresPerChannel;
1545
1546     } // end loop on TDC channel number
1547
1548     //AliDebug(3,Form(" TDC number %2i:  numberOfMeasuresPerChannel = %2i  ---  maxMeasuresPerChannelInTDC = %2i ", nTDC, numberOfMeasuresPerChannel, maxMeasuresPerChannelInTDC));
1549
1550     if (localIndex==-1) continue;
1551
1552     if (fPackedAcquisition) {
1553
1554       for (jj=0; jj<=localIndex; jj++) {
1555         fIndex++;
1556         buf[fIndex] = localBuffer[jj];
1557         localBuffer[jj] = 0;
1558         psArray[jj] = -1;
1559       }
1560
1561     }
1562     else {
1563       /*
1564       if (maxMeasuresPerChannelInTDC = 1) {
1565
1566         for (Int_t jj=0; jj<=localIndex; jj++) {
1567           if (psArray[jj]==2) {
1568             fIndex++;
1569             buf[fIndex] = localBuffer[jj];
1570             localBuffer[jj] = 0;
1571             psArray[jj] = -1;
1572           }
1573         }
1574         for (Int_t jj=0; jj<=localIndex; jj++) {
1575           if (psArray[jj]==1) {
1576             fIndex++;
1577             buf[fIndex] = localBuffer[jj];
1578             localBuffer[jj] = 0;
1579             psArray[jj] = -1;
1580           }
1581         }
1582
1583       } // if (maxMeasuresPerChannelInTDC = 1)
1584       else if (maxMeasuresPerChannelInTDC>1) {
1585
1586         AliDebug(3,Form(" In the TOF DDL %2i, TRM %2i, TDC %2i, chain %1i, the maximum number of t.o.f. good measurements per channel is %2i",
1587                      nDDL, nTRM, iChain, nTDC, iCH, maxMeasuresPerChannelInTDC));
1588       */
1589       for (jj=0; jj<=localIndex; jj++) {
1590             fIndex++;
1591             buf[fIndex] = localBuffer[jj];
1592             localBuffer[jj] = 0;
1593             psArray[jj] = -1;
1594         }
1595
1596         //} // else if (maxMeasuresPerChannelInTDC>1)
1597
1598     } // else (!fPackedAcquisition)
1599
1600     localIndex = -1;
1601
1602     //maxMeasuresPerChannelInTDC = 0;
1603
1604   } // end loop on TDC number
1605
1606
1607   if (fVerbose==2) ftxt.close();
1608
1609 }
1610
1611 //----------------------------------------------------------------------------
1612 void AliTOFDDLRawData::ReverseArray(UInt_t a[], Int_t n) const
1613 {
1614   //
1615   // Reverses the n elements of array a
1616   //
1617
1618   Int_t ii, temp;
1619
1620   for (ii=0; ii<n/2; ii++) {
1621     temp      = a[ii];
1622     a[ii]     = a[n-ii-1];
1623     a[n-ii-1] = temp;
1624   }
1625
1626   return;
1627
1628 }
1629
1630 //----------------------------------------------------------------------------
1631 Bool_t AliTOFDDLRawData::HeadOrTail() const
1632 {
1633   //
1634   // Returns the result of a 'pitch and toss'
1635   //
1636
1637   Double_t dummy = gRandom->Rndm();
1638
1639   if (dummy<0.5) return kFALSE;
1640   else return kTRUE;
1641
1642 }