]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - TRD/AliTRDrawOldStream.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Some unuseful print commented
[u/mrichter/AliRoot.git] / TRD / AliTRDrawOldStream.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id: AliTRDrawOldStream.cxx 23562 2008-01-25 15:35:04Z cblume $ */
17
18////////////////////////////////////////////////////////////////////////////
19// //
20// This class provides access to TRD digits in raw data. //
21// //
22// It loops over all TRD digits in the raw data given by the AliRawReader //
23// The Next method goes to the next digit. If there are no digits left //
24// it returns kFALSE. //
25// Several getters provide information about the current digit. //
26// //
27// Author: //
28// Christian Lippmann (C.Lippmann@gsi.de) //
29// //
30////////////////////////////////////////////////////////////////////////////
31
32#include "AliLog.h"
33#include "AliRawReader.h"
34
35#include "AliTRDrawOldStream.h"
36#include "AliTRDgeometry.h"
37#include "AliTRDcalibDB.h"
38#include "AliTRDdigitsManager.h"
39#include "AliTRDarrayDictionary.h"
40#include "AliTRDarrayADC.h"
41#include "AliTRDSignalIndex.h"
42#include "AliTRDfeeParam.h"
43
44ClassImp(AliTRDrawOldStream)
45
46//_____________________________________________________________________________
47AliTRDrawOldStream::AliTRDrawOldStream()
48 :AliTRDrawStreamBase()
49// :TObject()
50 ,fGeo(NULL)
51 ,fSig()
52 ,fADC(0)
53 ,fTB(0)
54 ,fEv(0)
55 ,fROB(0)
56 ,fMCM(0)
57 ,fSM(0)
58 ,fLAYER(0)
59 ,fSTACK(0)
60 ,fROC(0)
61 ,fSIDE(0)
62 ,fDCS(0)
63 ,fROW(0)
64 ,fCOL(0)
65 ,fDET(0)
66 ,fLastDET(-1)
67 ,fBCctr(0)
68 ,fPTctr(0)
69 ,fPTphase(0)
70 ,fRVmajor(0)
71 ,fRVminor(0)
72 ,fHCHWords(0)
73 ,fTBins(0)
74 ,fTCon(0)
75 ,fPEDon(0)
76 ,fGAINon(0)
77 ,fXTon(0)
78 ,fNonLinOn(0)
79 ,fBypass(0)
80 ,fCommonAdditive(0)
81 ,fZeroSuppressed(0)
82 ,fHCHctr1(0)
83 ,fHCHctr2(0)
84 ,fMCMHctr1(0)
85 ,fMCMHctr2(0)
86 ,fGTUctr1(0)
87 ,fGTUctr2(0)
88 ,fHCdataCtr(0)
89 ,fTracklPID(0.)
90 ,fTracklDefL(0.)
91 ,fTracklPadPos(0.)
92 ,fTracklPadRow(0)
93 ,fGTUlinkMask()
94 ,fRawReader(NULL)
95 ,fRawVersion(2)
96 ,fNextStatus(0)
97 ,fTbSwitch(0)
98 ,fTbSwitchCtr(0)
99 ,fTimeWords(0)
100 ,fWordCtr(0)
101 ,fRowMax(0)
102 ,fColMax(0)
103 ,fADCmask()
104 ,fChamberDone()
105 ,fRetVal(0)
106 ,fEqID(0)
107 ,fDataSize(0)
108 ,fSizeOK(kFALSE)
109 ,fCountBytes(0)
110 ,fBufSize(0)
111 ,fBufferSet(kFALSE)
112 ,fPos(NULL)
113 ,fDataWord(NULL)
114 ,fTimeBinsCalib(0)
115{
116 //
117 // Default constructor
118 //
119
120 for (Int_t i = 0; i < 540; i++) {
121 fChamberDone[i] = 0;
122 }
123
124}
125
126//_____________________________________________________________________________
127AliTRDrawOldStream::AliTRDrawOldStream(AliRawReader *rawReader)
128 :AliTRDrawStreamBase(rawReader)
129// :TObject()
130 ,fGeo(NULL)
131 ,fSig()
132 ,fADC(0)
133 ,fTB(0)
134 ,fEv(0)
135 ,fROB(0)
136 ,fMCM(0)
137 ,fSM(0)
138 ,fLAYER(0)
139 ,fSTACK(0)
140 ,fROC(0)
141 ,fSIDE(0)
142 ,fDCS(0)
143 ,fROW(0)
144 ,fCOL(0)
145 ,fDET(0)
146 ,fLastDET(-1)
147 ,fBCctr(0)
148 ,fPTctr(0)
149 ,fPTphase(0)
150 ,fRVmajor(0)
151 ,fRVminor(0)
152 ,fHCHWords(0)
153 ,fTBins(0)
154 ,fTCon(0)
155 ,fPEDon(0)
156 ,fGAINon(0)
157 ,fXTon(0)
158 ,fNonLinOn(0)
159 ,fBypass(0)
160 ,fCommonAdditive(0)
161 ,fZeroSuppressed(0)
162 ,fHCHctr1(0)
163 ,fHCHctr2(0)
164 ,fMCMHctr1(0)
165 ,fMCMHctr2(0)
166 ,fGTUctr1(0)
167 ,fGTUctr2(0)
168 ,fHCdataCtr(0)
169 ,fTracklPID(0.)
170 ,fTracklDefL(0.)
171 ,fTracklPadPos(0.)
172 ,fTracklPadRow(0)
173 ,fGTUlinkMask()
174 ,fRawReader(rawReader)
175 ,fRawVersion(2)
176 ,fNextStatus(0)
177 ,fTbSwitch(0)
178 ,fTbSwitchCtr(0)
179 ,fTimeWords(0)
180 ,fWordCtr(0)
181 ,fRowMax(0)
182 ,fColMax(0)
183 ,fADCmask()
184 ,fChamberDone()
185 ,fRetVal(0)
186 ,fEqID(0)
187 ,fDataSize(0)
188 ,fSizeOK(kFALSE)
189 ,fCountBytes(0)
190 ,fBufSize(0)
191 ,fBufferSet(kFALSE)
192 ,fPos(NULL)
193 ,fDataWord(NULL)
194 ,fTimeBinsCalib(0)
195{
196 //
197 // Create an object to read TRD raw digits
198 //
199
200 fRawReader->Select("TRD");
201
202 for (Int_t i = 0; i < 540; i++) {
203 fChamberDone[i] = 0;
204 }
205
206}
207
208//_____________________________________________________________________________
209AliTRDrawOldStream::AliTRDrawOldStream(const AliTRDrawOldStream& stream)
210 :AliTRDrawStreamBase(stream)
211// :TObject()
212 ,fGeo(NULL)
213 ,fSig()
214 ,fADC(-1)
215 ,fTB(-1)
216 ,fEv(-1)
217 ,fROB(-1)
218 ,fMCM(-1)
219 ,fSM(-1)
220 ,fLAYER(-1)
221 ,fSTACK(-1)
222 ,fROC(-1)
223 ,fSIDE(-1)
224 ,fDCS(-1)
225 ,fROW(-1)
226 ,fCOL(-1)
227 ,fDET(0)
228 ,fLastDET(-1)
229 ,fBCctr(-1)
230 ,fPTctr(-1)
231 ,fPTphase(-1)
232 ,fRVmajor(-1)
233 ,fRVminor(-1)
234 ,fHCHWords(-1)
235 ,fTBins(-1)
236 ,fTCon(0)
237 ,fPEDon(0)
238 ,fGAINon(0)
239 ,fXTon(0)
240 ,fNonLinOn(-1)
241 ,fBypass(-1)
242 ,fCommonAdditive(-1)
243 ,fZeroSuppressed(0)
244 ,fHCHctr1(-1)
245 ,fHCHctr2(-1)
246 ,fMCMHctr1(-1)
247 ,fMCMHctr2(-1)
248 ,fGTUctr1(-1)
249 ,fGTUctr2(-1)
250 ,fHCdataCtr(-1)
251 ,fTracklPID(-1.)
252 ,fTracklDefL(-1.)
253 ,fTracklPadPos(-1.)
254 ,fTracklPadRow(-1)
255 ,fGTUlinkMask()
256 ,fRawReader(NULL)
257 ,fRawVersion(-1)
258 ,fNextStatus(0)
259 ,fTbSwitch(0)
260 ,fTbSwitchCtr(0)
261 ,fTimeWords(0)
262 ,fWordCtr(0)
263 ,fRowMax(-1)
264 ,fColMax(-1)
265 ,fADCmask()
266 ,fChamberDone()
267 ,fRetVal(0)
268 ,fEqID(0)
269 ,fDataSize(0)
270 ,fSizeOK(kFALSE)
271 ,fCountBytes(0)
272 ,fBufSize(0)
273 ,fBufferSet(kFALSE)
274 ,fPos(NULL)
275 ,fDataWord(NULL)
276 ,fTimeBinsCalib(0)
277{
278 //
279 // Copy constructor
280 //
281
282 AliFatal("Copy constructor not implemented");
283
284}
285
286//_____________________________________________________________________________
287AliTRDrawOldStream& AliTRDrawOldStream::operator = (const AliTRDrawOldStream&
288 /* stream */)
289{
290 //
291 // Assigment operator
292 //
293
294 AliFatal("Assignment operator not implemented");
295 return *this;
296
297}
298
299//_____________________________________________________________________________
300AliTRDrawOldStream::~AliTRDrawOldStream()
301{
302 //
303 // Destructor
304 //
305
306 if (fGeo) {
307 delete fGeo;
308 }
309
310}
311
312//_____________________________________________________________________________
313void AliTRDrawOldStream::SetRawReader(AliRawReader *rawReader)
314{
315 //
316 // Sets the raw reader
317 //
318
319 if (rawReader)
320 {
321 fRawReader = rawReader;
322 }
323
324}
325
326//_____________________________________________________________________________
327Bool_t AliTRDrawOldStream::SetRawVersion(Int_t rv)
328{
329 //
330 // Set the raw data version
331 //
332
333 if ( rv >= 0 && rv <= 3 ) {
334 fRawVersion = rv;
335 return kTRUE;
336 }
337
338 return kFALSE;
339
340}
341
342//____________________________________________________________________________
343Bool_t AliTRDrawOldStream::Init()
344{
345 //
346 // Initialization
347 //
348
349 if (!AliTRDcalibDB::Instance()) {
350 AliError("Could not get calibration object");
351 return kFALSE;
352 }
353
354 if (!fGeo) {
355 fGeo = new AliTRDgeometry();
356 }
357
358 fTimeBinsCalib = AliTRDcalibDB::Instance()->GetNumberOfTimeBins();
359 AliDebug(2, Form("Number of Timebins read from CDB: %d", fTimeBinsCalib));
360
361 // The number of data words needed for this number of time bins (there
362 // are 3 time bins in one word)
363 fTimeWords = (fTimeBinsCalib-1)/3 + 1;
364
365 fTbSwitch = 3;
366 fTbSwitchCtr = 0;
367
368 fHCHctr1 = fHCHctr2 = 0;
369 fGTUctr1 = fGTUctr2 = -1;
370
371 fHCdataCtr = 0;
372 fWordCtr = 0;
373
374 fDET = 0;
375 fLastDET = -1;
376 fRetVal = 0;
377 fEqID = 0;
378 fDataSize = 0;
379 fSizeOK = kFALSE;
380
381 fNextStatus = kStart;
382
383 fCountBytes = 0;
384 fBufSize = 0;
385 fDataWord = NULL;
386 fPos = NULL;
387 fWordCtr = 0;
388 fBufferSet = kFALSE;
389
390 return kTRUE;
391
392}
393
394//____________________________________________________________________________
395Int_t AliTRDrawOldStream::NextData()
396{
397 //
398 // Updates the next data word pointer
399 //
400
401 if (fCountBytes + kSizeWord >= fBufSize)
402 {
403 fBufferSet = fRawReader->ReadNextData(fPos);
404 if (fBufferSet == kTRUE)
405 {
406 fBufSize = fRawReader->GetDataSize();
407 fCountBytes = 0;
408 fDataWord = (UInt_t*)fPos;
409 fNextStatus = kNextSM;
410 fWordCtr = 0;
411 return kNextSM;
412 }
413 else
414 {
415 fNextStatus = kStop;
416 return kNoMoreData;
417 }
418 }
419 else
420 {
421
422 fPos += kSizeWord;
423 fCountBytes += kSizeWord;
424 fDataWord = (UInt_t*)fPos;
425 fWordCtr++;
426 return kWordOK;
427 }
428}
429
430//____________________________________________________________________________
431Bool_t AliTRDrawOldStream::Next()
432{
433 //
434 // Updates the next data word pointer
435 //
436
437 if (fNextStatus == kStart)
438 {
439 Init();
440 }
441
442 while (fNextStatus != kStop)
443 { // !kStop
444 NextData();
445 if (fNextStatus == kNextMCM || fNextStatus == kNextData)
446 {
447 fHCdataCtr += 4;
448
449 if( ((*fDataWord & 0x80000000) == 0x0) && ((*fDataWord & 0x0000000f) == 0xC) )
450 { // MCM Header
451 DecodeMCMheader();
452 if ( fMCM < 0 || fMCM > 15 || fROB < 0 || fROB > 7 )
453 {
454 AliWarning("Wrong fMCM or fROB. Skip this data");
455 fRawReader->AddMajorErrorLog(kWrongMCMorROB,Form("MCM=%d, ROB=%d",fMCM,fROB));
456 fNextStatus = kNextHC;
457 continue;
458 }
459 fTbSwitch = 3; // For first adc channel we expect: (*fDataWord & 3) = 3
460 fTbSwitchCtr = 0; //
461 fADC = fTB = 0; // Reset Counter
462 fNextStatus = kNextData;
463 continue;
464 }
465
466 if ( *fDataWord == kEndofrawdatamarker )
467 { // End of half-chamber data, finished
468 fGTUctr1 = -1;
469 fNextStatus = kNextHC;
470 continue;
471 }
472
473 if (fNextStatus == kNextData )
474 { // MCM header is set, ADC data is valid.
475
476 // Found some data. Decode it now:
477 fRetVal = DecodeDataWord();
478 if ( fRetVal == 0 ) continue;
479 if ( fRetVal == -1 )
480 {
481 fNextStatus = kNextHC;
482 continue;
483 }
484 if ( fRetVal == 1)
485 {
486 { // A real pad
487 fTB += 3;
488 return kTRUE;
489 }
490 }
491 // following ifs have been moved to DEcodeDatawordV1V2
492 // if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax()-1 )
493 // {
494 // // Write Digits
495 // if ( fCOL >= 0 && fCOL < fColMax && fROW >= 0 && fROW < fRowMax )
496 // { // A real pad
497 // fTB += 3;
498 // return kTRUE;
499 // }
500 // }
501 // else
502 // {
503 // fCOL = -1;
504 // }
505 }// kNextData
506
507 continue;
508 } //next mcm
509
510 if ( fNextStatus == kNextHC )
511 {
512 //
513 // 1) Find end_of_tracklet_marker
514 //
515 // GTU Link Mask?
516 if ( (*fDataWord & 0xfffff000) == 0xe0000000 )
517 {
518 DecodeGTUlinkMask();
519 continue;
520 }
521
522 // endoftrackletmarker?
523 if ( *fDataWord == kEndoftrackletmarker )
524 {
525 AliDebug(3, "end-of-tracklet-marker found");
526 fNextStatus = kSeekNonEoTracklet;
527 continue;
528 }
529 else
530 {
531 // Tracklets found
532 AliDebug(3, "Tracklet found");
533 DecodeTracklet();
534 continue;
535 }
536 } //if next HC
537
538 if (fNextStatus == kSeekNonEoTracklet)
539 {
540 //
541 // 2) Look for non-end_of_tracklet_marker
542 //
543 //printf("Word %d: 0x%08x\n", fWordCtr, *fDataWord);
544
545 if ( *fDataWord != kEndoftrackletmarker )
546 {
547 fNextStatus = kDecodeHC;
548 AliDebug(3, "NON end-of-tracklet-marker found");
549 //// no do not continue - this should be the hcheader
550 }
551 else
552 {
553 //just go on and find the non-end_of_tracklet_marker
554 continue;
555 }
556 }
557
558 if ( fNextStatus == kDecodeHC )
559 {
560 AliDebug(3, "Decode HC");
561
562 //
563 // 3) This Word must be Half Chamber Header
564 //
565 if ( (*fDataWord & 0x00000003) == 1 )
566 { // HC header
567 DecodeHCheader(fTimeBinsCalib); // This is the new header!
568 fLastDET = fDET;
569 fDET = fGeo->GetDetector(fLAYER, fSTACK, fSM);
570 fRowMax = fGeo->GetRowMax(fLAYER,fSTACK,fSM);
571 fColMax = fGeo->GetColMax(fROC);
572
573 fMCMHctr2 = 0;
574 fHCdataCtr = 0;
575
576 fChamberDone[fDET]++;
577 fNextStatus = kNextMCM;
578 AliDebug(3, "Decode HC OK");
579 continue;
580 } //HC header
581 else
582 {
583 AliDebug(3, "Decode HC NOT OK");
584 fNextStatus = kNextSM;
585 continue;
586 }
587 } // if decode HC
588
589 if (fNextStatus == kNextSM)
590 {
591
592 fDET = 0;
593 fRetVal = 0;
594 fEqID = 0;
595 fDataSize = 0;
596 fSizeOK = kFALSE;
597
598 // After reading the first word check for size of this data and get Eq. ID
599 if ( fWordCtr == 1 )
600 {
601 fDataSize = fRawReader->GetDataSize()/4; // Size of this payload in 32bit words
602 fEqID = fRawReader->GetEquipmentId(); // Get Equipment ID
603 if ( fDataSize > 0 ) fSizeOK = kTRUE;
604 }
605
606 // GTU Link Mask?
607 if ( (*fDataWord & 0xfffff000) == 0xe0000000 )
608 {
609 DecodeGTUlinkMask();
610 fNextStatus = kNextHC;
611 continue;
612 }
613 else
614 {
615 AliWarning(Form("Equipment %d: First data word is not GTU Link Mask!", fEqID));
616 fRawReader->AddMajorErrorLog(kGTULinkMaskMissing,Form("Equipment %d",fEqID));
617 fNextStatus = kStop;
618 }
619 }// if nextSM
620
621 } // not kStop
622
623 AliDebug(1, Form("That's all folks! %d", fSM));
624 return kFALSE;
625}
626
627//____________________________________________________________________________
628Int_t AliTRDrawOldStream::NextChamber(AliTRDdigitsManager *man, UInt_t** /*trackletContainer*/)
629{
630 //
631 // Updates the next data word pointer
632 //
633
634 AliTRDarrayADC *digits = 0;
635 AliTRDarrayDictionary *track0 = 0;
636 AliTRDarrayDictionary *track1 = 0;
637 AliTRDarrayDictionary *track2 = 0;
638 AliTRDSignalIndex *indexes = 0;
639
640 if (fNextStatus == kStart)
641 {
642 Init();
643 }
644
645 while (fNextStatus != kStop)
646 { // !kStop
647 NextData();
648 if (fNextStatus == kNextMCM || fNextStatus == kNextData)
649 //while (fNextStatus == kNextMCM || fNextStatus == kNextData)
650 {
651 fHCdataCtr += 4;
652
653 if( ((*fDataWord & 0x80000000) == 0x0) && ((*fDataWord & 0x0000000f) == 0xC) )
654 { // MCM Header
655 DecodeMCMheader();
656 if ( fMCM < 0 || fMCM > 15 || fROB < 0 || fROB > 7 )
657 {
658 AliWarning("Wrong fMCM or fROB. Skip this data");
659 fRawReader->AddMajorErrorLog(kWrongMCMorROB,Form("MCM=%d, ROB=%d",fMCM,fROB));
660 fNextStatus = kNextHC;
661 continue;
662 }
663 fTbSwitch = 3; // For first adc channel we expect: (*fDataWord & 3) = 3
664 fTbSwitchCtr = 0; //
665 fADC = fTB = 0; // Reset Counter
666 fNextStatus = kNextData;
667
668// NextData(); // if while loop!
669 continue; // if if
670 }
671
672 if ( *fDataWord == kEndofrawdatamarker )
673 { // End of half-chamber data, finished
674 fGTUctr1 = -1;
675 fNextStatus = kNextHC;
676 // full chamber processed ?
677 if (fChamberDone[fDET] == 2)
678 {
679 return fDET;
680 }
681 else
682 {
683// break; // if while loop
684 continue; // if if
685 }
686 }
687
688 if (fNextStatus == kNextData )
689 { // MCM header is set, ADC data is valid.
690
691 // Found some data. Decode it now:
692 fRetVal = DecodeDataWord();
693 if ( fRetVal == 0 ) continue;
694 if ( fRetVal == -1 )
695 {
696 fNextStatus = kNextHC;
697
698// NextData(); // if while loop!
699// break; //if while loop!
700 continue;// if if
701 }
702
703 if ( fRetVal == 1)
704 {
705 { // A real pad
706 // here fill the data arrays
707 //return kTRUE;
708 for (Int_t it = 0; it < 3; it++)
709 {
710 if ( GetTimeBin() + it < GetNumberOfTimeBins() )
711 {
712 if (GetSignals()[it] > 0)
713 {
714 digits->SetData(fROW, fCOL, fTB + it, fSig[it]);
715 indexes->AddIndexRC(fROW, fCOL);
716 if (man->UsesDictionaries())
717 {
718 track0->SetData(fROW, fCOL, fTB + it, 0);
719 track1->SetData(fROW, fCOL, fTB + it, 0);
720 track2->SetData(fROW, fCOL, fTB + it, 0);
721 }
722 }
723 } // check the tbins range
724 } // for each tbin of current 3
725 fTB += 3;
726 }// real pad
727 } // if fRetVal == 1
728
729 // following ifs have been moved to DEcodeDatawordV1V2
730// if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax()-1 )
731// {
732// // Write Digits
733// if ( fCOL >= 0 && fCOL < fColMax && fROW >= 0 && fROW < fRowMax )
734// { // A real pad
735// fTB += 3;
736// return kTRUE;
737// }
738// }
739// else
740// {
741// fCOL = -1;
742// }
743 }// kNextData
744
745// NextData(); // if while loop!
746 continue; //if if
747 } //next mcm
748
749 if ( fNextStatus == kNextHC )
750 {
751 //
752 // 1) Find end_of_tracklet_marker
753 //
754 // GTU Link Mask?
755 if ( (*fDataWord & 0xfffff000) == 0xe0000000 )
756 {
757 DecodeGTUlinkMask();
758 continue;
759 }
760
761 // endoftrackletmarker?
762 if ( *fDataWord == kEndoftrackletmarker )
763 {
764 AliDebug(3, "end-of-tracklet-marker found");
765 fNextStatus = kSeekNonEoTracklet;
766 continue;
767 }
768 else
769 {
770 // Tracklets found
771 AliDebug(3, "Tracklet found");
772 DecodeTracklet();
773 continue;
774 }
775 } //if next HC
776
777 if (fNextStatus == kSeekNonEoTracklet)
778 {
779 //
780 // 2) Look for non-end_of_tracklet_marker
781 //
782 //printf("Word %d: 0x%08x\n", fWordCtr, *fDataWord);
783
784 if ( *fDataWord != kEndoftrackletmarker )
785 {
786 fNextStatus = kDecodeHC;
787 AliDebug(3, "NON end-of-tracklet-marker found");
788 //// no do not continue - this should be the hcheader
789 }
790 else
791 {
792 //just go on and find the non-end_of_tracklet_marker
793 continue;
794 }
795 }
796
797 if ( fNextStatus == kDecodeHC )
798 {
799 AliDebug(3, "Decode HC");
800
801 //
802 // 3) This Word must be Half Chamber Header
803 //
804 if ( (*fDataWord & 0x00000003) == 1 )
805 { // HC header
806 DecodeHCheader(fTimeBinsCalib); // This is the new header!
807 fDET = fGeo->GetDetector(fLAYER, fSTACK, fSM);
808 fRowMax = fGeo->GetRowMax(fLAYER,fSTACK,fSM);
809 fColMax = fGeo->GetColMax(fROC);
810
811 if (fLastDET != fDET)
812 {
813 AliDebug(4, "New DET!");
814 // allocate stuff for the new det
815 //man->ResetArrays();
816 digits = (AliTRDarrayADC *) man->GetDigits(fDET);
817 track0 = (AliTRDarrayDictionary *) man->GetDictionary(fDET,0);
818 track1 = (AliTRDarrayDictionary *) man->GetDictionary(fDET,1);
819 track2 = (AliTRDarrayDictionary *) man->GetDictionary(fDET,2);
820
821 // Allocate memory space for the digits buffer
822 if (digits->GetNtime() == 0)
823 {
824 AliDebug(4, "Allocating digits");
825 //AliDebug(5, Form("Alloc digits for det %d", det));
826 digits->Allocate(fRowMax, fColMax, fTBins);
827 if (man->UsesDictionaries())
828 {
829 track0->Allocate(fRowMax, fColMax, fTBins);
830 track1->Allocate(fRowMax, fColMax, fTBins);
831 track2->Allocate(fRowMax, fColMax, fTBins);
832 }
833 }
834
835 indexes = man->GetIndexes(fDET);
836 indexes->SetSM(fSM);
837 indexes->SetStack(fSTACK);
838 indexes->SetLayer(fLAYER);
839 indexes->SetDetNumber(fDET);
840
841 if (indexes->IsAllocated() == kFALSE)
842 {
843 AliDebug(4, "Allocating indexes");
844 indexes->Allocate(fRowMax, fColMax, fTBins);
845 }
846 fLastDET = fDET;
847 }
848
849 fMCMHctr2 = 0;
850 fHCdataCtr = 0;
851
852 fChamberDone[fDET]++;
853 fNextStatus = kNextMCM;
854 AliDebug(3, "Decode HC OK");
855 continue;
856 } //HC header
857 else
858 {
859 AliDebug(3, "Decode HC NOT OK");
860 fNextStatus = kNextSM;
861 continue;
862 }
863 } // if decode HC
864
865 if (fNextStatus == kNextSM)
866 {
867
868 fDET = 0;
869 fRetVal = 0;
870 fEqID = 0;
871 fDataSize = 0;
872 fSizeOK = kFALSE;
873
874 // After reading the first word check for size of this data and get Eq. ID
875 if ( fWordCtr == 1 )
876 {
877 fDataSize = fRawReader->GetDataSize()/4; // Size of this payload in 32bit words
878 fEqID = fRawReader->GetEquipmentId(); // Get Equipment ID
879 if ( fDataSize > 0 ) fSizeOK = kTRUE;
880 }
881
882 // GTU Link Mask?
883 if ( (*fDataWord & 0xfffff000) == 0xe0000000 )
884 {
885 DecodeGTUlinkMask();
886 fNextStatus = kNextHC;
887 continue;
888 }
889 else
890 {
891 AliWarning(Form("Equipment %d: First data word is not GTU Link Mask!", fEqID));
892 fRawReader->AddMajorErrorLog(kGTULinkMaskMissing,Form("Equipment %d",fEqID));
893 fNextStatus = kStop;
894 }
895 }// if nextSM
896
897 } // not kStop
898
899 AliDebug(1, Form("That's all folks! %d", fSM));
900 //return kFALSE;
901 return -1;
902}
903
904//============================================================================
905// Decoding functions
906//============================================================================
907
908
909//____________________________________________________________________________
910void AliTRDrawOldStream::DecodeHCheader(Int_t timeBins)
911{
912 //
913 // Decode the HC header (fRawVersion == 2, 3, 4, ???)
914 //
915
916 fRVmajor = (*fDataWord >> 24) & 0x7f;
917 fRVminor = (*fDataWord >> 17) & 0x7f;
918
919 if (fRVmajor < 2 || fRVmajor > 4)
920 AliError(Form(" Unsupported raw version: %d", fRawVersion))
921
922 if ( fRawVersion != fRVmajor ) {
923
924 AliWarning("===============================================================================");
925 AliWarning(Form("Mismatch between fRawVersion (%d) and fRVmajor from HC header (%d)"
926 ,fRawVersion,fRVmajor));
927 AliWarning(Form("Setting fRawVersion to %d", fRVmajor));
928 AliWarning("===============================================================================");
929 fRawVersion = fRVmajor;
930
931 }
932
933 //
934 // check for zero suppression
935 if ( fRawVersion >= 3 || fRawVersion <= 4 ) fZeroSuppressed = kTRUE;
936 else fZeroSuppressed = kFALSE;
937
938 // 1st word (h[0])
939 if ( (*fDataWord & 0x3) == 1 ) {
940
941 fHCHWords = (*fDataWord >> 14) & 0x7;
942 fSM = (*fDataWord >> 9) & 0x1f;
943 fLAYER = (*fDataWord >> 6) & 0x7;
944 fSTACK = (*fDataWord >> 3) & 0x7;
945 fSIDE = (*fDataWord >> 2) & 0x1;
946
947 fROC = fGeo->GetDetectorSec(fLAYER, fSTACK);
948
949 AliDebug(3, Form("0x%08x: HC header: sm=%d; roc=%d; side=%x", *fDataWord, fSM, fROC, fSIDE+10));
950
951 if ((fSM < 0) ||
952 (fSM > 17) ||
953 (fLAYER < 0) ||
954 (fLAYER > 5) ||
955 (fSTACK < 0) ||
956 (fSTACK > 4) ||
957 (fSIDE < 0) ||
958 (fSIDE > 1)) {
959 AliWarning(Form("0x%08x: Strange HC header: dcs=%d; sm=%d; layer=%d; stack=%d.",
960 *fDataWord, fDCS, fSM, fLAYER, fSTACK));
961 fRawReader->AddMajorErrorLog(kHCHeaderCorrupt,Form("0x%08x:dcs=%d; sm=%d; layer=%d; stack=%d.",
962 *fDataWord, fDCS, fSM, fLAYER, fSTACK));
963 }
964 else {
965 fHCHctr1++;
966 fHCHctr2++;
967 }
968 }
969 else {
970 AliWarning(Form("0x%08x: No HC header when it was expected.", *fDataWord));
971 fRawReader->AddMajorErrorLog(kHCHeaderMissing,Form("0x%08x", *fDataWord));
972 }
973
974 // 2nd word (h[1])
975 if ( fHCHWords >= 1 ) {
976 // read one more word
977 if (NextData() != kWordOK)
978 {
979 AliWarning("Next HC word missing");
980 fRawReader->AddMajorErrorLog(kHCWordMissing,"Next HC word missing");
981 fNextStatus = kNextHC;
982 return;
983 }
984 if ( (*fDataWord & 0x3) == 1 ) {
985
986 fBCctr = (*fDataWord >> 16);
987 fPTctr = (*fDataWord >> 12) & 0xf;
988 fPTphase = (*fDataWord >> 8) & 0xf;
989 fTBins = ((*fDataWord >> 2) & 0x3f) + 1;
990
991 AliDebug(3, Form("0x%08x: HC header 2: BCctr=%d PTctr=%d PTph=%d TB=%d"
992 , *fDataWord, fBCctr, fPTctr, fPTphase, fTBins));
993
994 if( fTBins != timeBins ) {
995
996 AliWarning("===============================================================================");
997 AliError(Form("Mismatch between nNTB from CDB (%d) and from HC header (%d)"
998 , timeBins, fTBins));
999 AliWarning(Form("We will use the value from the raw data (HC header): %d", fTBins));
1000 AliWarning("===============================================================================");
1001
1002 fTimeWords = (fTBins - 1)/3 + 1;
1003 }
1004
1005 }
1006
1007 }
1008
1009 // 3nd word (h[2])
1010 if ( fHCHWords >= 2 ) {
1011 // read one more word
1012 if (NextData() != kWordOK)
1013 {
1014 AliWarning("Next HC word missing");
1015 fRawReader->AddMajorErrorLog(kHCWordMissing,"Next HC word missing");
1016 fNextStatus = kNextHC;
1017 return;
1018 }
1019 if ( (*fDataWord & 0x3) == 1 ) {
1020
1021 fTCon = (*fDataWord >> 29) & 0x1;
1022 fPEDon = (*fDataWord >> 31) & 0x1;
1023 fGAINon = (*fDataWord >> 30) & 0x1;
1024 fXTon = (*fDataWord >> 28) & 0x1;
1025 fNonLinOn = (*fDataWord >> 27) & 0x1;
1026 fBypass = (*fDataWord >> 26) & 0x1;
1027
1028 fCommonAdditive = (*fDataWord >> 20) & 0x3f;
1029
1030 AliDebug(3, Form("0x%08x: HC header 3: TC=%d, PED=%d, GAIN=%d, XT=%d, NonLin=%d, Bypass=%d, Add=%d"
1031 , fTCon, fPEDon, fGAINon, fXTon, fNonLinOn, fBypass, fCommonAdditive));
1032 }
1033 }
1034
1035}
1036
1037//____________________________________________________________________________
1038void AliTRDrawOldStream::DecodeMCMheader()
1039{
1040
1041 //
1042 // Decode the MCM header
1043 //
1044
1045 if ( fRawVersion < 1 || fRawVersion > 3 )
1046 {
1047 AliError(Form(" Unsupported raw version: %d", fRawVersion));
1048 }
1049
1050 fMCM = (*fDataWord & 0xff000000) >> 24;
1051 fEv = (*fDataWord & 0x00fffff0) >> 4;
1052
1053 fROB = fMCM / 16;
1054 fMCM = fMCM % 16;
1055
1056 fROW = AliTRDfeeParam::Instance()->GetPadRowFromMCM(fROB, fMCM);
1057
1058 AliDebug(4, Form("0x%08x: SM%d L%dS%d. MCM Header: fROB=%d fMCM=%02d fEv=%02d"
1059 , *fDataWord, fSM, fLAYER, fSTACK, fROB, fMCM, fEv));
1060
1061 if ( fROB % 2 == 0 && fSIDE == 1 ) {
1062 AliWarning(Form("SM%d L%dS%d: Mismatch between fROB (%d) and fSIDE (%d): fMCM=%02d"
1063 , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
1064 fRawReader->AddMajorErrorLog(kROBSideMismatch,Form("SM%d L%dS%d: fROB (%d) fSIDE (%d): fMCM=%02d"
1065 , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
1066 }
1067 if ( fROB % 2 != 0 && fSIDE == 0 ) {
1068 AliWarning(Form("SM%d L%dS%d: Mismatch between fROB (%d) and fSIDE (%d): fMCM=%02d"
1069 , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
1070 fRawReader->AddMajorErrorLog(kROBSideMismatch,Form("SM%d L%dS%d: fROB (%d) fSIDE (%d): fMCM=%02d"
1071 , fSM, fLAYER, fSTACK, fROB, fSIDE, fMCM ));
1072 }
1073 if ( (fSTACK == 2 && fROW >= fGeo->RowmaxC0()) ||
1074 (fSTACK != 2 && fROW >= fGeo->RowmaxC1()) || fROW < 0 ) {
1075 AliWarning(Form("SM%d L%dS%d: Wrong Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d"
1076 , fSM, fLAYER, fSTACK, fROW, fROB, fSIDE, fMCM ));
1077 fRawReader->AddMajorErrorLog(kWrongPadrow,Form("SM%d L%dS%d: Padrow (%d) fROB=%d, fSIDE=%d, fMCM=%02d"
1078 , fSM, fLAYER, fSTACK, fROW, fROB, fSIDE, fMCM ));
1079 }
1080
1081 fMCMHctr1++;
1082 fMCMHctr2++;
1083
1084 // AdcMask for Zero supressed data
1085 if ( fRawVersion == 3 ) {
1086 // read one more word
1087 if (NextData() != kWordOK)
1088 {
1089 AliWarning("MCM ADC mask missing");
1090 fRawReader->AddMajorErrorLog(kMCMADCMaskMissing,"Missing");
1091 fNextStatus = kNextHC;
1092 return;
1093 }
1094 if ( (*fDataWord & 0x000007ff) == 0xC ) { // at the moment bits 4-10 are empty
1095
1096 for ( Int_t ctr = 0; ctr < fGeo->ADCmax(); ctr++ ) {
1097 if ( (*fDataWord >> (11+ctr)) == 0x1 ) fADCmask[ctr] = kTRUE;
1098 else fADCmask[ctr] = kFALSE;
1099 }
1100
1101 AliDebug(4, Form("0x%08x: ADC mask", *fDataWord));
1102
1103 }
1104 else {
1105 AliWarning("Expected ADC mask but did not find one!");
1106 fRawReader->AddMajorErrorLog(kMCMADCMaskMissing,"Decode error");
1107 }
1108
1109 }
1110
1111}
1112
1113//____________________________________________________________________________
1114void AliTRDrawOldStream::DecodeTracklet()
1115{
1116
1117 //
1118 // Decode the Tracklet
1119 //
1120 // this function is not tested yet on real tracklets
1121 //
1122
1123 if ( fRawVersion < 1 || fRawVersion > 3 )
1124 {
1125 AliError(Form(" Unsupported raw version: %d", fRawVersion));
1126 }
1127
1128 fTracklPID = (*fDataWord >> 24) & 0xff;
1129 fTracklPadRow = (*fDataWord >> 20) & 0xf; // 0:15
1130 fTracklDefL = (*fDataWord >> 13) & 0x7f;
1131 fTracklPadPos = (*fDataWord) & 0x1fff;
1132
1133 fTracklPID /= (Float_t)((1<<8) - 1); // 0:1 (steps of 0.39%)
1134 fTracklDefL = (fTracklDefL - ((1<< 7)-1)/2.) * 140.e-4; // -0.889:0.889cm
1135 fTracklPadPos = (fTracklPadPos - ((1<<13)-1)/2.) * 160.e-4; // -65.528:65.528 cm
1136
1137 //AliDebug(4, Form("0x%08x: Tracklet found: SM%d L%dS%d side %x: PadRow=%d PadPos=%f DefL=%f PID=%f"
1138 // , *fDataWord, fSM, fLAYER, fSTACK, fSIDE+10
1139 // , fTracklPadRow, fTracklPadPos, fTracklDefL, fTracklPID));
1140
1141 if( ((fSTACK == 2) && (fTracklPadRow >= (Int_t) fGeo->RowmaxC0())) ||
1142 ((fSTACK != 2) && (fTracklPadRow >= (Int_t) fGeo->RowmaxC1())) ) {
1143 AliWarning(Form("Strange Row read from Tracklet Word: %d", fTracklPadRow));
1144 fRawReader->AddMajorErrorLog(kTrackletRowMismatch,Form("Word: %d", fTracklPadRow));
1145 }
1146
1147}
1148
1149//____________________________________________________________________________
1150void AliTRDrawOldStream::DecodeGTUlinkMask()
1151{
1152
1153 //
1154 // Decode the link masks sent by the GTU. These marke the active optical links
1155 // between GTU and Super Module. Up to now only fully active links are found
1156 // (0xfff = 12 active links).
1157 //
1158
1159 if ( fRawVersion < 1 || fRawVersion > 3 )
1160 {
1161 AliError(Form(" Unsupported raw version: %d", fRawVersion));
1162 }
1163
1164 if ( fGTUctr1 == -1 ) fGTUctr2++;
1165 fGTUctr1++;
1166
1167 if ( (fGTUctr1 >= 0) && (fGTUctr1 < 5) && (fGTUctr2 >= 0) && (fGTUctr2 < 18) ) {
1168 fGTUlinkMask[fGTUctr2][fGTUctr1] = (*fDataWord & 0xfff);
1169 }
1170
1171}
1172
1173//____________________________________________________________________________
1174Int_t AliTRDrawOldStream::DecodeDataWord()
1175{
1176
1177 //
1178 // Decode the Data
1179 //
1180
1181 if ( fRawVersion >= 1 && fRawVersion <= 2 ) {
1182 return DecodeDataWordV1V2();
1183 }
1184 else if ( fRawVersion >= 3 && fRawVersion <= 3 ) {
1185 return DecodeDataWordV3();
1186 }
1187
1188 AliError(Form(" Unsupported raw version: %d", fRawVersion));
1189 return -1;
1190
1191}
1192
1193//____________________________________________________________________________
1194Int_t AliTRDrawOldStream::DecodeDataWordV1V2()
1195{
1196
1197 //
1198 // Decode the Data (full raw data. No zero suppression. 21 adc channels)
1199 //
1200 // return 0 means continue to next data word
1201 // return -1 means break data loop
1202 //
1203
1204// // check the content first! - something wrong with that...
1205// // Decode 32 bit data words with information from 3 time bins and copy the data
1206// fSig[0] = (*fDataWord & 0x00000ffc) >> 2;
1207// fSig[1] = (*fDataWord & 0x003ff000) >> 12;
1208// fSig[2] = (*fDataWord & 0xffc00000) >> 22;
1209// if (fSig[0] <= 0 && fSig[1] <= 0 && fSig[2] <= 0)
1210// return 0;
1211
1212 if ( (*fDataWord & 0x00000003) != 0x2 && (*fDataWord & 0x00000003) != 0x3) {
1213 //AliWarning(Form("Data %08x : Data Word ends neither with b11 nor b10", (Int_t)*fDataWord));
1214 fRawReader->AddMinorErrorLog(kDataMaskError,Form("Data %08x", (Int_t)*fDataWord));
1215 return -1;
1216 }
1217
1218 if ( (*fDataWord & 0x00000003) != fTbSwitch ) { // Next ADC channel found
1219 fTbSwitch = (fTbSwitch & 2) | !(fTbSwitch & 1); // 0x3 <--> 0x2
1220 fTbSwitchCtr = 0;
1221 fADC++;
1222 fTB=0;
1223 }
1224
1225 fTbSwitchCtr++; // Just read one word
1226
1227 // We have only timeTotal time bins
1228 if ( fTbSwitchCtr > fTimeWords ) {
1229 //AliWarning(Form("Data is strange. Already found %d words for this ADC channel", (Int_t)fTbSwitchCtr));
1230 fRawReader->AddMinorErrorLog(kADCNumberOverflow,Form("%d words", (Int_t)fTbSwitchCtr));
1231 return 0;
1232 }
1233
1234 // We have only 21 ADC channels.
1235 if ( fADC > (Int_t)fGeo->ADCmax()-1 ) {
1236 //AliWarning(Form("Data %08x : Data is strange. fADC is already %d", (Int_t)*fDataWord, (Int_t)fADC));
1237 fRawReader->AddMinorErrorLog(kADCChannelOverflow,Form("Data %08x : fADC=%d", (Int_t)*fDataWord, (Int_t)fADC));
1238 return 0;
1239 }
1240
1241 // There are 18 pads connected to each MCM ADC channels 2...19. The other channels cross to other
1242 // MCMs and are good for online tracking in the MCM.
1243 if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax()-1 ) {
1244
1245 // Get Pad column
1246 fCOL = AliTRDfeeParam::Instance()->GetPadColFromADC(fROB, fMCM, fADC);
1247
1248 // We have only 144 Pad Columns
1249 //if ( fCOL > fColMax-1 || fCOL < 0 ) {
1250 if ( fCOL >= 0 && fCOL < fColMax && fROW >= 0 && fROW < fRowMax )
1251 {
1252 // Decode 32 bit data words with information from 3 time bins and copy the data
1253 fSig[0] = (*fDataWord & 0x00000ffc) >> 2;
1254 fSig[1] = (*fDataWord & 0x003ff000) >> 12;
1255 fSig[2] = (*fDataWord & 0xffc00000) >> 22;
1256
1257 if (fSig[0] > 0 || fSig[1] > 0 || fSig[2] > 0)
1258 return 1;
1259 else
1260 return 0;
1261 }
1262 else
1263 {
1264// AliWarning(Form("SM%d L%dS%d: Wrong Pad column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM,
1265// fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM ));
1266 fRawReader->AddMajorErrorLog(kWrongPadcolumn,Form("SM%d L%dS%d: column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM,
1267 fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM ));
1268 return 0;
1269 }
1270 // Print data to screen:
1271 // Do NOT switch on for default production, it is VERY slow
1272 // AliDebug(5, Form("SM%d L%dS%d: ROB%d MCM=%d ADC=%d (ROW=%d COL=%d): Data %04d %04d %04d\n",
1273 // fSM, fLAYER, fSTACK, fROB, fMCM, fADC, fROW, fCOL, fSig[0], fSig[1], fSig[2]));
1274
1275 }
1276 else {
1277
1278 fCOL = -1;
1279 return 0;
1280 }
1281
1282 return 1;
1283
1284}
1285
1286//____________________________________________________________________________
1287Int_t AliTRDrawOldStream::DecodeDataWordV3()
1288{
1289
1290 //
1291 // Decode the data (Zero suppresses data. 21 adc channels)
1292 //
1293 // return 0 means continue to next data word
1294 // return -1 means break data loop
1295 //
1296 // NOT TESTED YET!!!!!!!!
1297 //
1298
1299 if ( (*fDataWord & 0x00000003) != 0x2 && (*fDataWord & 0x00000003) != 0x3) {
1300 AliWarning(Form("Data %08x : Data Word ends neither with b11 nor b10", (Int_t)*fDataWord));
1301 fRawReader->AddMinorErrorLog(kDataMaskError,Form("Data %08x", (Int_t)*fDataWord));
1302 return -1;
1303 }
1304
1305 if ( (*fDataWord & 0x00000003) != fTbSwitch ) { // Next ADC channel found
1306 fTbSwitch = (fTbSwitch & 2) | !(fTbSwitch & 1); // 0x3 <--> 0x2
1307 fTbSwitchCtr = 0;
1308 //
1309 // Jump to next ADC channel that is not masked
1310 do {
1311 fADC++;
1312 } while ( ((fADC < fGeo->ADCmax()) && (fADCmask[fADC] == kFALSE)) || (fADC >= fGeo->ADCmax()) );
1313 fTB=0;
1314 }
1315
1316 fTbSwitchCtr++; // Just read one word
1317
1318 // We have only timeTotal time bins
1319 if ( fTbSwitchCtr > fTimeWords ) {
1320 AliWarning(Form("Data is strange. Already found %d words for this ADC channel", (Int_t)fTbSwitchCtr));
1321 fRawReader->AddMinorErrorLog(kADCNumberOverflow,Form("%d words", (Int_t)fTbSwitchCtr));
1322 return 0;
1323 }
1324
1325 // We have only 21 ADC channels.
1326 if ( fADC > (Int_t)fGeo->ADCmax()-1 ) {
1327 AliWarning(Form("Data %08x : Data is strange. fADC is already %d", (Int_t)*fDataWord, (Int_t)fADC));
1328 fRawReader->AddMinorErrorLog(kADCChannelOverflow,Form("Data %08x : fADC=%d", (Int_t)*fDataWord, (Int_t)fADC));
1329 return 0;
1330 }
1331
1332 // There are 18 pads connected to each MCM ADC channels 2...19. The other channels cross to other
1333 // MCMs and are good for online tracking in the MCM.
1334 if ( fADC > 1 && fADC < (Int_t)fGeo->ADCmax()-1 ) {
1335
1336 // Get Pad column
1337 //fCOL = fGeo->GetPadColFromADC(fROB, fMCM, fADC);
1338 fCOL = AliTRDfeeParam::Instance()->GetPadColFromADC(fROB, fMCM, fADC);
1339
1340 // We have only 144 Pad Columns
1341 if ( fCOL > fColMax-1 || fCOL < 0 ) {
1342 AliWarning(Form("SM%d L%dS%d: Wrong Pad column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM,
1343 fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM ));
1344 fRawReader->AddMajorErrorLog(kWrongPadcolumn,Form("SM%d L%dS%d: column (%d) fROB=%d, fSIDE=%d, fMCM=%02d", fSM,
1345 fLAYER, fSTACK, fCOL, fROB, fSIDE, fMCM ));
1346 }
1347
1348 // Decode 32 bit data words with information from 3 time bins and copy the data
1349 fSig[0] = (*fDataWord & 0x00000ffc) >> 2;
1350 fSig[1] = (*fDataWord & 0x003ff000) >> 12;
1351 fSig[2] = (*fDataWord & 0xffc00000) >> 22;
1352
1353 // Print data to screen:
1354 AliDebug(5, Form("SM%d L%dS%d: ROB%d MCM=%d ADC=%d (ROW=%d COL=%d): Data %04d %04d %04d\n",
1355 fSM, fLAYER, fSTACK, fROB, fMCM, fADC, fROW, fCOL, fSig[0], fSig[1], fSig[2]));
1356
1357 }
1358 else {
1359
1360 fCOL = -1;
1361
1362 }
1363
1364 return 1;
1365
1366}