Line data Source code
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 26 : ClassImp(AliTOFDDLRawData)
99 :
100 : //---------------------------------------------------------------------------
101 : AliTOFDDLRawData::AliTOFDDLRawData():
102 13 : TObject(),
103 13 : fVerbose(0),
104 13 : fIndex(-1),
105 13 : fPackedAcquisition(kFALSE),
106 13 : fFakeOrphaneProduction(kFALSE),
107 13 : fMatchingWindow(8192),
108 39 : fTOFdigitMap(new AliTOFDigitMap()),
109 13 : fTOFdigitArray(0x0),
110 13 : fWordsPerDRM(0),
111 13 : fWordsPerTRM(0),
112 13 : fWordsPerChain(0)
113 65 : {
114 : //Default constructor
115 26 : }
116 : //----------------------------------------------------------------------------
117 : AliTOFDDLRawData::AliTOFDDLRawData(const AliTOFDDLRawData &source) :
118 0 : TObject(source),
119 0 : fVerbose(source.fVerbose),
120 0 : fIndex(source.fIndex),
121 0 : fPackedAcquisition(source.fPackedAcquisition),
122 0 : fFakeOrphaneProduction(source.fFakeOrphaneProduction),
123 0 : fMatchingWindow(source.fMatchingWindow),
124 0 : fTOFdigitMap(source.fTOFdigitMap),
125 0 : fTOFdigitArray(source.fTOFdigitArray),
126 0 : fWordsPerDRM(source.fWordsPerDRM),
127 0 : fWordsPerTRM(source.fWordsPerTRM),
128 0 : fWordsPerChain(source.fWordsPerChain)
129 0 : {
130 : //Copy Constructor
131 0 : return;
132 0 : }
133 :
134 : //----------------------------------------------------------------------------
135 : AliTOFDDLRawData& AliTOFDDLRawData::operator=(const AliTOFDDLRawData &source) {
136 : //Assigment operator
137 :
138 0 : if (this == &source)
139 0 : return *this;
140 :
141 0 : TObject::operator=(source);
142 0 : fIndex=source.fIndex;
143 0 : fVerbose=source.fVerbose;
144 0 : fPackedAcquisition=source.fPackedAcquisition;
145 0 : fFakeOrphaneProduction=source.fFakeOrphaneProduction;
146 0 : fMatchingWindow=source.fMatchingWindow;
147 0 : fTOFdigitMap=source.fTOFdigitMap;
148 0 : fTOFdigitArray=source.fTOFdigitArray;
149 0 : fWordsPerDRM=source.fWordsPerDRM;
150 0 : fWordsPerTRM=source.fWordsPerTRM;
151 0 : fWordsPerChain=source.fWordsPerChain;
152 0 : return *this;
153 0 : }
154 :
155 : //----------------------------------------------------------------------------
156 : AliTOFDDLRawData::~AliTOFDDLRawData()
157 52 : {
158 : // dtr
159 :
160 26 : delete fTOFdigitMap;
161 26 : }
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 8 : UInt_t buf[kSize];
172 :
173 : // To clear the digit indices map for each event
174 4 : fTOFdigitMap->Clear();
175 :
176 4 : fIndex = -1;
177 :
178 4 : fTOFdigitArray = * (TClonesArray**) branch->GetAddress();
179 :
180 : AliFstream* outfile; // logical name of the output file
181 :
182 4 : AliRawDataHeaderSim header;
183 :
184 : UInt_t sizeRawData = 0;
185 :
186 4 : branch->GetEvent();
187 :
188 4 : 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 584 : for (nDDL=0; nDDL<AliDAQ::NumberOfDdls("TOF"); nDDL++) {
200 :
201 288 : char fileName[256]="";
202 288 : strncpy(fileName,AliDAQ::DdlFileName("TOF",nDDL),255); //The name of the output file
203 :
204 288 : outfile = new AliFstream(fileName);
205 288 : iDDL = AliTOFRawStream::GetDDLnumberPerSector(nDDL);
206 :
207 : // write Dummy DATA HEADER
208 288 : UInt_t dataHeaderPosition = outfile->Tellp();
209 288 : outfile->WriteBuffer((char*)(&header),sizeof(header));
210 :
211 : // DRM section: trailer
212 288 : MakeDRMtrailer(buf);
213 :
214 : // loop on TRM number per DRM
215 6336 : for (nTRM=AliTOFGeometry::NTRM(); nTRM>=3; nTRM--) {
216 :
217 2880 : fWordsPerTRM = 0;
218 :
219 : // the slot number 3 of the even DRM (i.e. right) doesn't contain TDC digit data
220 2880 : if (iDDL%2==0 && nTRM==3) continue;
221 :
222 : // loop on TRM chain number per TRM
223 16416 : for (iChain=AliTOFGeometry::NChain()-1; iChain>=0; iChain--) {
224 :
225 : // TRM chain trailer
226 5472 : MakeTRMchainTrailer(iChain, buf); fWordsPerTRM++;
227 :
228 : // TRM TDC digits
229 5472 : MakeTDCdigits(nDDL, nTRM, iChain, buf);
230 :
231 : // TRM chain header
232 5472 : MakeTRMchainHeader(nTRM, iChain, buf); fWordsPerTRM++;
233 :
234 : } // end loop on iChain
235 :
236 : // TRM global header
237 2736 : MakeTRMheader(nTRM, buf); fWordsPerTRM++;
238 :
239 : // TRM filler in case where TRM data number is odd
240 2736 : if ((fWordsPerTRM+1)%2!=0) {
241 0 : MakeTRMfiller(buf); fWordsPerTRM++;
242 0 : }
243 :
244 2736 : MakeTRMtrailer(buf); fWordsPerDRM++;
245 :
246 2736 : fWordsPerDRM += fWordsPerTRM;
247 :
248 2736 : } // 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 288 : MakeLTMtrailer(buf); fWordsPerDRM++;
255 288 : MakeLTMdata(buf); fWordsPerDRM+=48;
256 288 : MakeLTMheader(buf); fWordsPerDRM++;
257 :
258 : // DRM section: in
259 288 : MakeDRMheader(nDDL, buf);
260 :
261 288 : ReverseArray(buf, fIndex+1);
262 :
263 288 : outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t)));
264 :
265 66640 : for (jj=0; jj<(fIndex+1); jj++) buf[jj]=0;
266 288 : fIndex = -1;
267 :
268 : //Write REAL DATA HEADER
269 288 : UInt_t currentFilePosition = outfile->Tellp();
270 288 : sizeRawData = currentFilePosition - dataHeaderPosition - sizeof(header);
271 288 : header.fSize = currentFilePosition - dataHeaderPosition;
272 288 : header.SetAttribute(0); // valid data
273 288 : outfile->Seekp(dataHeaderPosition);
274 288 : outfile->WriteBuffer((char*)(&header),sizeof(header));
275 288 : outfile->Seekp(currentFilePosition);
276 :
277 576 : delete outfile;
278 :
279 288 : } //end loop on DDL file number
280 :
281 4 : return 0;
282 :
283 4 : }
284 :
285 : //----------------------------------------------------------------------------
286 : void AliTOFDDLRawData::GetDigits()
287 : {
288 : //
289 : // Fill the TOF volumes' map with the TOF digit indices
290 : //
291 :
292 8 : Int_t vol[5] = {-1,-1,-1,-1,-1};
293 :
294 : Int_t digit = -1;
295 4 : Int_t ndigits = fTOFdigitArray->GetEntries();
296 12 : AliDebug(2, Form(" Number of read digits = %d",ndigits));
297 : AliTOFdigit *digs;
298 :
299 : // loop on TOF digits
300 208 : for (digit=0; digit<ndigits; digit++) {
301 100 : digs = (AliTOFdigit*)fTOFdigitArray->UncheckedAt(digit);
302 :
303 100 : vol[0] = digs->GetSector(); // Sector Number (0-17)
304 100 : vol[1] = digs->GetPlate(); // Plate Number (0-4)
305 100 : vol[2] = digs->GetStrip(); // Strip Number (0-14/18)
306 100 : vol[3] = digs->GetPadx(); // Pad Number in x direction (0-47)
307 100 : vol[4] = digs->GetPadz(); // Pad Number in z direction (0-1)
308 :
309 100 : fTOFdigitMap->AddDigit(vol, digit);
310 :
311 : } // close loop on digit del TOF
312 12 : AliDebug(2,Form(" Number of mapped digits = %d",fTOFdigitMap->GetFilledCellNumber()));
313 4 : }
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 576 : Int_t iDDL = AliTOFRawStream::GetDDLnumberPerSector(nDDL);
324 :
325 : //Int_t iSector = fTOFrawStream->GetSectorNumber(nDDL);
326 288 : Int_t iSector = AliTOFRawStream::GetSectorNumber(nDDL);
327 :
328 288 : UInt_t baseWord=0;
329 : UInt_t word;
330 :
331 : // DRM event CRC
332 288 : baseWord=0;
333 : word = 1; // 0001 -> DRM data are coming from the VME slot number 1
334 288 : AliBitPacking::PackWord(word,baseWord, 0, 3);
335 : word = 0; // event CRC --> CHANGED
336 288 : AliBitPacking::PackWord(word,baseWord, 4,19);
337 : word = 0; // reserved for future use
338 288 : AliBitPacking::PackWord(word,baseWord,20,27);
339 : word = 4; // 0100 -> DRM header ID
340 288 : AliBitPacking::PackWord(word,baseWord,28,31);
341 288 : fIndex++;
342 288 : buf[fIndex]=baseWord;
343 :
344 : // DRM status header 4
345 288 : baseWord=0;
346 : word = 1; // 0001 -> DRM data are coming from the VME slot number 1
347 288 : AliBitPacking::PackWord(word,baseWord, 0, 3);
348 : word = 0; // temperature
349 288 : AliBitPacking::PackWord(word,baseWord, 4,13);
350 : word = 0; // zero
351 288 : AliBitPacking::PackWord(word,baseWord, 14,14);
352 : word = 0; // ACK
353 288 : AliBitPacking::PackWord(word,baseWord, 15,15);
354 : word = 0; // Sens AD
355 288 : AliBitPacking::PackWord(word,baseWord, 16,18);
356 : word = 0; // zero
357 288 : AliBitPacking::PackWord(word,baseWord, 19,19);
358 : word = 0; // reserved for future use
359 288 : AliBitPacking::PackWord(word,baseWord, 20,27);
360 : word = 4; // 0100 -> DRM header ID
361 288 : AliBitPacking::PackWord(word,baseWord,28,31);
362 288 : fIndex++;
363 288 : buf[fIndex]=baseWord;
364 :
365 : // DRM status header 3
366 288 : baseWord=0;
367 : word = 1; // 0001 -> DRM data are coming from the VME slot number 1
368 288 : AliBitPacking::PackWord(word,baseWord, 0, 3);
369 : word = 0; // L0 BCID
370 288 : AliBitPacking::PackWord(word,baseWord, 4,15);
371 : word = 0; // Run Time info
372 288 : AliBitPacking::PackWord(word,baseWord, 16,27);
373 : word = 4; // 0100 -> DRM header ID
374 288 : AliBitPacking::PackWord(word,baseWord,28,31);
375 288 : fIndex++;
376 288 : buf[fIndex]=baseWord;
377 :
378 : // DRM status header 2
379 288 : baseWord=0;
380 : word = 1; // 0001 -> DRM data are coming from the VME slot number 1
381 288 : AliBitPacking::PackWord(word,baseWord, 0, 3);
382 :
383 288 : if (iDDL%2==1) {
384 : word = 2047; // enable ID: [00000000000;11111111111] for odd
385 : // (i.e. right) crates
386 144 : AliBitPacking::PackWord(word,baseWord, 4,14);
387 144 : } else {
388 : word = 2045; // enable ID: [00000000000;11111111101] for even
389 : // (i.e. left) crates
390 144 : AliBitPacking::PackWord(word,baseWord, 4,14);
391 : }
392 :
393 : word = 0; //
394 288 : AliBitPacking::PackWord(word,baseWord,15,15);
395 : word = 0; // fault ID
396 288 : AliBitPacking::PackWord(word,baseWord,16,26);
397 : word = 0; // RTO
398 288 : AliBitPacking::PackWord(word,baseWord,27,27);
399 : word = 4; // 0100 -> DRM header ID
400 288 : AliBitPacking::PackWord(word,baseWord,28,31);
401 288 : fIndex++;
402 288 : buf[fIndex]=baseWord;
403 :
404 : // DRM status header 1
405 288 : baseWord=0;
406 : word = 1; // 0001 -> DRM data are coming from the VME slot number 1
407 288 : AliBitPacking::PackWord(word,baseWord, 0, 3);
408 :
409 288 : if (iDDL%2==1) {
410 : word = 2047; // slot ID: [00000000000;11111111111] for odd
411 : // (i.e. right) crates
412 144 : AliBitPacking::PackWord(word,baseWord, 4,14);
413 144 : } else {
414 : word = 2045; // slot ID: [00000000000;11111111101] for even
415 : // (i.e. left) crates
416 144 : AliBitPacking::PackWord(word,baseWord, 4,14);
417 : }
418 :
419 : word = 1; // LHC clock status: 1/0
420 288 : AliBitPacking::PackWord(word,baseWord,15,15);
421 : word = 0; // Vers ID
422 288 : AliBitPacking::PackWord(word,baseWord,16,20);
423 : word = 0; // DRMH size
424 288 : AliBitPacking::PackWord(word,baseWord,21,24);
425 : word = 0; // reserved for future use
426 288 : AliBitPacking::PackWord(word,baseWord,25,27);
427 : word = 4; // 0100 -> DRM header ID
428 288 : AliBitPacking::PackWord(word,baseWord,28,31);
429 288 : fIndex++;
430 288 : buf[fIndex]=baseWord;
431 :
432 : // DRM global header
433 288 : baseWord=0;
434 : word = 1; // 0001 -> DRM data are coming from the VME slot number 1
435 288 : AliBitPacking::PackWord(word,baseWord, 0, 3);
436 288 : word = fIndex+1 + 1; // event words
437 288 : AliBitPacking::PackWord(word,baseWord, 4,20);
438 : word = iDDL; // crate ID [0;3]
439 288 : AliBitPacking::PackWord(word,baseWord,21,22);
440 : word = iSector; // sector ID [0;17]
441 288 : AliBitPacking::PackWord(word,baseWord,23,27);
442 : word = 4; // 0100 -> DRM header ID
443 288 : AliBitPacking::PackWord(word,baseWord,28,31);
444 288 : fIndex++;
445 288 : buf[fIndex]=baseWord;
446 :
447 288 : }
448 :
449 : //----------------------------------------------------------------------------
450 : void AliTOFDDLRawData::MakeDRMtrailer(UInt_t *buf)
451 : {
452 : //
453 : // DRM global trailer
454 : //
455 :
456 576 : UInt_t baseWord;
457 : UInt_t word;
458 :
459 288 : baseWord=0;
460 : word = 1; // 0001 -> DRM data are coming from the VME slot number 1
461 288 : AliBitPacking::PackWord(word,baseWord, 0, 3);
462 : word = 0; // local event counter --> TO BE CHANGED IN fWordsPerDRM+5
463 288 : AliBitPacking::PackWord(word,baseWord, 4,15);
464 : word = 0; // reserved for future use
465 288 : AliBitPacking::PackWord(word,baseWord,16,27);
466 : word = 5; // 0101 -> DRM trailer ID
467 288 : AliBitPacking::PackWord(word,baseWord,28,31);
468 288 : fIndex++;
469 288 : buf[fIndex]=baseWord;
470 :
471 288 : }
472 :
473 : //----------------------------------------------------------------------------
474 : void AliTOFDDLRawData::MakeLTMheader(UInt_t *buf)
475 : {
476 : //
477 : // LTM header
478 : //
479 :
480 576 : UInt_t baseWord;
481 : UInt_t word;
482 :
483 288 : baseWord=0;
484 : word = 2; // 0010 -> LTM data are coming from the VME slot number 2
485 288 : AliBitPacking::PackWord(word,baseWord, 0, 3);
486 : word = 35; // event words
487 288 : AliBitPacking::PackWord(word,baseWord, 4,16);
488 : word = 0; // crc error
489 288 : AliBitPacking::PackWord(word,baseWord,17,17);
490 : word = 0; // fault
491 288 : AliBitPacking::PackWord(word,baseWord,18,23);
492 : word = 0;
493 288 : AliBitPacking::PackWord(word,baseWord,24,27);
494 : word = 4; // 0100 -> LTM header ID
495 288 : AliBitPacking::PackWord(word,baseWord,28,31);
496 288 : fIndex++;
497 288 : buf[fIndex]=baseWord;
498 :
499 288 : }
500 :
501 : //----------------------------------------------------------------------------
502 : void AliTOFDDLRawData::MakeLTMdata(UInt_t *buf)
503 : {
504 : //
505 : // LTM data
506 : //
507 :
508 576 : UInt_t baseWord;
509 : UInt_t word;
510 :
511 288 : baseWord=0;
512 : word = 0;
513 288 : AliBitPacking::PackWord(word,baseWord,0,9);
514 : word = 0;
515 288 : AliBitPacking::PackWord(word,baseWord,10,19);
516 : word = 0;
517 288 : AliBitPacking::PackWord(word,baseWord,20,29);
518 : word = 0;
519 288 : AliBitPacking::PackWord(word,baseWord,30,30);
520 : word = 0;
521 288 : AliBitPacking::PackWord(word,baseWord,31,31);
522 :
523 :
524 : // OR45, OR46, OR47
525 288 : fIndex++;
526 288 : buf[fIndex]=baseWord;
527 :
528 : // OR42, OR43, OR44
529 288 : fIndex++;
530 288 : buf[fIndex]=baseWord;
531 :
532 : // OR39, OR40, OR41
533 288 : fIndex++;
534 288 : buf[fIndex]=baseWord;
535 :
536 : // OR36, OR37, OR38
537 288 : fIndex++;
538 288 : buf[fIndex]=baseWord;
539 :
540 : // OR33, OR34, OR35
541 288 : fIndex++;
542 288 : buf[fIndex]=baseWord;
543 :
544 : // OR30, OR31, OR32
545 288 : fIndex++;
546 288 : buf[fIndex]=baseWord;
547 :
548 : // OR27, OR28, OR29
549 288 : fIndex++;
550 288 : buf[fIndex]=baseWord;
551 :
552 : // OR24, OR25, OR26
553 288 : fIndex++;
554 288 : buf[fIndex]=baseWord;
555 :
556 : // OR21, OR22, OR23
557 288 : fIndex++;
558 288 : buf[fIndex]=baseWord;
559 :
560 : // OR18, OR19, OR20
561 288 : fIndex++;
562 288 : buf[fIndex]=baseWord;
563 :
564 : // OR15, OR16, OR17
565 288 : fIndex++;
566 288 : buf[fIndex]=baseWord;
567 :
568 : // OR12, OR12, OR24
569 288 : fIndex++;
570 288 : buf[fIndex]=baseWord;
571 :
572 : // OR9, OR10, OR11
573 288 : fIndex++;
574 288 : buf[fIndex]=baseWord;
575 :
576 : // OR6, OR7, OR8
577 288 : fIndex++;
578 288 : buf[fIndex]=baseWord;
579 :
580 : // OR3, OR4, OR5
581 288 : fIndex++;
582 288 : buf[fIndex]=baseWord;
583 :
584 : // OR0, OR1, OR2
585 288 : fIndex++;
586 288 : buf[fIndex]=baseWord;
587 :
588 :
589 :
590 288 : baseWord=0;
591 : word = 100; // Local temperature in LTM11 -> 4 X 25 degree (environment temperature)
592 288 : AliBitPacking::PackWord(word,baseWord, 0, 9);
593 : word = 100; // Local temperature in LTM10 -> 4 X 25 degree (environment temperature)
594 288 : AliBitPacking::PackWord(word,baseWord,10,19);
595 : word = 100; // Local temperature in LTM9 -> 4 X 25 degree (environment temperature)
596 288 : AliBitPacking::PackWord(word,baseWord,20,29);
597 : word = 0;
598 288 : AliBitPacking::PackWord(word,baseWord,30,30);
599 : word = 0;
600 288 : AliBitPacking::PackWord(word,baseWord,31,31);
601 :
602 288 : fIndex++;
603 288 : buf[fIndex]=baseWord;
604 :
605 : // Local temperature in LTM8, LMT7, LTM6 -> 4 X 25 degree (environment temperature)
606 288 : fIndex++;
607 288 : buf[fIndex]=baseWord;
608 :
609 : // Local temperature in LTM5, LMT4, LTM3 -> 4 X 25 degree (environment temperature)
610 288 : fIndex++;
611 288 : buf[fIndex]=baseWord;
612 :
613 : // Local temperature in LTM2, LMT1, LTM0 -> 4 X 25 degree (environment temperature)
614 288 : fIndex++;
615 288 : buf[fIndex]=baseWord;
616 :
617 :
618 :
619 : // Local temperature in T7, T6, T5 -> 4 X 25 degree (environment temperature)
620 288 : fIndex++;
621 288 : buf[fIndex]=baseWord;
622 :
623 : // Local temperature in T4, T3, T2 -> 4 X 25 degree (environment temperature)
624 288 : fIndex++;
625 288 : 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 288 : fIndex++;
630 288 : buf[fIndex]=baseWord;
631 :
632 288 : baseWord=0;
633 : word = 0; // VTH13 -> Thereshould voltage for FEAC16
634 288 : AliBitPacking::PackWord(word,baseWord, 0, 9);
635 : word = 0; // VTH14 -> Thereshould voltage for FEAC14
636 288 : AliBitPacking::PackWord(word,baseWord,10,19);
637 : word = 0; // GND-FEAC7 -> Voltage drop between GND and FEAC7
638 288 : AliBitPacking::PackWord(word,baseWord,20,29);
639 : word = 0;
640 288 : AliBitPacking::PackWord(word,baseWord,30,30);
641 : word = 0;
642 288 : AliBitPacking::PackWord(word,baseWord,31,31);
643 :
644 288 : fIndex++;
645 288 : 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 288 : fIndex++;
651 288 : 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 288 : fIndex++;
657 288 : 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 288 : fIndex++;
663 288 : 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 288 : fIndex++;
669 288 : 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 288 : fIndex++;
675 288 : 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 288 : fIndex++;
681 288 : buf[fIndex]=baseWord;
682 :
683 : // LV15
684 : // VTH0 -> Thereshould voltage for FEAC12
685 : // GND-FEAC0 -> Voltage drop between GND and FEAC6
686 288 : fIndex++;
687 288 : buf[fIndex]=baseWord;
688 :
689 : // LV15
690 : // VTH0 -> Thereshould voltage for FEAC12
691 : // GND-FEAC0 -> Voltage drop between GND and FEAC6
692 288 : fIndex++;
693 288 : buf[fIndex]=baseWord;
694 :
695 : // LV12
696 : // LV13
697 : // LV14
698 288 : fIndex++;
699 288 : buf[fIndex]=baseWord;
700 :
701 : // LV9
702 : // LV10
703 : // LV11
704 288 : fIndex++;
705 288 : buf[fIndex]=baseWord;
706 :
707 : // LV6
708 : // LV7
709 : // LV8
710 288 : fIndex++;
711 288 : buf[fIndex]=baseWord;
712 :
713 : // LV3
714 : // LV4
715 : // LV5
716 288 : fIndex++;
717 288 : buf[fIndex]=baseWord;
718 :
719 : // LV0
720 : // LV1
721 : // LV2
722 288 : fIndex++;
723 288 : buf[fIndex]=baseWord;
724 :
725 :
726 :
727 288 : baseWord=0;
728 : word = 0; // PDL45 -> Delay Line setting for PDL41
729 288 : AliBitPacking::PackWord(word,baseWord, 0, 7);
730 : word = 0; // PDL46 -> Delay Line setting for PDL42
731 288 : AliBitPacking::PackWord(word,baseWord, 8,15);
732 : word = 0; // PDL47 -> Delay Line setting for PDL43
733 288 : AliBitPacking::PackWord(word,baseWord,16,23);
734 : word = 0; // PDL48 -> Delay Line setting for PDL44
735 288 : AliBitPacking::PackWord(word,baseWord,24,31);
736 288 : fIndex++;
737 288 : buf[fIndex]=baseWord;
738 :
739 : // Delay Line setting for PDL37, PDL38, PDL39, PDL40
740 288 : fIndex++;
741 288 : buf[fIndex]=baseWord;
742 :
743 : // Delay Line setting for PDL33, PDL34, PDL35, PDL36
744 288 : fIndex++;
745 288 : buf[fIndex]=baseWord;
746 :
747 : // Delay Line setting for PDL29, PDL30, PDL31, PDL32
748 288 : fIndex++;
749 288 : buf[fIndex]=baseWord;
750 :
751 : // Delay Line setting for PDL25, PDL26, PDL27, PDL28
752 288 : fIndex++;
753 288 : buf[fIndex]=baseWord;
754 :
755 : // Delay Line setting for PDL21, PDL22, PDL23, PDL24
756 288 : fIndex++;
757 288 : buf[fIndex]=baseWord;
758 :
759 : // Delay Line setting for PDL17, PDL18, PDL19, PDL20
760 288 : fIndex++;
761 288 : buf[fIndex]=baseWord;
762 :
763 : // Delay Line setting for PDL13, PDL14, PDL15, PDL16
764 288 : fIndex++;
765 288 : buf[fIndex]=baseWord;
766 :
767 : // Delay Line setting for PDL9, PDL10, PDL11, PDL12
768 288 : fIndex++;
769 288 : buf[fIndex]=baseWord;
770 :
771 : // Delay Line setting for PDL5, PDL6, PDL7, PDL8
772 288 : fIndex++;
773 288 : buf[fIndex]=baseWord;
774 :
775 : // Delay Line setting for PDL1, PDL2, PDL3, PDL4
776 288 : fIndex++;
777 288 : buf[fIndex]=baseWord;
778 :
779 288 : }
780 :
781 : //----------------------------------------------------------------------------
782 : void AliTOFDDLRawData::MakeLTMtrailer(UInt_t *buf)
783 : {
784 : //
785 : // LTM trailer
786 : //
787 :
788 576 : UInt_t baseWord;
789 : UInt_t word;
790 :
791 288 : baseWord=0;
792 : word = 2; // 0010 -> LTM data are coming from the VME slot number 2
793 288 : AliBitPacking::PackWord(word,baseWord, 0, 3);
794 : word = 0; // event crc
795 288 : AliBitPacking::PackWord(word,baseWord, 4,15);
796 : word = 0; // event number
797 288 : AliBitPacking::PackWord(word,baseWord,16,27);
798 : word = 5; // 0101 -> LTM trailer ID
799 288 : AliBitPacking::PackWord(word,baseWord,28,31);
800 288 : fIndex++;
801 288 : buf[fIndex]=baseWord;
802 :
803 288 : }
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 5472 : if (nTRM<3 || nTRM>12) {
813 0 : AliWarning(Form(" TRM number is out of the right range [3;12] (nTRM = %3i",nTRM));
814 0 : return;
815 : }
816 :
817 2736 : UInt_t baseWord;
818 : UInt_t word;
819 :
820 2736 : baseWord = 0;
821 : word = nTRM; // TRM data coming from the VME slot number nTRM
822 2736 : AliBitPacking::PackWord(word,baseWord, 0, 3);
823 : word = 0; // event words
824 2736 : AliBitPacking::PackWord(word,baseWord, 4,16);
825 :
826 2736 : if (fPackedAcquisition)
827 0 : word = 0; // ACQuisition mode: [0;3] see document
828 : else
829 : word = 3; // ACQuisition mode: [0;3] see document
830 2736 : 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 2736 : AliBitPacking::PackWord(word,baseWord,19,19);
834 : word = 0; // Must Be Zero (MBZ)
835 2736 : AliBitPacking::PackWord(word,baseWord,20,27);
836 : word = 4; // 0100 -> TRM header ID
837 2736 : AliBitPacking::PackWord(word,baseWord,28,31);
838 2736 : fIndex++;
839 2736 : buf[fIndex]=baseWord;
840 :
841 5472 : }
842 :
843 : //----------------------------------------------------------------------------
844 : void AliTOFDDLRawData::MakeTRMtrailer(UInt_t *buf)
845 : {
846 : //
847 : // Set TRM Global Trailer
848 : // with the calculated CRC
849 : //
850 :
851 5472 : UInt_t baseWord;
852 : UInt_t word;
853 :
854 2736 : baseWord=0;
855 : word = 15; // 1111 -> TRM trailer ID 1
856 2736 : AliBitPacking::PackWord(word,baseWord, 0, 3);
857 :
858 : UInt_t trmCRC=0x0;
859 27760 : for (Int_t ii=fIndex-(fWordsPerTRM-1); ii<fIndex; ii++)
860 11144 : trmCRC ^= buf[ii];
861 : //PH printf(" A trmCRC=%d\n",trmCRC);
862 :
863 : word = 0x0;
864 2736 : word ^= ( (trmCRC & 0x00000fff) >> 0);
865 2736 : word ^= ( (trmCRC & 0x00fff000) >> 12);
866 2736 : word ^= ( (trmCRC & 0xff000000) >> 24);
867 :
868 : //PH printf(" B trmCRC=%d\n",word);
869 :
870 2736 : AliBitPacking::PackWord(word,baseWord, 4,15); // event CRC --> CHANGED
871 :
872 : word = 0; // local event counter == DRM local event counter --> TO BE CHANGED
873 2736 : AliBitPacking::PackWord(word,baseWord,16,27);
874 : word = 5; // 0101 -> TRM trailer ID 2
875 2736 : AliBitPacking::PackWord(word,baseWord,28,31);
876 :
877 2736 : fIndex++;
878 33232 : for (Int_t ii=fIndex; ii>fIndex-fWordsPerTRM; ii--)
879 13880 : buf[ii]=buf[ii-1];
880 :
881 2736 : buf[fIndex-fWordsPerTRM] = baseWord;
882 :
883 2736 : }
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 10944 : UInt_t baseWord;
894 : UInt_t word;
895 :
896 5472 : if (nTRM<3 || nTRM>12) {
897 0 : AliWarning(Form(" TRM number is out of the right range [3;12] (nTRM = %3i", nTRM));
898 0 : return;
899 : }
900 :
901 5472 : if (iChain<0 || iChain>1) {
902 0 : AliWarning(Form(" Chain number is out of the right range [0;1] (iChain = %3i", iChain));
903 0 : return;
904 : }
905 :
906 10944 : baseWord=0;
907 : word = nTRM; // TRM data coming from the VME slot ID nTRM
908 10944 : AliBitPacking::PackWord(word,baseWord, 0, 3);
909 : word = 0; // bunch ID
910 10944 : AliBitPacking::PackWord(word,baseWord, 4,15);
911 : word = 0;//100; // PB24 temperature -> 4 X 25 degree (environment temperature)
912 10944 : AliBitPacking::PackWord(word,baseWord,16,23);
913 : word = 0;//(Int_t)(5 * gRandom->Rndm()); // PB24 ID [0;4]
914 10944 : AliBitPacking::PackWord(word,baseWord,24,26);
915 : word = 0; // TS
916 10944 : AliBitPacking::PackWord(word,baseWord,27,27);
917 10944 : switch (iChain) {
918 : case 0:
919 : word = 0; // 0000 -> TRM chain 0 ID
920 2736 : break;
921 : case 1:
922 : word = 2; // 0010 -> TRM chain 1 ID
923 2736 : break;
924 : }
925 5472 : AliBitPacking::PackWord(word,baseWord,28,31);
926 5472 : fIndex++;
927 5472 : buf[fIndex]=baseWord;
928 :
929 10944 : }
930 :
931 : //----------------------------------------------------------------------------
932 : void AliTOFDDLRawData::MakeTRMfiller(UInt_t *buf)
933 : {
934 : //
935 : // TRM filler
936 : //
937 :
938 : Int_t jj = -1;
939 :
940 0 : fIndex++;
941 0 : for (jj=fIndex; jj>fIndex-fWordsPerTRM; jj--)
942 0 : buf[jj] = buf[jj-1];
943 :
944 0 : buf[fIndex-fWordsPerTRM] = MakeFiller();
945 :
946 0 : }
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 0 : UInt_t baseWord;
956 : UInt_t word;
957 :
958 0 : baseWord=0;
959 : word = 0; // 0000 -> filler ID 1
960 0 : AliBitPacking::PackWord(word,baseWord, 0, 3);
961 : word = 0; // MBZ
962 0 : AliBitPacking::PackWord(word,baseWord, 4,27);
963 : word = 7; // 0111 -> filler ID 2
964 0 : AliBitPacking::PackWord(word,baseWord, 28,31);
965 :
966 0 : return baseWord;
967 :
968 0 : }
969 :
970 : //----------------------------------------------------------------------------
971 : void AliTOFDDLRawData::MakeTRMchainTrailer(Int_t iChain, UInt_t *buf)
972 : {
973 : //
974 : // TRM chain trailer
975 : //
976 :
977 10944 : if (iChain<0 || iChain>1) {
978 0 : AliWarning(Form(" Chain number is out of the right range [0;1] (iChain = %3i", iChain));
979 0 : return;
980 : }
981 :
982 10944 : UInt_t baseWord;
983 : UInt_t word;
984 :
985 10944 : baseWord=0;
986 : word = 0; // status
987 10944 : AliBitPacking::PackWord(word,baseWord, 0, 3);
988 : word = 0; // MBZ
989 10944 : AliBitPacking::PackWord(word,baseWord, 4,15);
990 : word = 0; // event counter --> TO BE CHANGED
991 10944 : AliBitPacking::PackWord(word,baseWord,16,27);
992 10944 : switch (iChain) {
993 : case 0:
994 : word = 1; // 0001 -> TRM chain 0 trailer ID
995 2736 : break;
996 : case 1:
997 : word = 3; // 0011 -> TRM chain 1 trailer ID
998 2736 : break;
999 : }
1000 5472 : AliBitPacking::PackWord(word,baseWord,28,31);
1001 5472 : fIndex++;
1002 5472 : buf[fIndex]=baseWord;
1003 :
1004 10944 : }
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 10944 : const Double_t kOneMoreFilledCell = 1./(AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors());
1014 5472 : Double_t percentFilledCells = Double_t(fTOFdigitMap->GetFilledCellNumber())/(AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors());
1015 :
1016 5472 : if (nDDL<0 || nDDL>71) {
1017 0 : AliWarning(Form(" DDL number is out of the right range [0;71] (nDDL = %3i", nDDL));
1018 0 : return;
1019 : }
1020 :
1021 5472 : if (nTRM<3 || nTRM>12) {
1022 0 : AliWarning(Form(" TRM number is out of the right range [3;12] (nTRM = %3i", nTRM));
1023 0 : return;
1024 : }
1025 :
1026 5472 : if (iChain<0 || iChain>1) {
1027 0 : AliWarning(Form(" Chain number is out of the right range [0;1] (iChain = %3i", iChain));
1028 0 : return;
1029 : }
1030 :
1031 5472 : Int_t psArray[1000];
1032 5472 : UInt_t localBuffer[1000];
1033 : Int_t localIndex = -1;
1034 :
1035 5472 : Int_t iDDL = nDDL%AliTOFGeometry::NDDL();
1036 :
1037 5472 : Int_t volume[5] = {-1, -1, -1, -1, -1};
1038 5472 : 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 5472 : 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 5472 : Bool_t outOut = HeadOrTail();
1059 :
1060 5472 : ofstream ftxt;
1061 :
1062 5472 : if (fVerbose==2) ftxt.open("TOFdigits.txt",ios::app);
1063 :
1064 65664 : for (jj=0; jj<5; jj++) volume[jj] = -1;
1065 :
1066 : // loop on TDC number
1067 175104 : 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 86400 : if (iDDL%2==1 && nTRM==3 && (Int_t)(nTDC/3)!=0) continue;
1072 :
1073 : // loop on TDC channel number
1074 1415232 : for (iCH=AliTOFGeometry::NCh()-1; iCH>=0; iCH--) {
1075 :
1076 : //numberOfMeasuresPerChannel = 0;
1077 :
1078 7547904 : for (Int_t aa=0; aa<5; aa++) volume[aa]=-1;
1079 628992 : AliTOFRawStream::EquipmentId2VolumeId(nDDL, nTRM, iChain, nTDC, iCH, volume);
1080 :
1081 3144960 : AliDebug(3,Form(" volume -> %2d %1d %2d %2d %1d",volume[0],volume[1],volume[2],volume[3],volume[4]));
1082 :
1083 2515968 : if (volume[0]==-1 || volume[1]==-1 || volume[2]==-1 ||
1084 1257984 : volume[3]==-1 || volume[4]==-1) continue;
1085 :
1086 3144960 : AliDebug(3,Form(" ====== %2d %1d %2d %2d %1d",volume[0],volume[1],volume[2],volume[3],volume[4]));
1087 :
1088 5031936 : for (jj=0; jj<3; jj++) indexDigit[jj] = -1;
1089 :
1090 628992 : fTOFdigitMap->GetDigitIndex(volume, indexDigit);
1091 :
1092 628992 : if (indexDigit[0]<0) {
1093 :
1094 1257784 : trailingSpurious = Int_t(2097152*gRandom->Rndm());
1095 1257784 : leadingSpurious = Int_t(2097152*gRandom->Rndm());
1096 :
1097 628892 : if ( fFakeOrphaneProduction &&
1098 0 : ( ( fPackedAcquisition && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) ||
1099 0 : (!fPackedAcquisition && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) ) ) ) {
1100 :
1101 0 : percentFilledCells+=kOneMoreFilledCell;
1102 :
1103 : Int_t dummyPS = 0;
1104 :
1105 0 : if (outOut) {
1106 : word = trailingSpurious; // trailing edge measurement
1107 : dummyPS = 2;
1108 0 : }
1109 : else {
1110 : word = leadingSpurious; // leading edge measurement
1111 : dummyPS = 1;
1112 : }
1113 :
1114 0 : if (fVerbose==2) {
1115 0 : if (nDDL<10) ftxt << " " << nDDL;
1116 0 : else ftxt << " " << nDDL;
1117 0 : if (nTRM<10) ftxt << " " << nTRM;
1118 0 : else ftxt << " " << nTRM;
1119 0 : ftxt << " " << iChain;
1120 0 : if (nTDC<10) ftxt << " " << nTDC;
1121 0 : else ftxt << " " << nTDC;
1122 0 : ftxt << " " << iCH;
1123 0 : if (volume[0]<10) ftxt << " -> " << volume[0];
1124 0 : else ftxt << " -> " << volume[0];
1125 0 : ftxt << " " << volume[1];
1126 0 : if (volume[2]<10) ftxt << " " << volume[2];
1127 0 : else ftxt << " " << volume[2];
1128 0 : ftxt << " " << volume[4];
1129 0 : if (volume[3]<10) ftxt << " " << volume[3];
1130 0 : else ftxt << " " << volume[3];
1131 0 : ftxt << " " << -1;
1132 0 : if (word<10) ftxt << " " << word;
1133 0 : else if (word>=10 && word<100) ftxt << " " << word;
1134 0 : else if (word>=100 && word<1000) ftxt << " " << word;
1135 0 : else if (word>=1000 && word<10000) ftxt << " " << word;
1136 0 : else if (word>=10000 && word<100000) ftxt << " " << word;
1137 0 : else if (word>=100000 && word<1000000) ftxt << " " << word;
1138 0 : else ftxt << " " << word;
1139 0 : ftxt << " " << dummyPS << endl;
1140 : }
1141 :
1142 0 : AliBitPacking::PackWord(word,baseWord, 0,20);
1143 : word = iCH; // TDC channel ID [0;7]
1144 0 : AliBitPacking::PackWord(word,baseWord,21,23);
1145 : word = nTDC; // TDC ID [0;14]
1146 0 : AliBitPacking::PackWord(word,baseWord,24,27);
1147 : word = 0; // error flag
1148 0 : AliBitPacking::PackWord(word,baseWord,28,28);
1149 : word = dummyPS; // Packing Status [0;3]
1150 0 : AliBitPacking::PackWord(word,baseWord,29,30);
1151 : word = 1; // TRM TDC digit ID
1152 0 : AliBitPacking::PackWord(word,baseWord,31,31);
1153 :
1154 0 : localIndex++; fWordsPerTRM++;
1155 0 : localBuffer[localIndex]=baseWord;
1156 0 : psArray[localIndex]=dummyPS;
1157 :
1158 0 : baseWord=0;
1159 :
1160 0 : } // if ( fFakeOrphaneProduction && ( ( fPackedAcquisition && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) or ... ) )
1161 : } // if (indexDigit[0]<0)
1162 :
1163 5031936 : for (jj=0; jj<3;jj++) {
1164 :
1165 1886976 : if (indexDigit[jj]<0) continue;
1166 :
1167 500 : 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 100 : digs = (AliTOFdigit*)fTOFdigitArray->UncheckedAt(indexDigit[jj]);
1170 :
1171 200 : if (digs->GetSector()!=volume[0] ||
1172 100 : digs->GetPlate() !=volume[1] ||
1173 100 : digs->GetStrip() !=volume[2] ||
1174 100 : digs->GetPadx() !=volume[3] ||
1175 100 : 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 100 : 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 200 : if (digs->GetTdcND()>=fMatchingWindow) {
1190 100 : AliDebug(2,"Out of matching window.");
1191 : continue; // adc
1192 : }
1193 500 : 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 100 : totCharge = (Int_t)(digs->GetToT());
1199 : // temporary control
1200 100 : if (totCharge<0) totCharge = 0;//TMath::Abs(totCharge);
1201 :
1202 100 : if (fPackedAcquisition) {
1203 :
1204 0 : if (fVerbose==2) {
1205 0 : if (nDDL<10) ftxt << " " << nDDL;
1206 0 : else ftxt << " " << nDDL;
1207 0 : if (nTRM<10) ftxt << " " << nTRM;
1208 0 : else ftxt << " " << nTRM;
1209 0 : ftxt << " " << iChain;
1210 0 : if (nTDC<10) ftxt << " " << nTDC;
1211 0 : else ftxt << " " << nTDC;
1212 0 : ftxt << " " << iCH;
1213 0 : if (volume[0]<10) ftxt << " -> " << volume[0];
1214 0 : else ftxt << " -> " << volume[0];
1215 0 : ftxt << " " << volume[1];
1216 0 : if (volume[2]<10) ftxt << " " << volume[2];
1217 0 : else ftxt << " " << volume[2];
1218 0 : ftxt << " " << volume[4];
1219 0 : if (volume[3]<10) ftxt << " " << volume[3];
1220 0 : else ftxt << " " << volume[3];
1221 0 : if (totCharge<10) ftxt << " " << totCharge;
1222 0 : else if (totCharge>=10 && totCharge<100) ftxt << " " << totCharge;
1223 0 : else ftxt << " " << totCharge;
1224 0 : if (timeOfFlight<10) ftxt << " " << timeOfFlight << endl;
1225 0 : else if (timeOfFlight>=10 && timeOfFlight<100) ftxt << " " << timeOfFlight << endl;
1226 0 : else if (timeOfFlight>=100 && timeOfFlight<1000) ftxt << " " << timeOfFlight << endl;
1227 0 : else ftxt << " " << timeOfFlight << endl;
1228 : }
1229 :
1230 0 : word = timeOfFlight%8192; // time-of-fligth measurement
1231 0 : AliBitPacking::PackWord(word,baseWord, 0,12);
1232 :
1233 0 : if (totCharge>=256) totCharge = 255;
1234 : word = totCharge; // time-over-threshould measurement
1235 0 : AliBitPacking::PackWord(word,baseWord,13,20);
1236 :
1237 : word = iCH; // TDC channel ID [0;7]
1238 0 : AliBitPacking::PackWord(word,baseWord,21,23);
1239 : word = nTDC; // TDC ID [0;14]
1240 0 : AliBitPacking::PackWord(word,baseWord,24,27);
1241 : word = 0; // error flag
1242 0 : AliBitPacking::PackWord(word,baseWord,28,28);
1243 : word = 0; // Packing Status [0;3]
1244 0 : AliBitPacking::PackWord(word,baseWord,29,30);
1245 : word = 1; // TRM TDC digit ID
1246 0 : AliBitPacking::PackWord(word,baseWord,31,31);
1247 :
1248 0 : localIndex++; fWordsPerTRM++;
1249 0 : localBuffer[localIndex]=baseWord;
1250 :
1251 0 : baseWord=0;
1252 :
1253 0 : if ( fFakeOrphaneProduction &&
1254 0 : percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) {
1255 :
1256 0 : percentFilledCells+=kOneMoreFilledCell;
1257 :
1258 0 : trailingSpurious = Int_t(2097152*gRandom->Rndm());
1259 0 : leadingSpurious = Int_t(2097152*gRandom->Rndm());
1260 :
1261 : Int_t dummyPS = 0;
1262 :
1263 0 : if (outOut) {
1264 : word = trailingSpurious; // trailing edge measurement
1265 : dummyPS = 2;
1266 0 : }
1267 : else {
1268 : word = leadingSpurious; // leading edge measurement
1269 : dummyPS = 1;
1270 : }
1271 :
1272 0 : if (fVerbose==2) {
1273 0 : if (nDDL<10) ftxt << " " << nDDL;
1274 0 : else ftxt << " " << nDDL;
1275 0 : if (nTRM<10) ftxt << " " << nTRM;
1276 0 : else ftxt << " " << nTRM;
1277 0 : ftxt << " " << iChain;
1278 0 : if (nTDC<10) ftxt << " " << nTDC;
1279 0 : else ftxt << " " << nTDC;
1280 0 : ftxt << " " << iCH;
1281 0 : if (volume[0]<10) ftxt << " -> " << volume[0];
1282 0 : else ftxt << " -> " << volume[0];
1283 0 : ftxt << " " << volume[1];
1284 0 : if (volume[2]<10) ftxt << " " << volume[2];
1285 0 : else ftxt << " " << volume[2];
1286 0 : ftxt << " " << volume[4];
1287 0 : if (volume[3]<10) ftxt << " " << volume[3];
1288 0 : else ftxt << " " << volume[3];
1289 0 : ftxt << " " << -1;
1290 0 : if (word<10) ftxt << " " << word;
1291 0 : else if (word>=10 && word<100) ftxt << " " << word;
1292 0 : else if (word>=100 && word<1000) ftxt << " " << word;
1293 0 : else if (word>=1000 && word<10000) ftxt << " " << word;
1294 0 : else if (word>=10000 && word<100000) ftxt << " " << word;
1295 0 : else if (word>=100000 && word<1000000) ftxt << " " << word;
1296 0 : else ftxt << " " << word;
1297 0 : ftxt << " " << dummyPS << endl;
1298 : }
1299 :
1300 0 : AliBitPacking::PackWord(word,baseWord, 0,20);
1301 : word = iCH; // TDC channel ID [0;7]
1302 0 : AliBitPacking::PackWord(word,baseWord,21,23);
1303 : word = nTDC; // TDC ID [0;14]
1304 0 : AliBitPacking::PackWord(word,baseWord,24,27);
1305 : word = 0; // error flag
1306 0 : AliBitPacking::PackWord(word,baseWord,28,28);
1307 : word = dummyPS; // Packing Status [0;3]
1308 0 : AliBitPacking::PackWord(word,baseWord,29,30);
1309 : word = 1; // TRM TDC digit ID
1310 0 : AliBitPacking::PackWord(word,baseWord,31,31);
1311 :
1312 0 : localIndex++; fWordsPerTRM++;
1313 0 : localBuffer[localIndex]=baseWord;
1314 0 : psArray[localIndex]=dummyPS;
1315 :
1316 0 : baseWord=0;
1317 :
1318 0 : } // if ( fFakeOrphaneProduction && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) )
1319 :
1320 :
1321 : } // if (fPackedAcquisition)
1322 : else { // if (!fPackedAcquisition)
1323 :
1324 200 : if ( fFakeOrphaneProduction &&
1325 100 : percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && outOut ) {
1326 :
1327 0 : percentFilledCells+=kOneMoreFilledCell;
1328 :
1329 0 : trailingSpurious = Int_t(2097152*gRandom->Rndm());
1330 : word = trailingSpurious;
1331 : Int_t dummyPS = 2;
1332 :
1333 0 : if (fVerbose==2) {
1334 0 : if (nDDL<10) ftxt << " " << nDDL;
1335 0 : else ftxt << " " << nDDL;
1336 0 : if (nTRM<10) ftxt << " " << nTRM;
1337 0 : else ftxt << " " << nTRM;
1338 0 : ftxt << " " << iChain;
1339 0 : if (nTDC<10) ftxt << " " << nTDC;
1340 0 : else ftxt << " " << nTDC;
1341 0 : ftxt << " " << iCH;
1342 0 : if (volume[0]<10) ftxt << " -> " << volume[0];
1343 0 : else ftxt << " -> " << volume[0];
1344 0 : ftxt << " " << volume[1];
1345 0 : if (volume[2]<10) ftxt << " " << volume[2];
1346 0 : else ftxt << " " << volume[2];
1347 0 : ftxt << " " << volume[4];
1348 0 : if (volume[3]<10) ftxt << " " << volume[3];
1349 0 : else ftxt << " " << volume[3];
1350 0 : ftxt << " " << -1;
1351 0 : if (word<10) ftxt << " " << word;
1352 0 : else if (word>=10 && word<100) ftxt << " " << word;
1353 0 : else if (word>=100 && word<1000) ftxt << " " << word;
1354 0 : else if (word>=1000 && word<10000) ftxt << " " << word;
1355 0 : else if (word>=10000 && word<100000) ftxt << " " << word;
1356 0 : else if (word>=100000 && word<1000000) ftxt << " " << word;
1357 0 : else ftxt << " " << word;
1358 0 : ftxt << " " << dummyPS << endl;
1359 : }
1360 :
1361 0 : AliBitPacking::PackWord(word,baseWord, 0,20);
1362 : word = iCH; // TDC channel ID [0;7]
1363 0 : AliBitPacking::PackWord(word,baseWord,21,23);
1364 : word = nTDC; // TDC ID [0;14]
1365 0 : AliBitPacking::PackWord(word,baseWord,24,27);
1366 : word = 0; // error flag
1367 0 : AliBitPacking::PackWord(word,baseWord,28,28);
1368 : word = dummyPS; // Packing Status [0;3]
1369 0 : AliBitPacking::PackWord(word,baseWord,29,30);
1370 : word = 1; // TRM TDC digit ID
1371 0 : AliBitPacking::PackWord(word,baseWord,31,31);
1372 :
1373 0 : localIndex++; fWordsPerTRM++;
1374 0 : localBuffer[localIndex]=baseWord;
1375 0 : psArray[localIndex]=dummyPS;
1376 :
1377 0 : baseWord=0;
1378 :
1379 0 : } // if ( fFakeOrphaneProduction && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && outOut )
1380 :
1381 :
1382 100 : word = (timeOfFlight + Int_t(totCharge*AliTOFGeometry::ToTBinWidth()/AliTOFGeometry::TdcBinWidth()))%2097152; // trailing edge measurement
1383 :
1384 100 : if (fVerbose==2) {
1385 0 : if (nDDL<10) ftxt << " " << nDDL;
1386 0 : else ftxt << " " << nDDL;
1387 0 : if (nTRM<10) ftxt << " " << nTRM;
1388 0 : else ftxt << " " << nTRM;
1389 0 : ftxt << " " << iChain;
1390 0 : if (nTDC<10) ftxt << " " << nTDC;
1391 0 : else ftxt << " " << nTDC;
1392 0 : ftxt << " " << iCH;
1393 0 : if (volume[0]<10) ftxt << " -> " << volume[0];
1394 0 : else ftxt << " -> " << volume[0];
1395 0 : ftxt << " " << volume[1];
1396 0 : if (volume[2]<10) ftxt << " " << volume[2];
1397 0 : else ftxt << " " << volume[2];
1398 0 : ftxt << " " << volume[4];
1399 0 : if (volume[3]<10) ftxt << " " << volume[3];
1400 0 : else ftxt << " " << volume[3];
1401 0 : ftxt << " " << -1;
1402 0 : if (word<10) ftxt << " " << word;
1403 0 : else if (word>=10 && word<100) ftxt << " " << word;
1404 0 : else if (word>=100 && word<1000) ftxt << " " << word;
1405 0 : else if (word>=1000 && word<10000) ftxt << " " << word;
1406 0 : else if (word>=10000 && word<100000) ftxt << " " << word;
1407 0 : else if (word>=100000 && word<1000000) ftxt << " " << word;
1408 0 : else ftxt << " " << word;
1409 0 : ftxt << " " << 2 << endl;
1410 : }
1411 :
1412 100 : AliBitPacking::PackWord(word,baseWord, 0,20);
1413 :
1414 : word = iCH; // TDC channel ID [0;7]
1415 100 : AliBitPacking::PackWord(word,baseWord,21,23);
1416 : word = nTDC; // TDC ID [0;14]
1417 100 : AliBitPacking::PackWord(word,baseWord,24,27);
1418 : word = 0; // error flag
1419 100 : AliBitPacking::PackWord(word,baseWord,28,28);
1420 : word = 2; // Packing Status [0;3]
1421 100 : AliBitPacking::PackWord(word,baseWord,29,30);
1422 : word = 1; // TRM TDC digit ID
1423 100 : AliBitPacking::PackWord(word,baseWord,31,31);
1424 :
1425 100 : localIndex++; fWordsPerTRM++;
1426 100 : localBuffer[localIndex]=baseWord;
1427 100 : psArray[localIndex]=2;
1428 :
1429 100 : baseWord=0;
1430 :
1431 100 : word = timeOfFlight%2097152; // leading edge measurement
1432 :
1433 100 : if (fVerbose==2) {
1434 0 : if (nDDL<10) ftxt << " " << nDDL;
1435 0 : else ftxt << " " << nDDL;
1436 0 : if (nTRM<10) ftxt << " " << nTRM;
1437 0 : else ftxt << " " << nTRM;
1438 0 : ftxt << " " << iChain;
1439 0 : if (nTDC<10) ftxt << " " << nTDC;
1440 0 : else ftxt << " " << nTDC;
1441 0 : ftxt << " " << iCH;
1442 0 : if (volume[0]<10) ftxt << " -> " << volume[0];
1443 0 : else ftxt << " -> " << volume[0];
1444 0 : ftxt << " " << volume[1];
1445 0 : if (volume[2]<10) ftxt << " " << volume[2];
1446 0 : else ftxt << " " << volume[2];
1447 0 : ftxt << " " << volume[4];
1448 0 : if (volume[3]<10) ftxt << " " << volume[3];
1449 0 : else ftxt << " " << volume[3];
1450 0 : ftxt << " " << -1;
1451 0 : if (word<10) ftxt << " " << word;
1452 0 : else if (word>=10 && word<100) ftxt << " " << word;
1453 0 : else if (word>=100 && word<1000) ftxt << " " << word;
1454 0 : else if (word>=1000 && word<10000) ftxt << " " << word;
1455 0 : else if (word>=10000 && word<100000) ftxt << " " << word;
1456 0 : else if (word>=100000 && word<1000000) ftxt << " " << word;
1457 0 : else ftxt << " " << word;
1458 0 : ftxt << " " << 1 << endl;
1459 : }
1460 :
1461 100 : AliBitPacking::PackWord(word,baseWord, 0,20);
1462 :
1463 : word = iCH; // TDC channel ID [0;7]
1464 100 : AliBitPacking::PackWord(word,baseWord,21,23);
1465 : word = nTDC; // TDC ID [0;14]
1466 100 : AliBitPacking::PackWord(word,baseWord,24,27);
1467 : word = 0; // error flag
1468 100 : AliBitPacking::PackWord(word,baseWord,28,28);
1469 : word = 1; // Packing Status [0;3]
1470 100 : AliBitPacking::PackWord(word,baseWord,29,30);
1471 : word = 1; // TRM TDC digit ID
1472 100 : AliBitPacking::PackWord(word,baseWord,31,31);
1473 :
1474 100 : localIndex++; fWordsPerTRM++;
1475 100 : localBuffer[localIndex]=baseWord;
1476 100 : psArray[localIndex]=1;
1477 :
1478 100 : baseWord=0;
1479 :
1480 :
1481 200 : if ( fFakeOrphaneProduction &&
1482 100 : percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && !outOut ) {
1483 :
1484 0 : percentFilledCells+=kOneMoreFilledCell;
1485 :
1486 0 : leadingSpurious = Int_t(2097152*gRandom->Rndm());
1487 : word = leadingSpurious;
1488 : Int_t dummyPS = 1;
1489 :
1490 0 : if (fVerbose==2) {
1491 0 : if (nDDL<10) ftxt << " " << nDDL;
1492 0 : else ftxt << " " << nDDL;
1493 0 : if (nTRM<10) ftxt << " " << nTRM;
1494 0 : else ftxt << " " << nTRM;
1495 0 : ftxt << " " << iChain;
1496 0 : if (nTDC<10) ftxt << " " << nTDC;
1497 0 : else ftxt << " " << nTDC;
1498 0 : ftxt << " " << iCH;
1499 0 : if (volume[0]<10) ftxt << " -> " << volume[0];
1500 0 : else ftxt << " -> " << volume[0];
1501 0 : ftxt << " " << volume[1];
1502 0 : if (volume[2]<10) ftxt << " " << volume[2];
1503 0 : else ftxt << " " << volume[2];
1504 0 : ftxt << " " << volume[4];
1505 0 : if (volume[3]<10) ftxt << " " << volume[3];
1506 0 : else ftxt << " " << volume[3];
1507 0 : ftxt << " " << -1;
1508 0 : if (word<10) ftxt << " " << word;
1509 0 : else if (word>=10 && word<100) ftxt << " " << word;
1510 0 : else if (word>=100 && word<1000) ftxt << " " << word;
1511 0 : else if (word>=1000 && word<10000) ftxt << " " << word;
1512 0 : else if (word>=10000 && word<100000) ftxt << " " << word;
1513 0 : else if (word>=100000 && word<1000000) ftxt << " " << word;
1514 0 : else ftxt << " " << word;
1515 0 : ftxt << " " << dummyPS << endl;
1516 : }
1517 :
1518 0 : AliBitPacking::PackWord(word,baseWord, 0,20);
1519 : word = iCH; // TDC channel ID [0;7]
1520 0 : AliBitPacking::PackWord(word,baseWord,21,23);
1521 : word = nTDC; // TDC ID [0;14]
1522 0 : AliBitPacking::PackWord(word,baseWord,24,27);
1523 : word = 0; // error flag
1524 0 : AliBitPacking::PackWord(word,baseWord,28,28);
1525 : word = dummyPS; // Packing Status [0;3]
1526 0 : AliBitPacking::PackWord(word,baseWord,29,30);
1527 : word = 1; // TRM TDC digit ID
1528 0 : AliBitPacking::PackWord(word,baseWord,31,31);
1529 :
1530 0 : localIndex++; fWordsPerTRM++;
1531 0 : localBuffer[localIndex]=baseWord;
1532 0 : psArray[localIndex]=dummyPS;
1533 :
1534 0 : baseWord=0;
1535 :
1536 0 : } // 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 78624 : if (localIndex==-1) continue;
1551 :
1552 69 : if (fPackedAcquisition) {
1553 :
1554 0 : for (jj=0; jj<=localIndex; jj++) {
1555 0 : fIndex++;
1556 0 : buf[fIndex] = localBuffer[jj];
1557 0 : localBuffer[jj] = 0;
1558 0 : 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 469 : for (jj=0; jj<=localIndex; jj++) {
1590 200 : fIndex++;
1591 200 : buf[fIndex] = localBuffer[jj];
1592 200 : localBuffer[jj] = 0;
1593 200 : psArray[jj] = -1;
1594 : }
1595 :
1596 : //} // else if (maxMeasuresPerChannelInTDC>1)
1597 :
1598 : } // else (!fPackedAcquisition)
1599 :
1600 : localIndex = -1;
1601 :
1602 : //maxMeasuresPerChannelInTDC = 0;
1603 :
1604 69 : } // end loop on TDC number
1605 :
1606 :
1607 5472 : if (fVerbose==2) ftxt.close();
1608 :
1609 10944 : }
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 33608 : for (ii=0; ii<n/2; ii++) {
1621 16372 : temp = a[ii];
1622 16372 : a[ii] = a[n-ii-1];
1623 16372 : a[n-ii-1] = temp;
1624 : }
1625 :
1626 : return;
1627 :
1628 288 : }
1629 :
1630 : //----------------------------------------------------------------------------
1631 : Bool_t AliTOFDDLRawData::HeadOrTail() const
1632 : {
1633 : //
1634 : // Returns the result of a 'pitch and toss'
1635 : //
1636 :
1637 10944 : Double_t dummy = gRandom->Rndm();
1638 :
1639 8193 : if (dummy<0.5) return kFALSE;
1640 2751 : else return kTRUE;
1641 :
1642 5472 : }
|
