]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TOF/AliTOFDecoderV2.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Changed number of LTM words. Minor change
[u/mrichter/AliRoot.git] / TOF / AliTOFDecoderV2.cxx
CommitLineData
5b4ed716 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14***************************************************************************/
15
16/*
17$Log: AliTOFDecoder.cxx,v $
18Revision 1.4 2007/05/18 13:08:57 decaro
19Coding convention: RS1 violation -> suppression
20
21Revision 1.3 2007/05/08 11:56:05 arcelli
22improved verbosity in verbose mode (R.Preghenella)
23
24Revision 1.2 2007/05/03 11:34:43 decaro
25Coding convention: RS1 violation -> suppression
26
27Revision 1.1 2007/04/27 11:00:32 arcelli
28TOF Raw Data decoder
29
30 author: Roberto Preghenella (R+), preghenella@bo.infn.it
31*/
32
33
34//////////////////////////////////////////////////////////////////////
35// //
36// //
37// Class for raw data decoding //
38// //
39// //
40//////////////////////////////////////////////////////////////////////
41
42
43#include "AliLog.h"
44#include "AliTOFDecoderV2.h"
45#include "AliTOFTDCHit.h"
46
47ClassImp(AliTOFDecoderV2)
48
49//_________________________________________________________________
50
51AliTOFDecoderV2::AliTOFDecoderV2(AliRawReader *reader) :
52 TObject(),
53 fRawReader(reader),
54 fVerbose(kFALSE),
55 fLogErrors(kTRUE),
56 fV2718Patch(kFALSE),
57 fRecoverError(kTRUE),
58 fRecoverErrorThr(0),
59 fSpider(kTRUE),
60 fRunNumber(0),
61 fEventNumber(0),
62 fEquipmentID(0),
63 fDecoderSummaryData(0x0),
64 fDRMSummaryData(0x0),
65 fLTMSummaryData(0x0),
66 fTRMSummaryData(0x0),
67 fChainSummaryData(0x0),
68 fTDCHitBuffer(0x0),
69 fTDCPackedHitBuffer(0x0),
70 fTDCErrorBuffer(0x0),
71 fDRMGlobalHeader(0x0),
72 fDRMGlobalTrailer(0x0),
73 fDRMStatusHeader1(0x0),
74 fDRMStatusHeader2(0x0),
75 fDRMStatusHeader3(0x0),
76 fDRMStatusHeader4(0x0),
77 fDRMEventCRC(0x0),
78 fLTMGlobalHeader(0x0),
79 fLTMGlobalTrailer(0x0),
80 fLTMPDLData(0x0),
81 fLTMADCData(0x0),
82 fLTMORData(0x0),
83 fTRMGlobalHeader(0x0),
84 fTRMGlobalTrailer(0x0),
85 fTRMChainHeader(0x0),
86 fTRMChainTrailer(0x0),
87 fTDCPackedHit(0x0),
88 fTDCUnpackedHit(0x0),
89 fTRMTDCError(0x0),
90 fTRMDiagnosticErrorWord1(0x0),
91 fTRMDiagnosticErrorWord2(0x0),
92 fSpiderTDCID(-1),
93 fSpiderTDCPackedHitBuffer(0x0)
94{
95 //default constructor
96 if (fRawReader)
97 fRawReader->Select("TOF", 0, 71);
98
99 fDecoderSummaryData = new AliTOFDecoderSummaryData();
100
101 for (Int_t iChan = 0; iChan < N_CHANNEL; iChan++)
102 fSpiderBufferFull[iChan] = kFALSE;
103}
104
105//_________________________________________________________________
106
107AliTOFDecoderV2::AliTOFDecoderV2(const AliTOFDecoderV2 &source) :
108 TObject(),
109 fRawReader(source.fRawReader),
110 fVerbose(source.fVerbose),
111 fLogErrors(source.fLogErrors),
112 fV2718Patch(source.fV2718Patch),
113 fRecoverError(source.fRecoverError),
114 fRecoverErrorThr(source.fRecoverErrorThr),
115 fSpider(source.fSpider),
116 fRunNumber(source.fRunNumber),
117 fEventNumber(source.fEventNumber),
118 fEquipmentID(source.fEquipmentID),
119 fDecoderSummaryData(0x0),
120 fDRMSummaryData(0x0),
121 fLTMSummaryData(0x0),
122 fTRMSummaryData(0x0),
123 fChainSummaryData(0x0),
124 fTDCHitBuffer(0x0),
125 fTDCPackedHitBuffer(0x0),
126 fTDCErrorBuffer(0x0),
127 fDRMGlobalHeader(0x0),
128 fDRMGlobalTrailer(0x0),
129 fDRMStatusHeader1(0x0),
130 fDRMStatusHeader2(0x0),
131 fDRMStatusHeader3(0x0),
132 fDRMStatusHeader4(0x0),
133 fDRMEventCRC(0x0),
134 fLTMGlobalHeader(0x0),
135 fLTMGlobalTrailer(0x0),
136 fLTMPDLData(0x0),
137 fLTMADCData(0x0),
138 fLTMORData(0x0),
139 fTRMGlobalHeader(0x0),
140 fTRMGlobalTrailer(0x0),
141 fTRMChainHeader(0x0),
142 fTRMChainTrailer(0x0),
143 fTDCPackedHit(0x0),
144 fTDCUnpackedHit(0x0),
145 fTRMTDCError(0x0),
146 fTRMDiagnosticErrorWord1(0x0),
147 fTRMDiagnosticErrorWord2(0x0),
148 fSpiderTDCID(-1),
149 fSpiderTDCPackedHitBuffer(0x0)
150{
151 //copy constructor
152 fDecoderSummaryData = new AliTOFDecoderSummaryData(*source.fDecoderSummaryData);
153
154 for (Int_t iChan = 0; iChan < N_CHANNEL; iChan++)
155 fSpiderBufferFull[iChan] = kFALSE;
156}
157
158//_________________________________________________________________
159
160AliTOFDecoderV2 &
161AliTOFDecoderV2::operator = (const AliTOFDecoderV2 &source)
162{
163 //operator =
164 fRawReader = source.fRawReader;
165 fVerbose = source.fVerbose;
166 fLogErrors = source.fLogErrors;
167 fV2718Patch = source.fV2718Patch;
168 fRecoverError = source.fRecoverError;
169 fRecoverErrorThr = source.fRecoverErrorThr;
170 fSpider = source.fSpider;
171 fRunNumber = source.fRunNumber;
172 fEventNumber = source.fEventNumber;
173 fEquipmentID = source.fEquipmentID;
174 *fDecoderSummaryData = *source.fDecoderSummaryData;
175 return *this;
176}
177
178AliTOFDecoderV2::~AliTOFDecoderV2()
179{
180 delete fDecoderSummaryData;
181}
182
183//_________________________________________________________________
184
185Bool_t
186AliTOFDecoderV2::Decode(UInt_t *rawData, UInt_t nWords)
187{
188 /* main decoding routine.
189 * it loops over nWords 32-bit words
190 * starting at *rawData and decodes them.
191 * it also fills some buffers in order to
192 * have the decoded data available for other
193 * classes.
194 */
195
196 //reset decoder summary data
197 fDecoderSummaryData->Reset();
198
199 //fill decoder summary data
200 fDecoderSummaryData->SetRunNumber(fRunNumber);
201 fDecoderSummaryData->SetEventNumber(fEventNumber);
202 fDecoderSummaryData->SetEquipmentID(fEquipmentID);
203 fDecoderSummaryData->SetInputWords(nWords);
204 fDecoderSummaryData->SetRecoverError(fRecoverError);
205 fDecoderSummaryData->SetSpider(fSpider);
206
207 AliTOFTDCHit hit;
208 AliTOFTDCError error;
209
210 //decoder status
211 UShort_t decoderStatus = 0x0;
212
213 //CRC variables
214 UInt_t DRMCRC = 0x0;
215 UInt_t LTMCRC = 0x0;
216 UInt_t TRMCRC = 0x0;
217
218 // error warning counter
219 Int_t errorWarning = 0;
220
221 if (fRecoverError && fVerbose)
222 AliInfo("Recover error option enabled: potentially dangerous!");
223
224 /*** V2718 patch ***/
225 if (fV2718Patch){
226 decoderStatus = decoderStatus | DRM_BIT;
227 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
228 fDecoderSummaryData->SetCurrentDRMID(0x0);
229 fDecoderSummaryData->SetV2718Patch(kTRUE);
230 fDRMSummaryData = fDecoderSummaryData->GetDRMSummaryData();
231 fDRMSummaryData->SetHeader(kTRUE);
232 fDRMSummaryData->SetDRMID(0x0);
233 if (fVerbose)
234 AliInfo("DRM not present: - V2718 patch decoding -");
235 }
236 /*** V2718 patch ***/
237
238 if (fVerbose)
239 AliInfo("Start decoding");
240
241 if (fVerbose)
242 AliInfo("Loop over the data and decode");
243
244 if (fVerbose)
245 AliInfo(" St Hex Word \t Decoded Word");
246
247 //loop over raw data
248 for (UInt_t iWord = 0;
249 iWord < nWords;
250 iWord++, rawData++, fDecoderSummaryData->SetDecodedWords(iWord)){
251
252 //try to recover error
253 if (fDecoderSummaryData->GetRecoveringError() && fVerbose)
254 AliInfo(Form(" %02x - 0x%08x",decoderStatus,*rawData));
255
256 //compute CRC with current data
257 DRMCRC ^= *rawData;
258 LTMCRC ^= *rawData;
259 TRMCRC ^= *rawData;
260
261 //switch word type
262 switch (*rawData & WORD_TYPE_MASK){
263
264 case GLOBAL_HEADER:
265
266 //switch slot ID
267 switch (*rawData & SLOT_ID_MASK){
268
269 //DRM global header (slotID=1)
270 case 1:
271 //try to recover error
272 if (fDecoderSummaryData->GetRecoveringError())
273 continue;
274 //check decode status
275 if ( decoderStatus != DRM_HEADER_STATUS ){
276 if (fLogErrors)
277 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected DRM global header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
278 fDecoderSummaryData->SetErrorDetected(kTRUE);
279 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
280 errorWarning++;
281 //try to recover error
282 if (fRecoverError){
283 if (errorWarning > fRecoverErrorThr) {
284 if (fVerbose)
285 AliInfo("Trying to recover the error: searching for the next header");
286 fDecoderSummaryData->SetRecoveringError(kTRUE);
287 continue;
288 }
289 else {
290 if (fVerbose)
291 AliInfo("Do not try to recover error yet, go on with decoding process");
292 continue;
293 }
294 }
295 return(fDecoderSummaryData->GetErrorDetected());
296 }
297 //decode status ok
298 errorWarning = 0;
299 //set DRM global header
300 fDRMGlobalHeader = (AliTOFDRMGlobalHeader *)rawData;
301 //reset DRM CRC
302 DRMCRC = 0x0;
303 //fill decoder summary data
304 fDecoderSummaryData->SetCurrentDRMID(fDRMGlobalHeader->GetDRMID());
305 fDecoderSummaryData->SetCurrentSlotID(fDRMGlobalHeader->GetSlotID());
306 //get DRM summary data
307 fDRMSummaryData = fDecoderSummaryData->GetDRMSummaryData();
308 //reset DRM summary data
309 fDRMSummaryData->Reset();
310 //fill DRM summary data
311 FillDRMSummaryData(fDRMGlobalHeader);
312 //print verbose
313 if (fVerbose)
314 AliInfo(Form(" %02x - 0x%08x \t DRM global header",decoderStatus,*rawData));
315 //change decode status
316 decoderStatus = decoderStatus | DRM_BIT;
317 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
318 //decode DRM status headers
319 for (Int_t i = 0; i < DRM_STATUS_HEADER_WORDS; i++){
320 iWord++;
321 rawData++;
322 DRMCRC ^= *rawData;
323
324 switch (i){
325 case 0: //DRM status header 1
326 fDRMStatusHeader1 = (AliTOFDRMStatusHeader1 *)rawData;
327 FillDRMSummaryData(fDRMStatusHeader1);
328 if (fVerbose)
329 AliInfo(Form(" %02x - 0x%08x \t DRM status header 1",decoderStatus,*rawData));
330 break;
331 case 1: //DRM status header 2
332 fDRMStatusHeader2 = (AliTOFDRMStatusHeader2 *)rawData;
333 FillDRMSummaryData(fDRMStatusHeader2);
334 if (fVerbose)
335 AliInfo(Form(" %02x - 0x%08x \t DRM status header 2",decoderStatus,*rawData));
336 break;
337 case 2: //DRM status header 3
338 fDRMStatusHeader3 = (AliTOFDRMStatusHeader3 *)rawData;
339 FillDRMSummaryData(fDRMStatusHeader3);
340 if (fVerbose)
341 AliInfo(Form(" %02x - 0x%08x \t DRM status header 3",decoderStatus,*rawData));
342 break;
343 case 3: //DRM status header 4
344 fDRMStatusHeader4 = (AliTOFDRMStatusHeader4 *)rawData;
345 FillDRMSummaryData(fDRMStatusHeader4);
346 if (fVerbose)
347 AliInfo(Form(" %02x - 0x%08x \t DRM status header 4",decoderStatus,*rawData));
348 break;
349 }
350 }
351 //decode DRM event CRC
352 iWord++;
353 rawData++;
354 DRMCRC ^= *rawData;
355 //remove DRM event CRC from DRM CRC
356 DRMCRC ^= *rawData;
357 fDRMEventCRC = (AliTOFDRMEventCRC *)rawData;
358 FillDRMSummaryData(fDRMEventCRC);
359 if (fVerbose)
360 AliInfo(Form(" %02x - 0x%08x \t DRM event CRC",decoderStatus,*rawData));
361 break;
362
363 //LTM global header (slotID=2)
364 case 2:
365 //recover error
366 if (fDecoderSummaryData->GetRecoveringError()){
367 //change decode status
368 decoderStatus = LTM_HEADER_STATUS;
369 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
370 fDecoderSummaryData->SetRecoveringError(kFALSE);
371 if (fVerbose)
372 AliInfo("LTM global header found: error probably recovered");
373 }
374 //check decode status
375 if ( decoderStatus != LTM_HEADER_STATUS ){
376 if (fLogErrors)
377 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected LTM global header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
378 fDecoderSummaryData->SetErrorDetected(kTRUE);
379 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
380 errorWarning++;
381 //try to recover error
382 if (fRecoverError){
383 if (errorWarning > fRecoverErrorThr) {
384 if (fVerbose)
385 AliInfo("Trying to recover the error: searching for the next header");
386 fDecoderSummaryData->SetRecoveringError(kTRUE);
387 continue;
388 }
389 else {
390 if (fVerbose)
391 AliInfo("Do not try to recover error yet, go on with decoding process");
392 continue;
393 }
394 }
395 return(fDecoderSummaryData->GetErrorDetected());
396 }
397 //decode status ok
398 errorWarning = 0;
399 //set LTM global header
400 fLTMGlobalHeader = (AliTOFLTMGlobalHeader *)rawData;
401 //reset LTM CRC
402 LTMCRC = 0x0;
403 //fill decoder summary data
404 fDecoderSummaryData->SetCurrentSlotID(fLTMGlobalHeader->GetSlotID());
405 //get LTM summary data
406 fLTMSummaryData = fDRMSummaryData->GetLTMSummaryData();
407 //reset LTM summary data
408 fLTMSummaryData->Reset();
409 //fill LTM summary data
410 FillLTMSummaryData(fLTMGlobalHeader);
411 //set DRM slot enable mask bit
412 fDRMSummaryData->SetDecoderSlotEnableMaskBit(fLTMGlobalHeader->GetSlotID() - 2);
413 //print verbose
414 if (fVerbose)
415 AliInfo(Form(" %02x - 0x%08x \t LTM global header",decoderStatus,*rawData));
416 //change decode status
417 decoderStatus = decoderStatus | LTM_BIT;
418 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
419
420 //decode LTM PDL data
421 for (Int_t iPDLWord = 0; iPDLWord < LTM_PDL_DATA_WORDS; iPDLWord++){
422 iWord++;
423 rawData++;
424 DRMCRC ^= *rawData;
425 LTMCRC ^= *rawData;
426 //set LTM PDL data
427 fLTMPDLData = (AliTOFLTMPDLData *)rawData;
428 //fill LTM summary data
429 FillLTMSummaryData(fLTMPDLData, iPDLWord);
430 //print verbose
431 if (fVerbose)
432 AliInfo(Form(" %02x - 0x%08x \t LTM PDL data \t\t PDL1=%03d PDL2=%03d PDL3=%03d PDL4=%03d",decoderStatus,*rawData,fLTMPDLData->GetPDLValue1(),fLTMPDLData->GetPDLValue2(),fLTMPDLData->GetPDLValue3(),fLTMPDLData->GetPDLValue4()));
433 }
434 //decode LTM ADC data
435 for (Int_t iADCWord = 0; iADCWord < LTM_ADC_DATA_WORDS; iADCWord++){
436 iWord++;
437 rawData++;
438 DRMCRC ^= *rawData;
439 LTMCRC ^= *rawData;
440 //set LTM ADC data
441 fLTMADCData = (AliTOFLTMADCData *)rawData;
442 //fill LTM summary data
443 FillLTMSummaryData(fLTMADCData, iADCWord);
444 //print verbose
445 if (fVerbose)
446 AliInfo(Form(" %02x - 0x%08x \t LTM ADC data \t\t ADC1=%04d ADC2=%04d ADC3=%04d",decoderStatus,*rawData,fLTMADCData->GetADCValue1(),fLTMADCData->GetADCValue2(),fLTMADCData->GetADCValue3()));
447 }
448 //decode LTM OR data
449 for (Int_t iORWord = 0; iORWord < LTM_OR_DATA_WORDS; iORWord++){
450 iWord++;
451 rawData++;
452 DRMCRC ^= *rawData;
453 LTMCRC ^= *rawData;
454 //set LTM OR data
455 fLTMORData = (AliTOFLTMORData *)rawData;
456 //fill LTM summary data
457 FillLTMSummaryData(fLTMORData, iORWord);
458 //print verbose
459 if (fVerbose)
460 AliInfo(Form(" %02x - 0x%08x \t LTM OR data \t\t ADC1=%04d ADC2=%04d ADC3=%04d",decoderStatus,*rawData,fLTMORData->GetORValue1(),fLTMORData->GetORValue2(),fLTMORData->GetORValue3()));
461 }
462 break;
463
464 //TRM global header (slotID=3-12)
465 case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
466 //recover error
467 if (fDecoderSummaryData->GetRecoveringError()){
468 //change decode status
469 decoderStatus = TRM_HEADER_STATUS;
470 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
471 fDecoderSummaryData->SetRecoveringError(kFALSE);
472 if (fVerbose)
473 AliInfo("TRM global header found: error probably recovered");
474 }
475 //check decode status
476 if ( decoderStatus != TRM_HEADER_STATUS ){
477 if (fLogErrors)
478 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected TRM global header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
479 fDecoderSummaryData->SetErrorDetected(kTRUE);
480 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
481 errorWarning++;
482 //try to recover error
483 if (fRecoverError){
484 if (errorWarning > fRecoverErrorThr) {
485 if (fVerbose)
486 AliInfo("Trying to recover the error: searching for the next header");
487 fDecoderSummaryData->SetRecoveringError(kTRUE);
488 continue;
489 }
490 else {
491 if (fVerbose)
492 AliInfo("Do not try to recover error yet, go on with decoding process");
493 continue;
494 }
495 }
496 return(fDecoderSummaryData->GetErrorDetected());
497 }
498 //decode status ok
499 errorWarning = 0;
500 //set TRM global header
501 fTRMGlobalHeader = (AliTOFTRMGlobalHeader *)rawData;
502 //reset TRM CRC
503 TRMCRC = 0x0;
504 //fill decoder summary data
505 fDecoderSummaryData->SetCurrentSlotID(fTRMGlobalHeader->GetSlotID());
506 //get TRM summary data
507 fTRMSummaryData = fDRMSummaryData->GetTRMSummaryData(fTRMGlobalHeader->GetSlotID() - TRM_FIRST_SLOT_ID);
508 //reset TRM summary data
509 fTRMSummaryData->Reset();
510 //fill TRM summary data
511 FillTRMSummaryData(fTRMGlobalHeader);
512 //set DRM slot enable mask bit
513 fDRMSummaryData->SetDecoderSlotEnableMaskBit(fTRMGlobalHeader->GetSlotID() - 2);
514 //print verbose
515 if (fVerbose)
516 AliInfo(Form(" %02x - 0x%08x \t TRM global header \t slotID=%02d ACQ=%01d L=%01d",decoderStatus,*rawData,fTRMGlobalHeader->GetSlotID(),fTRMGlobalHeader->GetACQBits(),fTRMGlobalHeader->GetLBit()));
517 //change decode status
518 decoderStatus = decoderStatus | TRM_BIT;
519 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
520 break;
521
522 default:
523 if (fLogErrors)
524 AliError(Form(" %02x - 0x%08x [ERROR] Not valid slotID in global header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
525 fDecoderSummaryData->SetErrorDetected(kTRUE);
526 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
527 //try to recover error
528 if (fRecoverError){
529 if (errorWarning > fRecoverErrorThr) {
530 if (fVerbose)
531 AliInfo("Trying to recover the error: searching for the next header");
532 fDecoderSummaryData->SetRecoveringError(kTRUE);
533 continue;
534 }
535 else {
536 if (fVerbose)
537 AliInfo("Do not try to recover error yet, go on with decoding process");
538 continue;
539 }
540 }
541 return(fDecoderSummaryData->GetErrorDetected());
542 break;
543
544 }
545 //end switch slotID
546 break;
547
548 case GLOBAL_TRAILER:
549
550 //switch slot ID
551 switch (*rawData & SLOT_ID_MASK){
552
553 //DRM global trailer (slotID=1)
554 case 1:
555 //recover error
556 if (fDecoderSummaryData->GetRecoveringError()){
557 //change decode status
558 decoderStatus = DRM_TRAILER_STATUS;
559 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
560 fDecoderSummaryData->SetRecoveringError(kFALSE);
561 if (fVerbose)
562 AliInfo("DRM global trailer found: error probably recovered");
563 }
564 //check decode status
565 if ( decoderStatus != DRM_TRAILER_STATUS ){
566 if (fLogErrors)
567 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected DRM global trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
568 fDecoderSummaryData->SetErrorDetected(kTRUE);
569 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
570 errorWarning++;
571 //try to recover error
572 if (fRecoverError){
573 if (errorWarning > fRecoverErrorThr) {
574 if (fVerbose)
575 AliInfo("Trying to recover the error: searching for the next header");
576 fDecoderSummaryData->SetRecoveringError(kTRUE);
577 continue;
578 }
579 else {
580 if (fVerbose)
581 AliInfo("Do not try to recover error yet, go on with decoding process");
582 continue;
583 }
584 }
585 return(fDecoderSummaryData->GetErrorDetected());
586 }
587 //decode status ok
588 errorWarning = 0;
589 //set DRM global trailer
590 fDRMGlobalTrailer = (AliTOFDRMGlobalTrailer *)rawData;
591 //remove global trailer from DRM CRC
592 DRMCRC ^= *rawData;
593 //fill DRM summary data
594 FillDRMSummaryData(fDRMGlobalTrailer);
595 fDRMSummaryData->SetDecoderCRC(COMPUTE_DRM_CRC(DRMCRC));
596 //print verbose
597 if (fVerbose)
598 AliInfo(Form(" %02x - 0x%08x \t DRM global trailer",decoderStatus,*rawData));
599 //change decode status
600 decoderStatus = decoderStatus & ~DRM_BIT;
601 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
602 break;
603
604 //LTM global trailer (slotID=2)
605 case 2:
606 //try to recover error
607 if (fDecoderSummaryData->GetRecoveringError())
608 continue;
609 //check decode status
610 if ( decoderStatus != LTM_TRAILER_STATUS ){
611 if (fLogErrors)
612 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected LTM global trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
613 fDecoderSummaryData->SetErrorDetected(kTRUE);
614 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
615 errorWarning++;
616 //try to recover error
617 if (fRecoverError){
618 if (errorWarning > fRecoverErrorThr) {
619 if (fVerbose)
620 AliInfo("Trying to recover the error: searching for the next header");
621 fDecoderSummaryData->SetRecoveringError(kTRUE);
622 continue;
623 }
624 else {
625 if (fVerbose)
626 AliInfo("Do not try to recover error yet, go on with decoding process");
627 continue;
628 }
629 }
630 return(fDecoderSummaryData->GetErrorDetected());
631 }
632 //decode status ok
633 errorWarning = 0;
634 //set LTM global trailer
635 fLTMGlobalTrailer = (AliTOFLTMGlobalTrailer *)rawData;
636 //remove global trailer from LTM CRC
637 LTMCRC ^= *rawData;
638 //fill LTM summary data
639 FillLTMSummaryData(fLTMGlobalTrailer);
640 fLTMSummaryData->SetDecoderCRC(COMPUTE_LTM_CRC(LTMCRC));
641 //print verbose
642 if (fVerbose)
643 AliInfo(Form(" %02x - 0x%08x \t LTM global trailer",decoderStatus,*rawData));
644 //change decode status
645 decoderStatus = decoderStatus & ~LTM_BIT;
646 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
647 break;
648
649 //TRM global trailer (slotID=15)
650 case 15:
651 //try to recover error
652 if (fDecoderSummaryData->GetRecoveringError())
653 continue;
654 //check decode status
655 if ( decoderStatus != TRM_TRAILER_STATUS ){
656 if (fLogErrors)
657 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected TRM global trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
658 fDecoderSummaryData->SetErrorDetected(kTRUE);
659 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
660 errorWarning++;
661 //try to recover error
662 if (fRecoverError){
663 if (errorWarning > fRecoverErrorThr) {
664 if (fVerbose)
665 AliInfo("Trying to recover the error: searching for the next header");
666 fDecoderSummaryData->SetRecoveringError(kTRUE);
667 continue;
668 }
669 else {
670 if (fVerbose)
671 AliInfo("Do not try to recover error yet, go on with decoding process");
672 continue;
673 }
674 }
675 return(fDecoderSummaryData->GetErrorDetected());
676 }
677 //decode status ok
678 errorWarning = 0;
679 //set TRM global trailer
680 fTRMGlobalTrailer = (AliTOFTRMGlobalTrailer *)rawData;
681 //remove global trailer from TRM CRC
682 TRMCRC ^= *rawData;
683 //fill TRM summary data
684 FillTRMSummaryData(fTRMGlobalTrailer);
685 fTRMSummaryData->SetDecoderCRC(COMPUTE_TRM_CRC(TRMCRC));
686 //print verbose
687 if (fVerbose)
688 AliInfo(Form(" %02x - 0x%08x \t TRM global trailer \t CRC=%04d eventCounter=%04d",decoderStatus,*rawData,fTRMGlobalTrailer->GetEventCRC(),fTRMGlobalTrailer->GetEventCounter()));
689 //change decode status
690 decoderStatus = decoderStatus & ~TRM_BIT;
691 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
692 break;
693
694 default:
695 //try to recover error
696 if (fDecoderSummaryData->GetRecoveringError())
697 continue;
698 if (fLogErrors)
699 AliError(Form(" %02x - 0x%08x [ERROR] Not valid slotID/pattern in global trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
700 fDecoderSummaryData->SetErrorDetected(kTRUE);
701 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
702 errorWarning++;
703 //try to recover error
704 if (fRecoverError){
705 if (fVerbose)
706 AliInfo("Trying to recover the error: searching for the next header");
707 fDecoderSummaryData->SetRecoveringError(kTRUE);
708 continue;
709 }
710 return(fDecoderSummaryData->GetErrorDetected());
711 break;
712 }
713 break;
714
715 case CHAIN_A_HEADER:
716
717 //try to recover error
718 if (fDecoderSummaryData->GetRecoveringError())
719 continue;
720 //check decode status
721 if ( decoderStatus != CHAIN_A_HEADER_STATUS && !fDecoderSummaryData->GetRecoveringError() ){
722 if (fLogErrors)
723 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected TRM chain A header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
724 fDecoderSummaryData->SetErrorDetected(kTRUE);
725 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
726 errorWarning++;
727 //try to recover error
728 if (fRecoverError){
729 if (errorWarning > fRecoverErrorThr) {
730 if (fVerbose)
731 AliInfo("Trying to recover the error: searching for the next header");
732 fDecoderSummaryData->SetRecoveringError(kTRUE);
733 continue;
734 }
735 else {
736 if (fVerbose)
737 AliInfo("Do not try to recover error yet, go on with decoding process");
738 continue;
739 }
740 }
741 return(fDecoderSummaryData->GetErrorDetected());
742 }
743 //decode status ok
744 errorWarning = 0;
745 //set TRM chain header
746 fTRMChainHeader = (AliTOFTRMChainHeader *)rawData;
747 //fill decoder summary data
748 fDecoderSummaryData->SetCurrentChain(0);
749 //get chain summary data
750 fChainSummaryData = fTRMSummaryData->GetChainSummaryData(0);
751 //reset chain summary data
752 fChainSummaryData->Reset();
753 //fill chain summary data
754 FillChainSummaryData(fTRMChainHeader);
755 //get tdc hit buffer
756 fTDCHitBuffer = fChainSummaryData->GetTDCHitBuffer();
757 //reset tdc hit buffer
758 fTDCHitBuffer->Reset();
759 //get tdc packed hit buffer
760 fTDCPackedHitBuffer = fChainSummaryData->GetTDCPackedHitBuffer();
761 //reset tdc packed hit buffer
762 fTDCPackedHitBuffer->Reset();
763 //get tdc error buffer
764 fTDCErrorBuffer = fChainSummaryData->GetTDCErrorBuffer();
765 //reset tdc error buffer
766 fTDCErrorBuffer->Reset();
767 //print verbose
768 if (fVerbose)
769 AliInfo(Form(" %02x - 0x%08x \t TRM chain A header \t chain=%01d bunchID=%04d",decoderStatus,*rawData,0,fTRMChainHeader->GetBunchID()));
770 //change decode status
771 decoderStatus = decoderStatus | CHAIN_A_BIT;
772 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
773 //reset spider
774 if (fSpider)
775 ResetSpider();
776 break;
777
778 case CHAIN_A_TRAILER:
779
780 //try to recover error
781 if (fDecoderSummaryData->GetRecoveringError())
782 continue;
783 //check decode status
784 if ( decoderStatus != CHAIN_A_TRAILER_STATUS && !fDecoderSummaryData->GetRecoveringError()){
785 if (fLogErrors)
786 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected TRM chain A trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
787 fDecoderSummaryData->SetErrorDetected(kTRUE);
788 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
789 errorWarning++;
790 //try to recover error
791 if (fRecoverError){
792 if (errorWarning > fRecoverErrorThr) {
793 if (fVerbose)
794 AliInfo("Trying to recover the error: searching for the next header");
795 fDecoderSummaryData->SetRecoveringError(kTRUE);
796 continue;
797 }
798 else {
799 if (fVerbose)
800 AliInfo("Do not try to recover error yet, go on with decoding process");
801 continue;
802 }
803 }
804 return(fDecoderSummaryData->GetErrorDetected());
805 }
806 //decode status ok
807 errorWarning = 0;
808 //set TRM chain trailer
809 fTRMChainTrailer = (AliTOFTRMChainTrailer *)rawData;
810 //fill chain summary data
811 FillChainSummaryData(fTRMChainTrailer);
812 //print verbose
813 if (fVerbose)
814 AliInfo(Form(" %02x - 0x%08x \t TRM chain A trailer",decoderStatus,*rawData));
815 //change decode status
816 decoderStatus = decoderStatus & ~CHAIN_A_BIT;
817 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
818 break;
819
820 case CHAIN_B_HEADER:
821
822 //try to recover error
823 if (fDecoderSummaryData->GetRecoveringError())
824 continue;
825 //check decode status
826 if ( decoderStatus != CHAIN_B_HEADER_STATUS && !fDecoderSummaryData->GetRecoveringError()){
827 if (fLogErrors)
828 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected TRM chain B header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
829 fDecoderSummaryData->SetErrorDetected(kTRUE);
830 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
831 errorWarning++;
832 //try to recover error
833 if (fRecoverError){
834 if (errorWarning > fRecoverErrorThr) {
835 if (fVerbose)
836 AliInfo("Trying to recover the error: searching for the next header");
837 fDecoderSummaryData->SetRecoveringError(kTRUE);
838 continue;
839 }
840 else {
841 if (fVerbose)
842 AliInfo("Do not try to recover error yet, go on with decoding process");
843 continue;
844 }
845 }
846 return(fDecoderSummaryData->GetErrorDetected());
847 }
848 //decode status ok
849 errorWarning = 0;
850 //set TRM chain header
851 fTRMChainHeader = (AliTOFTRMChainHeader *)rawData;
852 //fill decoder summary data
853 fDecoderSummaryData->SetCurrentChain(1);
854 //get chain summary data
855 fChainSummaryData = fTRMSummaryData->GetChainSummaryData(1);
856 //reset chain summary data
857 fChainSummaryData->Reset();
858 //fill chain summary data
859 FillChainSummaryData(fTRMChainHeader);
860 //get tdc hit buffer
861 fTDCHitBuffer = fChainSummaryData->GetTDCHitBuffer();
862 //reset tdc hit buffer
863 fTDCHitBuffer->Reset();
864 //get tdc packed hit buffer
865 fTDCPackedHitBuffer = fChainSummaryData->GetTDCPackedHitBuffer();
866 //reset tdc packed hit buffer
867 fTDCPackedHitBuffer->Reset();
868 //get tdc error buffer
869 fTDCErrorBuffer = fChainSummaryData->GetTDCErrorBuffer();
870 //reset tdc error buffer
871 fTDCErrorBuffer->Reset();
872 //print verbose
873 if (fVerbose)
874 AliInfo(Form(" %02x - 0x%08x \t TRM chain B header \t chain=%01d bunchID=%04d",decoderStatus,*rawData,1,fTRMChainHeader->GetBunchID()));
875 //change decode status
876 decoderStatus = decoderStatus | CHAIN_B_BIT;
877 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
878 //reset spider
879 if (fSpider)
880 ResetSpider();
881 break;
882
883 case CHAIN_B_TRAILER:
884
885 //try to recover error
886 if (fDecoderSummaryData->GetRecoveringError())
887 continue;
888 //check decode status
889 if ( decoderStatus != CHAIN_B_TRAILER_STATUS && !fDecoderSummaryData->GetRecoveringError()){
890 if (fLogErrors)
891 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected TRM chain B trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
892 fDecoderSummaryData->SetErrorDetected(kTRUE);
893 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
894 errorWarning++;
895 //try to recover error
896 if (fRecoverError){
897 if (errorWarning > fRecoverErrorThr) {
898 if (fVerbose)
899 AliInfo("Trying to recover the error: searching for the next header");
900 fDecoderSummaryData->SetRecoveringError(kTRUE);
901 continue;
902 }
903 else {
904 if (fVerbose)
905 AliInfo("Do not try to recover error yet, go on with decoding process");
906 continue;
907 }
908 }
909 return(fDecoderSummaryData->GetErrorDetected());
910 }
911 //decode status ok
912 errorWarning = 0;
913 //set TRM chain trailer
914 fTRMChainTrailer = (AliTOFTRMChainTrailer *)rawData;
915 //fill chain summary data
916 FillChainSummaryData(fTRMChainTrailer);
917 //print verbose
918 if (fVerbose)
919 AliInfo(Form(" %02x - 0x%08x \t TRM chain B trailer",decoderStatus,*rawData));
920 //change decode status
921 decoderStatus = decoderStatus & ~CHAIN_B_BIT;
922 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
923 break;
924
925 case ERROR:
926
927 //try to recover error
928 if (fDecoderSummaryData->GetRecoveringError())
929 continue;
930 //decode TRM TDC error
931 fTRMTDCError = (AliTOFTRMTDCError *)rawData;
932 //check diagnostic word
933 if (fTRMTDCError->GetTDCID() == 15) {
934 if (fVerbose)
935 AliInfo(Form(" %02x - 0x%08x \t Diagnostic error word",decoderStatus,*rawData));
936 break;
937 }
938 //set error data
939 error.SetErrorFlags(fTRMTDCError->GetErrorFlags());
940 error.SetTDCID(fTRMTDCError->GetTDCID());
941 //fill TDC error buffer
942 fTDCErrorBuffer->Add(error);
943 if (fVerbose)
944 AliInfo(Form(" %02x - 0x%08x \t TDC error",decoderStatus,*rawData));
945 break;
946
947 case FILLER:
948
949 //try to recover error
950 if (fDecoderSummaryData->GetRecoveringError())
951 continue;
952 if (fVerbose)
953 AliInfo(Form(" %02x - 0x%08x \t Filler",decoderStatus,*rawData));
954 break;
955
956 default:
957
958 //try to recover error
959 if (fDecoderSummaryData->GetRecoveringError())
960 continue;
961 //check decode status
962 if ( decoderStatus != CHAIN_A_TDC_HIT_STATUS &&
963 decoderStatus != CHAIN_B_TDC_HIT_STATUS && !fDecoderSummaryData->GetRecoveringError()){
964 if (fLogErrors)
965 AliError(Form(" %02x - 0x%08x [ERROR] Unexpected or unknown word (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
966 fDecoderSummaryData->SetErrorDetected(kTRUE);
967 fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
968 errorWarning++;
969 //try to recover error
970 if (fRecoverError){
971 if (errorWarning > fRecoverErrorThr) {
972 if (fVerbose)
973 AliInfo("Trying to recover the error: searching for the next header");
974 fDecoderSummaryData->SetRecoveringError(kTRUE);
975 continue;
976 }
977 else {
978 if (fVerbose)
979 AliInfo("Do not try to recover error yet, go on with decoding process");
980 continue;
981 }
982 }
983 return(fDecoderSummaryData->GetErrorDetected());
984 }
985 //decode status ok
986 errorWarning = 0;
987
988 //switch TRM ACQ
989 switch (fTRMSummaryData->GetACQBits()){
990
991 case PACKING_ENABLED_ACQ:
992 //decode TDC packed/unpacked hit
993 fTDCPackedHit = (AliTOFTDCPackedHit *)rawData;
994 fTDCUnpackedHit = (AliTOFTDCUnpackedHit *)rawData;
995 //set hit data
996 hit.SetChan(fTDCUnpackedHit->GetChan());
997 hit.SetTDCID(fTDCUnpackedHit->GetTDCID());
998 hit.SetEBit(fTDCUnpackedHit->GetEBit());
999 hit.SetPSBits(fTDCUnpackedHit->GetPSBits());
1000 //switch PS bits
1001 switch (hit.GetPSBits()){
1002 //packed hit or overflow hit
1003 case PACKED_HIT_PS: case TOT_OVF_HIT_PS:
1004 hit.SetHitTime(fTDCPackedHit->GetHitTime());
1005 hit.SetTOTWidth(fTDCPackedHit->GetTOTWidth());
1006 //add hit
1007 fTDCHitBuffer->Add(hit);
1008 fTDCPackedHitBuffer->Add(hit);
1009 break;
1010 //orphane leading
1011 case LEADING_HIT_PS:
1012 hit.SetHitTime(fTDCUnpackedHit->GetHitTime());
1013 hit.SetTOTWidth(0);
1014 //add hit
1015 fTDCHitBuffer->Add(hit);
1016 fTDCPackedHitBuffer->Add(hit);
1017 break;
1018 //orphane trailing
1019 case TRAILING_HIT_PS:
1020 hit.SetHitTime(fTDCUnpackedHit->GetHitTime());
1021 hit.SetTOTWidth(0);
1022 //add hit
1023 fTDCHitBuffer->Add(hit);
1024 break;
1025 }
1026 //end switch PS bits
1027 //print verbose
1028 if (fVerbose)
1029 switch (hit.GetPSBits()){
1030 case PACKED_HIT_PS:
1031 AliInfo(Form(" %02x - 0x%08x \t TDC hit [packed] \t PS=%1d TDC=%1d chan=%1d TOT=%3d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetTOTWidth(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1032 break;
1033 case LEADING_HIT_PS:
1034 AliInfo(Form(" %02x - 0x%08x \t TDC hit [orp.lead] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1035 break;
1036 case TRAILING_HIT_PS:
1037 AliInfo(Form(" %02x - 0x%08x \t TDC hit [orp.trai] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1038 break;
1039 case TOT_OVF_HIT_PS:
1040 AliInfo(Form(" %02x - 0x%08x \t TDC hit [TOT ovfl] \t PS=%1d TDC=%1d chan=%1d TOT=%3d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetTOTWidth(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1041 break;
1042 }
1043 break;
1044
1045 case LEADING_ONLY_ACQ: case TRAILING_ONLY_ACQ:
1046 //decode TDC unpacked hit
1047 fTDCUnpackedHit = (AliTOFTDCUnpackedHit *)rawData;
1048 //set hit data
1049 hit.SetChan(fTDCUnpackedHit->GetChan());
1050 hit.SetTDCID(fTDCUnpackedHit->GetTDCID());
1051 hit.SetEBit(fTDCUnpackedHit->GetEBit());
1052 hit.SetPSBits(fTDCUnpackedHit->GetPSBits());
1053 hit.SetHitTime(fTDCUnpackedHit->GetHitTime());
1054 hit.SetTOTWidth(0);
1055 //add hit
1056 fTDCHitBuffer->Add(hit);
1057 //print verbose
1058 if (fVerbose)
1059 switch (hit.GetPSBits()){
1060 case LEADING_HIT_PS:
1061 AliInfo(Form(" %02x - 0x%08x \t TDC hit [leading] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1062 break;
1063 case TRAILING_HIT_PS:
1064 AliInfo(Form(" %02x - 0x%08x \t TDC hit [trailing] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1065 }
1066 break;
1067
1068 case PACKING_DISABLED_ACQ:
1069 //decode TDC unpacked hit
1070 fTDCUnpackedHit = (AliTOFTDCUnpackedHit *)rawData;
1071 //set hit data
1072 hit.SetChan(fTDCUnpackedHit->GetChan());
1073 hit.SetTDCID(fTDCUnpackedHit->GetTDCID());
1074 hit.SetEBit(fTDCUnpackedHit->GetEBit());
1075 hit.SetPSBits(fTDCUnpackedHit->GetPSBits());
1076 hit.SetHitTime(fTDCUnpackedHit->GetHitTime());
1077 hit.SetTOTWidth(0);
1078 //add hit
1079 fTDCHitBuffer->Add(hit);
1080 //print verbose
1081 if (fVerbose)
1082 switch (hit.GetPSBits()){
1083 case LEADING_HIT_PS:
1084 AliInfo(Form(" %02x - 0x%08x \t TDC hit [leading] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1085 break;
1086 case TRAILING_HIT_PS:
1087 AliInfo(Form(" %02x - 0x%08x \t TDC hit [trailing] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1088 } //print verbose
1089 //spider
1090 if (fSpider)
1091 Spider(hit);
1092
1093 break;
1094 }
1095 //end switch TRM ACQ
1096
1097 break;
1098
1099 }
1100
1101 }
1102 //end equipment data loop
1103
1104 if (fVerbose)
1105 AliInfo("End of data loop");
1106
1107 //reset spider
1108 if (fSpider)
1109 ResetSpider();
1110
1111 /*** V2718 patch ***/
1112 if (fV2718Patch){
1113 decoderStatus = decoderStatus & ~DRM_BIT;
1114 fDecoderSummaryData->SetDecoderStatus(decoderStatus);
1115 fDRMSummaryData->SetTrailer(kTRUE);
1116 fDRMSummaryData->SetSlotEnableMask(fDRMSummaryData->GetDecoderSlotEnableMask());
1117 fDRMSummaryData->SetCBit(1);
1118 fDRMSummaryData->SetLocalEventCounter(fTRMSummaryData->GetEventCounter());
1119 if (fVerbose)
1120 AliInfo("DRM was not present: - V2718 end patch decoding -");
1121 }
1122 /*** V2718 patch ***/
1123
1124 if (fVerbose)
1125 AliInfo("Decoder is exiting succesfully.");
1126
1127 return(fDecoderSummaryData->GetErrorDetected());
1128}
1129
1130//_________________________________________________________________
1131
1132void
1133AliTOFDecoderV2::FillDRMSummaryData(AliTOFDRMGlobalHeader *DRMGlobalHeader)
1134{
1135 fDRMSummaryData->SetHeader(kTRUE);
1136 fDRMSummaryData->SetSlotID(DRMGlobalHeader->GetSlotID());
1137 fDRMSummaryData->SetEventWords(DRMGlobalHeader->GetEventWords());
1138 fDRMSummaryData->SetDRMID(DRMGlobalHeader->GetDRMID());
1139}
1140
1141//_________________________________________________________________
1142
1143void
1144AliTOFDecoderV2::FillDRMSummaryData(AliTOFDRMGlobalTrailer *DRMGlobalTrailer)
1145{
1146 fDRMSummaryData->SetTrailer(kTRUE);
1147 fDRMSummaryData->SetLocalEventCounter(DRMGlobalTrailer->GetLocalEventCounter());
1148}
1149
1150//_________________________________________________________________
1151
1152void
1153AliTOFDecoderV2::FillDRMSummaryData(AliTOFDRMStatusHeader1 *DRMStatusHeader1)
1154{
1155 fDRMSummaryData->SetPartecipatingSlotID(DRMStatusHeader1->GetPartecipatingSlotID());
1156 fDRMSummaryData->SetCBit(DRMStatusHeader1->GetCBit());
1157 fDRMSummaryData->SetVersID(DRMStatusHeader1->GetVersID());
1158 fDRMSummaryData->SetDRMhSize(DRMStatusHeader1->GetDRMhSize());
1159}
1160
1161//_________________________________________________________________
1162
1163void
1164AliTOFDecoderV2::FillDRMSummaryData(AliTOFDRMStatusHeader2 *DRMStatusHeader2)
1165{
1166 fDRMSummaryData->SetSlotEnableMask(DRMStatusHeader2->GetSlotEnableMask());
1167 fDRMSummaryData->SetFaultID(DRMStatusHeader2->GetFaultID());
1168 fDRMSummaryData->SetRTOBit(DRMStatusHeader2->GetRTOBit());
1169}
1170
1171//_________________________________________________________________
1172
1173void
1174AliTOFDecoderV2::FillDRMSummaryData(AliTOFDRMStatusHeader3 *DRMStatusHeader3)
1175{
1176 fDRMSummaryData->SetL0BCID(DRMStatusHeader3->GetL0BCID());
1177 fDRMSummaryData->SetRunTimeInfo(DRMStatusHeader3->GetRunTimeInfo());
1178}
1179
1180//_________________________________________________________________
1181
1182void
1183AliTOFDecoderV2::FillDRMSummaryData(AliTOFDRMStatusHeader4 *DRMStatusHeader4)
1184{
1185 fDRMSummaryData->SetTemperature(DRMStatusHeader4->GetTemperature());
1186 fDRMSummaryData->SetACKBit(DRMStatusHeader4->GetACKBit());
1187 fDRMSummaryData->SetSensAD(DRMStatusHeader4->GetSensAD());
1188}
1189
1190//_________________________________________________________________
1191
1192void
1193AliTOFDecoderV2::FillDRMSummaryData(AliTOFDRMEventCRC *DRMEventCRC)
1194{
1195 fDRMSummaryData->SetEventCRC(DRMEventCRC->GetEventCRC());
1196}
1197
1198//_________________________________________________________________
1199
1200void
1201AliTOFDecoderV2::FillLTMSummaryData(AliTOFLTMGlobalHeader *LTMGlobalHeader)
1202{
1203 fLTMSummaryData->SetHeader(kTRUE);
1204 fLTMSummaryData->SetSlotID(LTMGlobalHeader->GetSlotID());
1205 fLTMSummaryData->SetEventWords(LTMGlobalHeader->GetEventWords());
1206 fLTMSummaryData->SetCBit(LTMGlobalHeader->GetCBit());
1207 fLTMSummaryData->SetFault(LTMGlobalHeader->GetFault());
1208}
1209
1210//_________________________________________________________________
1211
1212void
1213AliTOFDecoderV2::FillLTMSummaryData(AliTOFLTMGlobalTrailer *LTMGlobalTrailer)
1214{
1215 fLTMSummaryData->SetTrailer(kTRUE);
1216 fLTMSummaryData->SetEventCRC(LTMGlobalTrailer->GetEventCRC());
1217 fLTMSummaryData->SetEventNumber(LTMGlobalTrailer->GetEventNumber());
1218}
1219
1220//_________________________________________________________________
1221
1222void
1223AliTOFDecoderV2::FillLTMSummaryData(AliTOFLTMPDLData *LTMPDLData, Int_t PDLWord)
1224{
1225 fLTMSummaryData->SetPDL(4 * PDLWord + 0, LTMPDLData->GetPDLValue1());
1226 fLTMSummaryData->SetPDL(4 * PDLWord + 1, LTMPDLData->GetPDLValue2());
1227 fLTMSummaryData->SetPDL(4 * PDLWord + 2, LTMPDLData->GetPDLValue3());
1228 fLTMSummaryData->SetPDL(4 * PDLWord + 3, LTMPDLData->GetPDLValue4());
1229}
1230
1231//_________________________________________________________________
1232
1233void
1234AliTOFDecoderV2::FillLTMSummaryData(AliTOFLTMADCData *LTMADCData, Int_t ADCWord)
1235{
1236 fLTMSummaryData->SetADC(3 * ADCWord + 0, LTMADCData->GetADCValue1());
1237 fLTMSummaryData->SetADC(3 * ADCWord + 1, LTMADCData->GetADCValue2());
1238 fLTMSummaryData->SetADC(3 * ADCWord + 2, LTMADCData->GetADCValue3());
1239}
1240
1241//_________________________________________________________________
1242
1243void
1244AliTOFDecoderV2::FillLTMSummaryData(AliTOFLTMORData *LTMORData, Int_t ORWord)
1245{
1246 fLTMSummaryData->SetOR(3 * ORWord + 0, LTMORData->GetORValue1());
1247 fLTMSummaryData->SetOR(3 * ORWord + 1, LTMORData->GetORValue2());
1248 fLTMSummaryData->SetOR(3 * ORWord + 2, LTMORData->GetORValue3());
1249}
1250
1251//_________________________________________________________________
1252
1253void
1254AliTOFDecoderV2::FillTRMSummaryData(AliTOFTRMGlobalHeader *TRMGlobalHeader)
1255{
1256 fTRMSummaryData->SetHeader(kTRUE);
1257 fTRMSummaryData->SetSlotID(TRMGlobalHeader->GetSlotID());
1258 fTRMSummaryData->SetEventWords(TRMGlobalHeader->GetEventWords());
1259 fTRMSummaryData->SetACQBits(TRMGlobalHeader->GetACQBits());
1260 fTRMSummaryData->SetLBit(TRMGlobalHeader->GetLBit());
1261 fTRMSummaryData->SetEBit(TRMGlobalHeader->GetEBit());
1262}
1263
1264//_________________________________________________________________
1265
1266void
1267AliTOFDecoderV2::FillTRMSummaryData(AliTOFTRMGlobalTrailer *TRMGlobalTrailer)
1268{
1269 fTRMSummaryData->SetTrailer(kTRUE);
1270 fTRMSummaryData->SetEventCRC(TRMGlobalTrailer->GetEventCRC());
1271 fTRMSummaryData->SetEventCounter(TRMGlobalTrailer->GetEventCounter());
1272}
1273
1274//_________________________________________________________________
1275
1276void
1277AliTOFDecoderV2::FillChainSummaryData(AliTOFTRMChainHeader *TRMChainHeader)
1278{
1279 fChainSummaryData->SetHeader(kTRUE);
1280 switch (*(UInt_t *)TRMChainHeader & WORD_TYPE_MASK){
1281 case CHAIN_A_HEADER:
1282 fChainSummaryData->SetChain(0);
1283 break;
1284 case CHAIN_B_HEADER:
1285 fChainSummaryData->SetChain(1);
1286 break;
1287 }
1288 fChainSummaryData->SetBunchID(TRMChainHeader->GetBunchID());
1289 fChainSummaryData->SetPB24Temp(TRMChainHeader->GetPB24Temp());
1290 fChainSummaryData->SetPB24ID(TRMChainHeader->GetPB24ID());
1291 fChainSummaryData->SetTSBit(TRMChainHeader->GetTSBit());
1292}
1293
1294//_________________________________________________________________
1295
1296void
1297AliTOFDecoderV2::FillChainSummaryData(AliTOFTRMChainTrailer *TRMChainTrailer)
1298{
1299 fChainSummaryData->SetTrailer(kTRUE);
1300 fChainSummaryData->SetStatus(TRMChainTrailer->GetStatus());
1301 fChainSummaryData->SetEventCounter(TRMChainTrailer->GetEventCounter());
1302}
1303
1304//_________________________________________________________________
1305
1306void
1307AliTOFDecoderV2::ResetSpider()
1308{
1309 //reset condition
1310 if (fVerbose)
1311 AliInfo("Reset signal received, empty and reset buffer");
1312 for (Int_t iChan = 0; iChan < N_CHANNEL; iChan++){
1313 if (fSpiderBufferFull[iChan]) {
1314 if (fVerbose)
1315 AliInfo(Form("Spider buffer is full for channel %d", iChan));
1316 fSpiderTDCPackedHitBuffer->Add(fSpiderBuffer[iChan]);
1317 }
1318 fSpiderBufferFull[iChan] = kFALSE;
1319 }
1320 fSpiderTDCID = -1;
1321 return;
1322}
1323
1324void
1325AliTOFDecoderV2::Spider(AliTOFTDCHit &hit){
1326
1327 if (fVerbose)
1328 AliInfo("Hit has been received from decode main routine");
1329
1330 //check new TDC
1331 if (fSpiderTDCID != hit.GetTDCID()){
1332 if (fVerbose)
1333 AliInfo("Data coming from a new TDC, empty and reset buffer");
1334 for (Int_t iChan = 0; iChan < N_CHANNEL; iChan++){
1335 if (fSpiderBufferFull[iChan])
1336 fSpiderTDCPackedHitBuffer->Add(fSpiderBuffer[iChan]);
1337 fSpiderBufferFull[iChan] = kFALSE;
1338 }
1339 fSpiderTDCPackedHitBuffer = fTDCPackedHitBuffer;
1340 fSpiderTDCID = hit.GetTDCID();
1341 }
1342
1343 //switch PS bits
1344 switch(hit.GetPSBits()){
1345 //leading hit
1346 case LEADING_HIT_PS:
1347 //check buffer status
1348 if (fSpiderBufferFull[hit.GetChan()]){ //buffer full
1349 fSpiderTDCPackedHitBuffer->Add(fSpiderBuffer[hit.GetChan()]); //buffered hit is orphane
1350 fSpiderBuffer[hit.GetChan()] = hit; //current hit into buffer
1351 if (fVerbose)
1352 AliInfo("Leading hit and buffer full, buffered hit is a orphane leading hit");
1353 }
1354 else{ //buffer empty
1355 fSpiderBuffer[hit.GetChan()] = hit; //current hit into buffer
1356 fSpiderBufferFull[hit.GetChan()] = kTRUE; //set buffer full
1357 }
1358 break;
1359 //trailing hit
1360 case TRAILING_HIT_PS:
1361 //check buffer status
1362 if (fSpiderBufferFull[hit.GetChan()]){ //buffer full
1363 fSpiderTDCPackedHitBuffer->Add(fSpiderBuffer[hit.GetChan()] << hit); //pack hits (Leading << Trailing) and save
1364 fSpiderBufferFull[hit.GetChan()] = kFALSE; //unset buffer full
1365 if (fVerbose)
1366 AliInfo("Trailing hit and buffer full, pack leading and trailing hit");
1367 }
1368 else{ //buffer empty
1369 ; //do nothing
1370 if (fVerbose)
1371 AliInfo("Trailing hit and buffer empty, trow trailing hit away");
1372 }
1373 break;
1374 } //switch PS bits
1375
1376}
1377
1378//_________________________________________________________________
1379
1380Bool_t
1381AliTOFDecoderV2::DecodeNext()
1382{
1383 /* decode next */
1384
1385 if (!fRawReader || !fRawReader->ReadHeader())
1386 return kFALSE;
1387
1388 const Int_t size = fRawReader->GetDataSize();
1389 UChar_t *data = new UChar_t[size];
1390 if (fRawReader->ReadNext(data, size) != 1) {
1391 delete [] data;
1392 return kFALSE;
1393 }
1394
1395 /* decode equipment data */
1396 SetEquipmentID(fRawReader->GetEquipmentId());
1397 Decode((UInt_t *)data, size / 4);
1398
1399 delete [] data;
1400 return kTRUE;
1401}