1 /**************************************************************************
\r
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
\r
4 * Author: The ALICE Off-line Project. *
\r
5 * Contributors are mentioned in the code where appropriate. *
\r
7 * Permission to use, copy, modify and distribute this software and its *
\r
8 * documentation strictly for non-commercial purposes is hereby granted *
\r
9 * without fee, provided that the above copyright notice appears in all *
\r
10 * copies and that both the copyright notice and this permission notice *
\r
11 * appear in the supporting documentation. The authors make no claims *
\r
12 * about the suitability of this software for any purpose. It is *
\r
13 * provided "as is" without express or implied warranty. *
\r
14 **************************************************************************/
\r
16 /* $Id: AliTRDrawFastStream.cxx 27797 2008-08-05 14:37:22Z cblume $ */
\r
18 ////////////////////////////////////////////////////////////////////////////////
\r
20 // This class provides access to TRD digits in raw data in a way of streaming //
\r
22 // It loops over all TRD digits in the raw data given by the AliRawReader. //
\r
23 // The Next method goes to the next digit. If there are no digits left //
\r
24 // it returns kFALSE. //
\r
25 // Several getters provide information about the current digit. //
\r
27 // Author: M. Ploskon (ploskon@ikf.uni-frankfurt.de) //
\r
28 // Author: MinJung Kweon (minjung@physi.uni-heidelberg.de) //
\r
30 ////////////////////////////////////////////////////////////////////////////////
\r
34 #include "AliTRDrawFastStream.h"
\r
35 #include "AliTRDgeometry.h"
\r
36 #include "AliTRDfeeParam.h"
\r
37 #include "AliTRDdigitsManager.h"
\r
38 #include "AliTRDarrayDictionary.h"
\r
39 #include "AliTRDarrayADC.h"
\r
40 #include "AliTRDSignalIndex.h"
\r
41 #include "AliTRDdigitsParam.h"
\r
43 #include "AliRawReader.h"
\r
45 #define END_OF_TRACKLET_MARKEROLD 0xaaaaaaaa
\r
46 #define END_OF_TRACKLET_MARKERNEW 0x10001000
\r
47 #define ENDOFRAWDATAMARKER 0x00000000
\r
48 #define WORD_SIZE sizeof(UInt_t) // size of a word in bytes
\r
49 #define EXTRA_LEAD_WORDS 24
\r
52 #define IS_BIT_SET(w,b) ( ((w) >> (b)) & 0x1 ) // 1 if bit b is set in word w
\r
53 #define GET_VALUE_AT(w,m,s) (( (w) >> (s)) & (m) ) // get value of word w rshifted by s and mask with m
\r
55 // SM index word masks:
\r
56 #define SM_HEADER_SIZE(w) GET_VALUE_AT(w,0xffff,16)
\r
57 #define TRACKLETS_ENABLED(w) IS_BIT_SET(w,5)
\r
58 #define STACK_MASK(w) ((w) & 0x1f)
\r
61 #define STACK_HEADER_SIZE(w) GET_VALUE_AT(w,0xffff,16)
\r
62 #define STACK_LINK_WORD(w) ((w) & 0xfff)
\r
63 #define LINK0_DATA_TYPE_FLAG(w) (GET_VALUE_AT(w,0x3,4) == (0x0) ? 0 : 1) // 0 if physics data
\r
64 #define LINK1_DATA_TYPE_FLAG(w) (GET_VALUE_AT(w,0x3,20) == (0x0) ? 0 : 1) // 0 if physics data
\r
65 #define LINK0_MONITOR_FLAG(w) (GET_VALUE_AT(w,0xf,0) == (0x0) ? 0 : 1) // 0 if OK
\r
66 #define LINK1_MONITOR_FLAG(w) (GET_VALUE_AT(w,0xf,16) == (0x0) ? 0 : 1) // 0 if OK
\r
69 //#define HC_HEADER_MASK_ERR(w) ( ((w) & (0x80000003)) == (0x80000001) ? 0 : 1) // 0 if OK!!!
\r
70 #define HC_HEADER_MASK_ERR(w) ( ((w) & (0x3)) == (0x1) ? 0 : 1) // 0 if OK!!!
\r
73 #define HC_SPECIAL_RAW_VERSION(w) IS_BIT_SET(w,31)
\r
74 #define HC_MAJOR_RAW_VERSION(w) GET_VALUE_AT(w,0x7f,24)
\r
75 #define HC_MAJOR_RAW_VERSION_OPT(w) GET_VALUE_AT(w,0x7,24)
\r
76 #define HC_MINOR_RAW_VERSION(w) GET_VALUE_AT(w,0x7f,17)
\r
77 #define HC_EXTRA_WORDS(w) GET_VALUE_AT(w,0x7,14)
\r
78 #define HC_DCS_BOARD(w) GET_VALUE_AT(w,0xfff<<20,20)
\r
79 #define HC_SM_NUMBER(w) GET_VALUE_AT(w,0x1f,9)
\r
80 #define HC_LAYER_NUMBER(w) GET_VALUE_AT(w,0x7,6)
\r
81 #define HC_STACK_NUMBER(w) GET_VALUE_AT(w,0x7,3)
\r
82 #define HC_SIDE_NUMBER(w) IS_BIT_SET(w,2)
\r
85 #define HC_NTIMEBINS(w) GET_VALUE_AT(w,0x3f,26)
\r
86 #define HC_BUNCH_CROSS_COUNTER(w) GET_VALUE_AT(w,0xffff,10)
\r
87 #define HC_PRETRIGGER_COUNTER(w) GET_VALUE_AT(w,0xf,6)
\r
88 #define HC_PRETRIGGER_PHASE(w) GET_VALUE_AT(w,0xf,2)
\r
90 // MCM word and ADC mask
\r
91 #define MCM_HEADER_MASK_ERR(w) ( ((w) & (0xf)) == (0xc) ? 0 : 1) // 0 if OK!!!
\r
92 #define MCM_ADCMASK_MASK_ERR(w) ( ((w) & (0xf)) == (0xc) ? 0 : 1) // 0 if OK!!!
\r
93 #define MCM_MCM_NUMBER(w) GET_VALUE_AT(w,0x0f,24)
\r
94 #define MCM_ROB_NUMBER(w) GET_VALUE_AT(w,0x7,28)
\r
95 #define MCM_EVENT_COUNTER(w) GET_VALUE_AT(w,0x00fffff,4)
\r
96 #define MCM_ADCMASK_VAL(w) GET_VALUE_AT(w,0x1fffff,4)
\r
97 #define MCM_ADCMASK_NADC(w) GET_VALUE_AT(w,0x1f,25)
\r
99 #define MCM_DUMMY_ADCMASK_VAL 0x015fffffc // updated
\r
100 #define ADCDATA_VAL1 0x2 // updated
\r
101 #define ADCDATA_VAL2 0x3 // updated
\r
103 //--------------------------------------------------------
\r
104 #define ADC_WORD_MASK(w) ((w) & 0x3)
\r
105 //--------------------------------------------------------
\r
106 ClassImp(AliTRDrawFastStream)
\r
108 Bool_t AliTRDrawFastStream::fgExtraSkip = kFALSE;
\r
109 Bool_t AliTRDrawFastStream::fgSkipCDH = kFALSE;
\r
110 Bool_t AliTRDrawFastStream::fgCleanDataOnly = kFALSE;
\r
111 Bool_t AliTRDrawFastStream::fgDebugFlag = kTRUE;
\r
112 Bool_t AliTRDrawFastStream::fgEnableMemoryReset = kTRUE;
\r
113 Bool_t AliTRDrawFastStream::fgStackNumberChecker = kTRUE;
\r
114 Bool_t AliTRDrawFastStream::fgStackLinkNumberChecker = kFALSE;
\r
115 Bool_t AliTRDrawFastStream::fgSkipData = kTRUE;
\r
116 Bool_t AliTRDrawFastStream::fgEnableDecodeConfigData = kFALSE;
\r
117 Int_t AliTRDrawFastStream::fgDumpHead = -1;
\r
118 Short_t AliTRDrawFastStream::fgMCMordering[] =
\r
120 12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3
\r
122 Short_t AliTRDrawFastStream::fgROBordering[] =
\r
127 Int_t AliTRDrawFastStream::fgLastHC = -1;
\r
128 Int_t AliTRDrawFastStream::fgLastROB = -1;
\r
129 Int_t AliTRDrawFastStream::fgLastIndex = -1;
\r
131 //--------------------------------------------------------
\r
132 AliTRDrawFastStream::AliTRDrawFastStream()
\r
133 : AliTRDrawStreamBase()
\r
144 , fGlobalNTimeBins(0)
\r
145 , fIsTimeBinSet(kFALSE)
\r
147 , fStackLinkNumber(-1)
\r
148 , fLinkTrackletCounter(-1)
\r
149 , fEndOfTrackletCount(-1)
\r
150 , fNWordsCounter(-1)
\r
154 , fLastEventCounter(0)
\r
155 , fSharedPadsOn(kTRUE)
\r
161 , fWarnError(kTRUE)
\r
162 , fWarnWarning(kFALSE)
\r
167 , fCommonAdditive(0)
\r
170 // default constructor
\r
173 if (Init() == kFALSE) {
\r
174 AliWarning("Unable to Init.");
\r
178 //--------------------------------------------------------
\r
179 AliTRDrawFastStream::AliTRDrawFastStream(AliRawReader *rawReader)
\r
180 : AliTRDrawStreamBase(rawReader)
\r
191 , fGlobalNTimeBins(0)
\r
192 , fIsTimeBinSet(kFALSE)
\r
194 , fStackLinkNumber(-1)
\r
195 , fLinkTrackletCounter(-1)
\r
196 , fEndOfTrackletCount(-1)
\r
197 , fNWordsCounter(-1)
\r
201 , fLastEventCounter(0)
\r
202 , fSharedPadsOn(kTRUE)
\r
208 , fWarnError(kTRUE)
\r
209 , fWarnWarning(kFALSE)
\r
212 , fRawReader(rawReader)
\r
214 , fCommonAdditive(0)
\r
217 // default constructor
\r
220 if (Init() == kFALSE) {
\r
221 AliWarning("Unable to Init. Try setting up the reader with SetReader or buffer with Init(void *, UInt_t )");
\r
225 AliWarning("Unable to setup reader. Use SetReader(AliRawReader*).");
\r
229 //------------------------------------------------------------
\r
230 AliTRDrawFastStream::AliTRDrawFastStream(const AliTRDrawFastStream& /*st*/)
\r
231 : AliTRDrawStreamBase()
\r
242 , fGlobalNTimeBins(0)
\r
243 , fIsTimeBinSet(kFALSE)
\r
245 , fStackLinkNumber(-1)
\r
246 , fLinkTrackletCounter(-1)
\r
247 , fEndOfTrackletCount(-1)
\r
248 , fNWordsCounter(-1)
\r
252 , fLastEventCounter(0)
\r
253 , fSharedPadsOn(kTRUE)
\r
259 , fWarnError(kTRUE)
\r
260 , fWarnWarning(kFALSE)
\r
265 , fCommonAdditive(0)
\r
268 // Copy constructor
\r
270 AliError("Not implemeneted.");
\r
273 //------------------------------------------------------------
\r
274 Bool_t AliTRDrawFastStream::SetRawVersion(Int_t fraw)
\r
277 // function provided for backward compatibility
\r
279 AliWarning("Raw data version is read from raw data stream! No point of setting it in here.");
\r
280 fraw = 0; // avoid warnings
\r
284 //------------------------------------------------------------
\r
285 AliTRDrawFastStream::~AliTRDrawFastStream()
\r
293 //------------------------------------------------------------
\r
295 AliTRDrawFastStream &
\r
296 AliTRDrawFastStream::operator=(const AliTRDrawFastStream &)
\r
299 // we are not using this functionality
\r
301 AliFatal("May not use.");
\r
305 //___________________________________________________________
\r
306 void AliTRDrawFastStream::SwapOnEndian()
\r
309 // Check the endian and swap if needed
\r
312 char* ptemp = (char*) &itemp;
\r
315 if (fgDebugFlag) AliDebug(8, "Swapping.");
\r
319 while (fpPos < fpEnd)
\r
322 iutmp = (((*fpPos & 0x000000ffU) << 24) | ((*fpPos & 0x0000ff00U) << 8) |
\r
323 ((*fpPos & 0x00ff0000U) >> 8) | ((*fpPos & 0xff000000U) >> 24));
\r
324 // here we override the value in the buffer!
\r
331 //------------------------------------------------------------
\r
332 Bool_t AliTRDrawFastStream::SkipWords(UInt_t iw)
\r
335 // Skip words corresponding to iw
\r
337 if ( fpPos + iw < fpEnd ) {
\r
342 if (fWarnWarning) AliWarning(Form("Skip %u words failed. %ld available", iw, fpEnd - fpPos - 1));
\r
349 //------------------------------------------------------------
\r
350 Bool_t AliTRDrawFastStream::SetReader(AliRawReader *reader)
\r
353 // set raw reader pointer
\r
356 fRawReader = reader;
\r
361 AliWarning("Unable to setup reader.");
\r
366 AliWarning("AliRawReader argument is 0.");
\r
373 //------------------------------------------------------------
\r
374 Int_t AliTRDrawFastStream::NextBuffer()
\r
377 // return -1 if no more buffers available
\r
378 // return 0 if SMHeader decoding failed
\r
379 // return 1 if SMHeader dedoding is OK
\r
381 if (fRawReader != 0) {
\r
382 UChar_t *buffer = 0;
\r
384 Bool_t kBufferSet = fRawReader->ReadNextData(buffer);
\r
385 if (kBufferSet == kTRUE) {
\r
386 if (fgDebugFlag) AliDebug(9, "Buffer is set.");
\r
387 length = fRawReader->GetDataSize();
\r
388 if (fgExtraSkip == kTRUE) {
\r
389 buffer += EXTRA_LEAD_WORDS * WORD_SIZE;
\r
390 length -= EXTRA_LEAD_WORDS * WORD_SIZE;
\r
393 if (fgSkipCDH == kTRUE) {
\r
394 buffer += CDH_WORDS * WORD_SIZE;
\r
395 length -= CDH_WORDS * WORD_SIZE;
\r
399 if (fgDebugFlag) AliDebug(9, Form("Buffer length : %d", length));
\r
400 if (fgEnableMemoryReset) ResetMemory();
\r
401 if (DecodeSMHeader((void*)buffer, length) == kTRUE)
\r
415 //------------------------------------------------------------
\r
416 void AliTRDrawFastStream::ResetCounters()
\r
419 // reset some global counters
\r
421 fBufferRead = kFALSE; // kFALSE if no buffer read
\r
423 fSM.fActiveStacks = 0;
\r
424 fSM.fNexpectedHalfChambers = 0;
\r
426 fLastEventCounter = 0;
\r
432 //------------------------------------------------------------
\r
433 void AliTRDrawFastStream::ResetIterators()
\r
436 // reset data which should be reset every sm
\r
439 fStackLinkNumber = 0;
\r
442 //------------------------------------------------------------
\r
443 void AliTRDrawFastStream::ResetPerSM()
\r
448 fSM.fHeaderSize = 0;
\r
449 fSM.fTrackletEnable = kFALSE;
\r
450 fSM.fCorrupted = 0;
\r
451 fSM.fNexpectedHalfChambers = 0;
\r
452 fSM.fNexpectedHalfChambers = 0;
\r
454 for (Int_t i=0; i<5; i++) {
\r
455 fSM.fStackActive[i] = kFALSE;
\r
459 //------------------------------------------------------------
\r
460 void AliTRDrawFastStream::ResetPerStack()
\r
463 // reset every Stack
\r
465 fStack->fHeaderSize = 0;
\r
466 fStack->fActiveLinks = 0;
\r
467 fStack->fPos = NULL;
\r
468 for (Int_t i=0; i<12; i++) {
\r
469 fStack->fLinksActive[i] = kFALSE;
\r
470 fStack->fLinksDataType[i] = 0;
\r
471 fStack->fLinksMonitor[i] = 0;
\r
472 fStack->fLinkMonitorError[i] = 0;
\r
476 //------------------------------------------------------------
\r
477 void AliTRDrawFastStream::ResetPerHC()
\r
483 fHC->fNTracklets = 0;
\r
484 fHC->fSpecialRawV = 0;
\r
485 fHC->fRawVMajor = 0;
\r
486 fHC->fRawVMajorOpt = 0;
\r
487 fHC->fRawVMinor = 0;
\r
488 fHC->fNExtraWords = 0;
\r
489 fHC->fDCSboard = 0;
\r
490 fHC->fTimeBins = 0;
\r
491 fHC->fBunchCrossCounter = 0;
\r
492 fHC->fPreTriggerCounter = 0;
\r
493 fHC->fPreTriggerPhase = 0;
\r
498 fHC->fStackHCheader = 0;
\r
500 fHC->fLayerHCheader = 0;
\r
502 fHC->fSideHCheader = 0;
\r
508 fHC->fH0Corrupted = 0;
\r
509 fHC->fH1Corrupted = 0;
\r
510 fHC->fCorrupted = 0;
\r
511 fHC->fEOTECorrupted = kFALSE;
\r
512 fHC->fBufferCorrupted = kFALSE;
\r
513 fHC->fDataCorrupted = kFALSE;
\r
516 memset(fHC->fErrorCodes, 0, 1411*sizeof(UShort_t)); // initialize error container
\r
517 memset(fHC->fTrackletWords, 0, MAXTRACKLETSPERHC*sizeof(UInt_t)); // initialize tracklet container
\r
520 //------------------------------------------------------------
\r
521 void AliTRDrawFastStream::ResetPerMCM()
\r
529 fMCM.fEvCounter = 0;
\r
531 fMCM.fADCMaskWord = 0;
\r
533 fMCM.fADCcount = 0;
\r
534 fMCM.fSingleADCwords = 0;
\r
535 fMCM.fMCMhdCorrupted = 0;
\r
536 fMCM.fADCmaskCorrupted = 0;
\r
537 fMCM.fDataCorrupted = kFALSE;
\r
539 fMCM.fAdcDataPos = NULL;
\r
540 fMCM.fADCcounter = 0;
\r
542 memset(fMCM.fADCchannel, 0, TRDMAXADC*sizeof(UInt_t));
\r
545 //------------------------------------------------------------
\r
546 void AliTRDrawFastStream::ResetMemory()
\r
549 // initialize all the data members to prevent read data
\r
550 // from previous buffer
\r
553 for (Int_t istack=0; istack<5; istack++) {
\r
554 fStack = &fSM.fStacks[istack];
\r
556 for (Int_t ilink=0; ilink<12; ilink++) {
\r
557 fHC = &fStack->fHalfChambers[ilink];
\r
563 //------------------------------------------------------------
\r
564 Bool_t AliTRDrawFastStream::Next()
\r
567 // returns with true on next adc read, returns false on errors and end of buffer
\r
570 while (fStackNumber < 5 && fSM.fActiveStacks > 0) {
\r
571 if (fSM.fStackActive[fStackNumber] == kTRUE) {
\r
572 fStack = &fSM.fStacks[fStackNumber];
\r
573 while (fStackLinkNumber < 12) {
\r
574 if (fStack->fLinksActive[fStackLinkNumber] == kTRUE) {
\r
575 //if (fStack->fLinksActive[fStackLinkNumber] == kTRUE && fStack->fLinksMonitor[fStackLinkNumber] == 0)
\r
576 fHC = &fStack->fHalfChambers[fStackLinkNumber];
\r
577 //ResetPerHC(); // [mj - you don't need to do? ]
\r
579 AliError(Form("HC missing at stack %d link %d", fStackNumber, fStackLinkNumber));
\r
582 fStackLinkNumber++;
\r
585 else fStackLinkNumber++;
\r
586 } //stack link number loop
\r
589 fStackLinkNumber = 0;
\r
590 } //stack number loop
\r
593 // go for the next buffer
\r
595 Int_t nextBuff = NextBuffer();
\r
596 while (nextBuff != -1) {
\r
597 if (nextBuff > 0) {
\r
598 fBufferRead = kTRUE;
\r
601 nextBuff = NextBuffer();
\r
608 //------------------------------------------------------------
\r
609 Int_t AliTRDrawFastStream::NextChamber(AliTRDdigitsManager *digitsManager, UInt_t **trackletContainer, UShort_t **errorCodeContainer)
\r
613 // Fills single chamber digit array
\r
614 // Return value is the detector number
\r
616 // first of all, you do the SM header decoding only at the beginning of the SM data reading
\r
617 // then, every HC, you call Next() which points next HC. then, there you decode the given HC
\r
618 // and at the same time, put the digit into digitmanager
\r
620 AliTRDarrayADC *digits = 0;
\r
621 AliTRDarrayDictionary *track0 = 0;
\r
622 AliTRDarrayDictionary *track1 = 0;
\r
623 AliTRDarrayDictionary *track2 = 0;
\r
624 AliTRDSignalIndex *indexes = 0;
\r
625 AliTRDdigitsParam *digitsparam = 0;
\r
627 Int_t lastdet = -1;
\r
631 Int_t ntracklets = 0;
\r
634 if (trackletContainer){
\r
635 for (Int_t i = 0; i < 2; i++)
\r
636 memset(trackletContainer[i], 0, MAXTRACKLETSPERHC*sizeof(UInt_t));
\r
639 if (errorCodeContainer){
\r
640 for (Int_t i = 0; i < 2; i++)
\r
641 memset(errorCodeContainer[i], 0, 1411*sizeof(UShort_t));
\r
644 while ( Next() ) { // loop over HC
\r
646 // get this information from the GTU header
\r
650 if (det != lastdet) {
\r
651 // If new detector found
\r
652 if (lastdet == -1) {lastdet = det; fLastHC = fHC;}
\r
653 else {fStackLinkNumber--; fHC = fLastHC ; return lastdet;}
\r
655 if (det < 0 || det >= AliTRDgeometry::kNdet) continue;
\r
657 // Add a container for the digits of this detector
\r
658 digits = (AliTRDarrayADC *) digitsManager->GetDigits(det);
\r
660 if (digitsManager->UsesDictionaries()) {
\r
661 track0 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,0);
\r
662 track1 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,1);
\r
663 track2 = (AliTRDarrayDictionary *) digitsManager->GetDictionary(det,2);
\r
666 if (!digits) return -1;
\r
668 //Int_t rowMax = GetRowMax();
\r
669 Int_t rowMax = fGeometry->RowmaxC1(); // we use maximum row number among all detectors to reuse memory
\r
670 Int_t colMax = GetColMax();
\r
671 Int_t ntbins = GetGlobalNTimeBins();
\r
673 // Set digitsparam variables
\r
674 digitsparam = (AliTRDdigitsParam *) digitsManager->GetDigitsParam();
\r
675 digitsparam->SetNTimeBins(det,ntbins);
\r
676 fCommonAdditive=10;
\r
677 digitsparam->SetADCbaseline(det,fCommonAdditive);
\r
679 // Allocate memory space for the digits buffer
\r
680 //if (digits->GetNtime() == 0) {
\r
681 if (ntbins != digits->GetNtime()) {
\r
682 digits->Allocate(rowMax, colMax, ntbins);
\r
683 if (digitsManager->UsesDictionaries()) {
\r
684 track0->Allocate(rowMax, colMax, ntbins);
\r
685 track1->Allocate(rowMax, colMax, ntbins);
\r
686 track2->Allocate(rowMax, colMax, ntbins);
\r
690 indexes = digitsManager->GetIndexes(det);
\r
691 indexes->SetSM(GetSM());
\r
692 indexes->SetStack(GetStack());
\r
693 indexes->SetLayer(GetLayer());
\r
694 indexes->SetDetNumber(det);
\r
695 if (indexes->GetNtime() != ntbins)
\r
696 indexes->Allocate(rowMax, colMax, ntbins);
\r
699 if (fSM.fTrackletEnable == kTRUE) {
\r
700 if (DecodeTracklets() == kFALSE) {
\r
703 if (fWarnWarning) AliWarning(Form("Tracklet decoding failed stack %d link %d", GetStack(), fStackLinkNumber));
\r
705 // copy error codes in memory into error container
\r
706 if (errorCodeContainer) {
\r
707 nErrors = GetNErrors();
\r
708 if(nErrors > 0) memcpy(errorCodeContainer[side], GetErrorCodes(), sizeof(UShort_t) * 1411); // [mj temp - optimize]
\r
711 continue; // if it fails to decode tracklets of this HC, it skips further decoding and goes to next HC
\r
716 fgLastROB = -1; // to check mcm number odering
\r
717 fgLastIndex = -1 ; // to check mcm number odering
\r
718 if (DecodeHC(digitsManager, digits, track0, track1, track2, indexes) == kFALSE) {
\r
719 // encode HC error code
\r
720 fHC->fErrorCodes[2] += fHC->fH0Corrupted;
\r
721 fHC->fErrorCodes[2] += (fHC->fH1Corrupted << 2);
\r
722 fHC->fErrorCodes[2] += (fHC->fCorrupted << 3);
\r
723 fHC->fErrorCodes[2] += ((fHC->fBufferCorrupted & 1) << 6);
\r
724 fHC->fErrorCodes[2] += ((fHC->fEOTECorrupted & 1) << 7);
\r
725 fHC->fErrorCodes[2] += ((fHC->fDataCorrupted & 1) << 8);
\r
727 if (fHC->fEOTECorrupted != kTRUE) SeekEndOfData();
\r
731 AliError(Form("Failed HC : %s", DumpHCinfoH0(fHC)));
\r
732 AliError(Form("Failed HC : %s", DumpHCinfoH1(fHC)));
\r
736 else SeekEndOfData(); // make sure that finish off with the end of data markers
\r
738 // set pretrigger phase since it is only avaliable after decoding HC header
\r
739 digitsparam->SetPretriggerPhase(det,GetPreTriggerPhase());
\r
741 // copy tracklets in memory into tracklet container
\r
742 if (trackletContainer) {
\r
743 ntracklets = GetNTracklets();
\r
744 // copy tracklet words to trackletContainer array
\r
745 if(ntracklets > 0) memcpy(trackletContainer[side], GetTrackletWords(), sizeof(UInt_t) * ntracklets);
\r
748 // copy error codes in memory into error container
\r
749 if (errorCodeContainer) {
\r
750 nErrors = GetNErrors();
\r
751 if(nErrors > 0) memcpy(errorCodeContainer[side], GetErrorCodes(), sizeof(UShort_t) * 1411);
\r
759 //------------------------------------------------------------
\r
760 Bool_t AliTRDrawFastStream::Init()
\r
763 // Initialize geometry and fee parameters
\r
765 TDirectory *saveDir = gDirectory;
\r
768 fGeometry = new AliTRDgeometry();
\r
772 AliError("Geometry FAILED!");
\r
776 fTRDfeeParam = AliTRDfeeParam::Instance();
\r
777 if (!fTRDfeeParam) {
\r
778 AliError("AliTRDfeeParam FAILED!");
\r
782 fMaxADCgeom = (Int_t)fGeometry->ADCmax();
\r
784 ResetCounters(); // fBufferRead is set to kFALSE - important
\r
791 //------------------------------------------------------------
\r
792 Bool_t AliTRDrawFastStream::InitBuffer(void *buffer, UInt_t length)
\r
795 // set initial information about the buffer
\r
797 if (fgDebugFlag) AliDebug(5, Form("Equipment ID: %d",fRawReader->GetEquipmentId()));
\r
798 if (fRawReader->GetEquipmentId()<1024 || fRawReader->GetEquipmentId()>1041)
\r
803 fpBegin = (UInt_t *)buffer;
\r
805 if (WORD_SIZE == 0) {
\r
806 AliFatal("Strange word size. size of UInt_t == 0");
\r
810 fWordLength = length/WORD_SIZE;
\r
811 fpEnd = fpBegin + fWordLength;
\r
814 if (fpBegin == 0 || length <= 0) {
\r
815 AliError(Form("Buffer size or pointer is strange. pointer to the buffer is 0x%p of size %u", fpBegin, length));
\r
821 if (fgDumpHead >= 0) {
\r
822 if ( fgDumpHead == 0 ) { // dump all words
\r
823 AliInfo(Form("---------- Dumping all words from the beginnig of the buffer ----------"));
\r
824 if (DumpWords(fpBegin, fWordLength) == kFALSE) AliError("Dump failed. Not enough data.");
\r
827 AliInfo(Form("---------- Dumping %u words from the beginnig of the buffer ----------",fgDumpHead));
\r
828 if (DumpWords(fpBegin, fgDumpHead) == kFALSE) AliError("Dump failed. Not enough data.");
\r
830 AliInfo(Form("---------- Dumping ended ----------------------------------------------"));
\r
836 //------------------------------------------------------------
\r
837 Bool_t AliTRDrawFastStream::DecodeSMHeader(void *buffer, UInt_t length)
\r
840 // decode one sm data in buffer
\r
844 if (InitBuffer(buffer, length) == kFALSE) {
\r
845 if (fWarnError) AliError("InitBuffer failed.");
\r
849 if (DecodeGTUheader()== kFALSE)
\r
852 Int_t nLinkErrors=0;
\r
853 for (Int_t istack = 0; istack < 5; istack++) {
\r
854 fStackNumber = istack;
\r
855 if (fSM.fStackActive[istack] == kFALSE) continue;
\r
857 fStack = &fSM.fStacks[istack];
\r
859 fgLastHC = -1; // to check rob number odering
\r
860 for (Int_t ilink = 0; ilink < 12; ilink++) {
\r
861 fStackLinkNumber = ilink;
\r
862 if (fStack->fLinksActive[ilink] == kFALSE) continue;
\r
864 // check GTU link monitor
\r
865 if (!(fStack->fLinksDataType[ilink] == 0 && fStack->fLinksMonitor[ilink] == 0)) {
\r
866 fStack->fLinkMonitorError[ilink] = 1;
\r
867 fStack->fLinkMonitorError[ilink] += fNWordsCounter; // counts words of given hc having link monitor error
\r
872 if (fpPos >= fpEnd) {
\r
873 if (fRawReader) fRawReader->AddMajorErrorLog(kLinkDataMissing, "Link data missing");
\r
874 if (fWarnWarning) AliWarning("Link data missing.");
\r
878 // set det number using SM header
\r
879 fHC = &fStack->fHalfChambers[ilink];
\r
880 fHC->fSM = fRawReader->GetEquipmentId() - 1024;
\r
881 fHC->fStack = fStackNumber;
\r
882 fHC->fLayer = Int_t(fStackLinkNumber/2.);
\r
883 fHC->fSide = fStackLinkNumber%2;
\r
884 fHC->fDET = fGeometry->GetDetector(fHC->fLayer, fHC->fStack, fHC->fSM);
\r
885 fHC->fRowMax = fGeometry->GetRowMax(fHC->fLayer, fHC->fStack, fHC->fSM);
\r
886 fHC->fROC = fGeometry->GetDetectorSec(fHC->fLayer, fHC->fStack);
\r
887 fHC->fColMax = fGeometry->GetColMax(fHC->fROC);
\r
891 // set number of timebin to be used in the digit container
\r
892 if (nLinkErrors>30) fGlobalNTimeBins=30;
\r
893 else if (!fIsTimeBinSet) {
\r
895 SetGlobalNTimebins();
\r
896 fIsTimeBinSet = kTRUE;
\r
899 ResetIterators(); // need to do it again for Next() function
\r
904 //------------------------------------------------------------
\r
905 Bool_t AliTRDrawFastStream::DecodeGTUheader()
\r
908 // decode Supermodule Index Word
\r
910 DecodeSMInfo(fpPos, &fSM);
\r
912 if (fgDebugFlag) AliDebug(5, DumpSMInfo(&fSM));
\r
915 if (fpPos < fpEnd) {
\r
916 // fSM.fHeaderSize represent additional Supermodule header size which contains additional information regarding hardware design.
\r
917 // For the moment, we skip decoding these words
\r
918 if (SkipWords(fSM.fHeaderSize) == kTRUE) {
\r
919 for (Int_t istack = 0; istack < 5; istack++) {
\r
920 if (fSM.fStackActive[istack] == kFALSE)
\r
923 fStack = &fSM.fStacks[istack];
\r
925 // Decode Stack Index Word of given stack
\r
926 DecodeStackInfo(fpPos, fStack);
\r
929 fSM.fNexpectedHalfChambers += fStack->fActiveLinks;
\r
931 if (fgDebugFlag) AliDebug(5, DumpStackInfo(fStack));
\r
933 if (SkipWords(fStack->fHeaderSize-6) == kFALSE) { // 6 is the 6 stack header words for 12 links
\r
934 if (fRawReader) fRawReader->AddMajorErrorLog(kDecodeStackInfo, "Stack header words missing");
\r
937 for (Int_t iword=0; iword<6; iword++) { // decode 6 stack header words
\r
938 // Decode Stack Header Word of given stack
\r
939 DecodeStackHeader(fpPos, fStack, iword);
\r
949 if (fWarnWarning) AliWarning("No additional sm headers and stack index words present.");
\r
950 if (fRawReader) fRawReader->AddMajorErrorLog(kDecodeStackInfo, "Stack info missing");
\r
954 if (fpPos < fpEnd) {
\r
955 if (fgDebugFlag) AliDebug(5, "GTU headers are OK.");
\r
958 if (fWarnError) AliError("No data just after GTU headers.");
\r
959 if (fRawReader) fRawReader->AddMajorErrorLog(kMissingData, "Missing sm data");
\r
963 if (fgDebugFlag) AliDebug(5, Form("Expected half chambers from GTU header: %d", fSM.fNexpectedHalfChambers));
\r
968 //--------------------------------------------------------
\r
969 void AliTRDrawFastStream::DecodeStackInfo(const UInt_t *word, struct AliTRDrawStack *st) const
\r
972 // decode Stack #i Index Word
\r
973 // The Stack #i Index Word is a 32-Bit word with following structure
\r
974 // ssssssss ssssssss vvvv mmmm mmmmmmmm
\r
975 // s: Size of the Stack #i Header, v: Supermodule Header Version, m: Link Mask
\r
977 st->fPos = (UInt_t*)word;
\r
979 UInt_t vword = *word;
\r
980 st->fHeaderSize = STACK_HEADER_SIZE(vword);
\r
982 UInt_t linkMask = STACK_LINK_WORD(vword);
\r
983 st->fActiveLinks = 0;
\r
984 for (Int_t i = 0; i < 12; i++) {
\r
985 if (IS_BIT_SET(linkMask,i) > 0) {
\r
986 st->fLinksActive[i] = kTRUE;
\r
987 st->fActiveLinks++;
\r
990 st->fLinksActive[i] = kFALSE;
\r
995 //--------------------------------------------------------
\r
996 void AliTRDrawFastStream::DecodeStackHeader(const UInt_t *word, struct AliTRDrawStack *st, Int_t iword) const
\r
999 // decode stack header
\r
1001 st->fPos = (UInt_t*)word;
\r
1003 UInt_t vword = *word;
\r
1004 st->fLinksDataType[2*iword] = LINK0_DATA_TYPE_FLAG(vword);
\r
1005 st->fLinksMonitor[2*iword] = LINK0_MONITOR_FLAG(vword);
\r
1006 st->fLinksDataType[2*iword+1] = LINK1_DATA_TYPE_FLAG(vword);
\r
1007 st->fLinksMonitor[2*iword+1] = LINK1_MONITOR_FLAG(vword);
\r
1010 //------------------------------------------------------------
\r
1011 Bool_t AliTRDrawFastStream::DecodeTracklets()
\r
1014 // decode tracklets
\r
1016 fLinkTrackletCounter = 0; // tracklet counter of this link
\r
1017 fEndOfTrackletCount = 0; // tracklet endmarker counter of this link
\r
1018 fHC->fNTracklets = 0; // number of tracklet of this link, should be less than 256
\r
1020 if (fgDebugFlag) AliDebug(10, Form("Decode tracklets at 0x%p : 0x%08x", fpPos, *fpPos));
\r
1022 while (!(*fpPos == END_OF_TRACKLET_MARKEROLD || *fpPos == END_OF_TRACKLET_MARKERNEW) && fpPos < fpEnd) {
\r
1023 if (fgDebugFlag) AliDebug(10, Form("Tracklet found at 0x%p : 0x%08x", fpPos, *fpPos));
\r
1025 fLinkTrackletCounter++;
\r
1027 if (fLinkTrackletCounter > MAXTRACKLETSPERHC) {
\r
1028 if (fgDebugFlag) AliDebug(11,Form("Max number of tracklets exceeded %d > %d. Tracklets are wrong either GTU header has problem",
\r
1029 fLinkTrackletCounter, MAXTRACKLETSPERHC));
\r
1030 if (fRawReader) fRawReader->AddMajorErrorLog(kTrackletOverflow,"Too many tracklets");
\r
1031 fHC->fErrorCodes[1] = 1;
\r
1035 fHC->fTrackletWords[fLinkTrackletCounter-1] = UInt_t(*fpPos); //store tracklet words into memory
\r
1039 fHC->fNTracklets = fLinkTrackletCounter;
\r
1041 while ((*fpPos == END_OF_TRACKLET_MARKEROLD || *fpPos == END_OF_TRACKLET_MARKERNEW) && fpPos < fpEnd) {
\r
1042 if (fgDebugFlag) AliDebug(10, Form("EoTracklets found at 0x%p : 0x%08x", fpPos, *fpPos));
\r
1044 fEndOfTrackletCount++;
\r
1048 if (fEndOfTrackletCount < 2) {
\r
1049 if (fgDebugFlag) AliDebug(11,"End of tracklets word missing");
\r
1050 if (fRawReader) fRawReader->AddMajorErrorLog(kEOTrackeltsMissing, "End of tracklets word missing");
\r
1051 fHC->fErrorCodes[1] += 2;
\r
1058 //--------------------------------------------------------
\r
1059 void AliTRDrawFastStream::DecodeSMInfo(const UInt_t *word, struct AliTRDrawSM *sm) const
\r
1062 // decode Supermodule Index Word
\r
1063 // The Supermodule Index Word is a 32-Bit word wit following structure
\r
1064 // ssssssss ssssssss vvvv rrrr r d t mmmm
\r
1065 // s: Size of the Supermodule Header, v: Supermodule Header Version, r: Reserved for future use
\r
1066 // d: Track Data Enabled Bit, t: Tracklet Data Enabled Bit, m: Stack Mask
\r
1068 sm->fPos = (UInt_t*)word;
\r
1070 UInt_t vword = *word;
\r
1071 sm->fHeaderSize = SM_HEADER_SIZE(vword);
\r
1073 if (TRACKLETS_ENABLED(vword) > 0)
\r
1074 sm->fTrackletEnable = kTRUE;
\r
1076 sm->fTrackletEnable = kFALSE;
\r
1078 UInt_t stackMask = STACK_MASK(vword);
\r
1079 sm->fActiveStacks = 0;
\r
1080 for (Int_t i = 0; i < 5; i++)
\r
1082 if (IS_BIT_SET(stackMask,i) > 0)
\r
1084 sm->fStackActive[i] = kTRUE;
\r
1085 sm->fActiveStacks++;
\r
1089 sm->fStackActive[i] = kFALSE;
\r
1094 //------------------------------------------------------------
\r
1095 Bool_t AliTRDrawFastStream::DecodeHC(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits,
\r
1096 AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2,
\r
1097 AliTRDSignalIndex *indexes)
\r
1100 // decode hc header and data
\r
1102 if (fpPos >= fpEnd) {
\r
1103 fHC->fCorrupted += 1;
\r
1104 if (fWarnError) AliError("No data(including HC header) in the buffer");
\r
1108 if (DecodeHCheader() == kFALSE) {
\r
1109 if (fWarnWarning) AliWarning(Form("HC Header decode failed. H0 Error: %d H1 Error: %d",fHC->fH0Corrupted,fHC->fH1Corrupted));
\r
1114 if (fpPos >= fpEnd) {
\r
1115 fHC->fCorrupted += 2;
\r
1116 if (fWarnError) AliError("No data right after HC header in the buffer");
\r
1121 // if ((fHC->fRawVMajor & 64) == 64) { // test pattern data
\r
1122 // AliTRDrawTPStream *tpStream = new AliTRDrawTPStream(fHC->fRawVMajorOpt, fpPos);
\r
1123 // if (tpStream->DecodeTPdata() == kFALSE) {
\r
1124 // if (fWarnError) AliError("Failed to decode test pattern data");
\r
1130 fHC->fMCMmax = 0; // count number of mcms in a hc
\r
1131 while (*fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd) {
\r
1133 ResetPerMCM(); // reset for every mcm
\r
1135 if (fHC->fMCMmax > TRDMAXMCM) {
\r
1136 fHC->fCorrupted += 4;
\r
1137 if (fgDebugFlag) AliDebug(11,"More mcm data than expected");
\r
1141 if (DecodeMCMheader() == kFALSE) {
\r
1143 // encode mcm level error codes
\r
1144 fHC->fErrorCodes[fHC->fMCMmax+2] += fMCM.fMCMhdCorrupted;
\r
1145 fHC->fErrorCodes[fHC->fMCMmax+2] += (fMCM.fADCmaskCorrupted << 4);
\r
1146 fHC->fErrorCodes[fHC->fMCMmax+2] += ((fMCM.fDataCorrupted & 1) << 6);
\r
1147 fHC->fErrorCodes[fHC->fMCMmax+2] += (fMCM.fMCM << 7); // encode MCM number
\r
1148 fHC->fErrorCodes[fHC->fMCMmax+2] += (fMCM.fROB << 11); // encode ROB number
\r
1150 fHC->fMCMmax++; // increase mcm counter to match with expected rob/mcm number
\r
1152 // in case we decide to keep reading data, skip this mcm data and find next mcm header
\r
1153 if (fMCM.fADCmaskCorrupted < 2) {
\r
1154 if (SkipMCMdata(fMCM.fADCcount*fMCM.fSingleADCwords) == kFALSE)
\r
1159 if (SeekNextMCMheader() == kFALSE)
\r
1167 if (fMCM.fADCmax > 0) {
\r
1169 if (fpPos >= fpEnd) {
\r
1170 fHC->fBufferCorrupted = kTRUE;
\r
1171 if (fgDebugFlag) AliDebug(11, Form("Buffer ends in the middle of data"));
\r
1176 for (Int_t iadc = 0; iadc < fMCM.fADCmax; iadc++) {
\r
1177 fADCnumber = fMCM.fADCchannel[iadc];
\r
1178 fExtendedCOL = fTRDfeeParam->GetExtendedPadColFromADC(fMCM.fROB, fMCM.fMCM, fADCnumber);
\r
1179 fCOL = fTRDfeeParam->GetPadColFromADC(fMCM.fROB, fMCM.fMCM, fADCnumber);
\r
1181 if (fADCnumber <= 1 || fADCnumber == fMaxADCgeom - 1) // if adc number = 0, 1, 20
\r
1182 fIsShared = kTRUE;
\r
1184 fIsShared = kFALSE;
\r
1186 if (fpPos + fMCM.fSingleADCwords >= fpEnd) {
\r
1187 fHC->fBufferCorrupted = kTRUE;
\r
1188 if (fgDebugFlag) AliDebug(11,"ADC (10 words) expected. Not enough data in the buffer.");
\r
1192 //if (GetGlobalNTimeBins() < 31){
\r
1193 if (fHC->fTimeBins < 31){
\r
1194 if (DecodeADC(digitsManager, digits, track0, track1, track2, indexes) == kFALSE) {
\r
1198 //else if (GetGlobalNTimeBins() > 32) {
\r
1199 else if (fHC->fTimeBins > 32) {
\r
1200 if (DecodeADCExtended(digitsManager, digits, track0, track1, track2, indexes) == kFALSE) {
\r
1204 else { // nsamples = 31, 32 are not implemented in the TRAP and should never happen
\r
1205 if (fWarnError) AliError("nsamples are 31 or 32. These are not implemented in the TRAP and should never happen!");
\r
1210 else { // if there is no adc activated
\r
1215 if (fpPos >= fpEnd) {
\r
1216 fHC->fBufferCorrupted = kTRUE;
\r
1217 if (fgDebugFlag) AliDebug(11,"We are at the end of buffer. Not enough data in the buffer.");
\r
1224 //------------------------------------------------------------
\r
1225 Bool_t AliTRDrawFastStream::DecodeHCheader()
\r
1228 // decode the half chamber header
\r
1229 // if it fails to decode HC header for both H0 and H1, return kFALSE
\r
1231 if (DecodeHCwordH0(fpPos, fHC) == kFALSE)
\r
1234 if (fHC->fNExtraWords > 0) {
\r
1236 if (fpPos < fpEnd) {
\r
1237 if (DecodeHCwordH1(fpPos, fHC) == kFALSE)
\r
1241 fHC->fBufferCorrupted = kTRUE;
\r
1242 if (fgDebugFlag) AliDebug(11,"Expected HC header word H1. Fail due to buffer END.");
\r
1247 if (fgDebugFlag) AliDebug(5, DumpHCinfoH0(fHC));
\r
1248 if (fgDebugFlag) AliDebug(5, DumpHCinfoH1(fHC));
\r
1250 if (IsHCheaderOK() == kFALSE) {
\r
1251 fHC->fH0Corrupted += 2;
\r
1252 if (fgDebugFlag) AliDebug(11,Form("H0 Header Insane. Word 0x%p", *fHC->fPos));
\r
1259 //--------------------------------------------------------
\r
1260 Bool_t AliTRDrawFastStream::DecodeHCwordH0(const UInt_t *word, struct AliTRDrawHC *hc) const
\r
1263 // decode the hc header word 0
\r
1265 UInt_t vword = *word;
\r
1266 hc->fPos[0] = (UInt_t*)word;
\r
1268 hc->fH0Corrupted = HC_HEADER_MASK_ERR(vword);
\r
1269 if (hc->fH0Corrupted > 0) {
\r
1270 if (fgDebugFlag) AliDebug(11,Form("H0 Header Mask Error. Word 0x%p",*fHC->fPos ));
\r
1273 hc->fSpecialRawV = HC_SPECIAL_RAW_VERSION(vword);
\r
1274 hc->fRawVMajor = HC_MAJOR_RAW_VERSION(vword);
\r
1275 hc->fRawVMajorOpt = HC_MAJOR_RAW_VERSION_OPT(vword);
\r
1276 hc->fRawVMinor = HC_MINOR_RAW_VERSION(vword);
\r
1277 hc->fNExtraWords = HC_EXTRA_WORDS(vword);
\r
1278 hc->fDCSboard = HC_DCS_BOARD(vword);
\r
1279 hc->fSMHCheader = HC_SM_NUMBER(vword);
\r
1280 hc->fStackHCheader = HC_STACK_NUMBER(vword);
\r
1281 hc->fLayerHCheader = HC_LAYER_NUMBER(vword);
\r
1282 hc->fSideHCheader = HC_SIDE_NUMBER(vword);
\r
1287 //--------------------------------------------------------
\r
1288 Bool_t AliTRDrawFastStream::DecodeHCwordH1(const UInt_t *word, struct AliTRDrawHC *hc) const
\r
1291 // decode the hc header word 1
\r
1293 UInt_t vword = *word;
\r
1294 hc->fPos[1] = (UInt_t*)word;
\r
1296 hc->fH1Corrupted = HC_HEADER_MASK_ERR(vword);
\r
1297 if (hc->fH1Corrupted > 0) {
\r
1298 if (fgDebugFlag) AliDebug(11,Form("H1 Header Mask Error. Word 0x%p", *(fHC->fPos+1) ));
\r
1301 hc->fTimeBins = HC_NTIMEBINS(vword);
\r
1302 hc->fBunchCrossCounter = HC_BUNCH_CROSS_COUNTER(vword);
\r
1303 hc->fPreTriggerCounter = HC_PRETRIGGER_COUNTER(vword);
\r
1304 hc->fPreTriggerPhase = HC_PRETRIGGER_PHASE(vword);
\r
1309 //------------------------------------------------------------
\r
1310 Bool_t AliTRDrawFastStream::IsHCheaderOK()
\r
1313 // check insanity of half chamber header
\r
1315 if (fHC->fStackHCheader < 0 || fHC->fStackHCheader > 4) {
\r
1316 if (fgDebugFlag) AliDebug(11,Form("Wrong Stack %d", fHC->fStackHCheader));
\r
1320 if (fHC->fLayerHCheader < 0 || fHC->fLayerHCheader >= AliTRDgeometry::kNlayer) {
\r
1321 if (fgDebugFlag) AliDebug(11,Form("Wrong layer %d", fHC->fLayerHCheader));
\r
1325 if (fHC->fSideHCheader < 0 || fHC->fSideHCheader > 1) {
\r
1326 if (fgDebugFlag) AliDebug(11,Form("Wrong Side %d", fHC->fSideHCheader));
\r
1330 if (fHC->fSMHCheader != fHC->fSM) {
\r
1331 if (fgDebugFlag) AliDebug(11,Form("Missmatch: SM number between HC header %d and GTU link mask %d",
\r
1332 fHC->fSMHCheader, fHC->fSM));
\r
1336 if (fgStackNumberChecker) {
\r
1337 if (fHC->fStackHCheader != fHC->fStack) {
\r
1338 if (fgDebugFlag) AliDebug(11,Form("Missmatch: Stack number between HC header %d and GTU link mask %d",
\r
1339 fHC->fStackHCheader, fHC->fStack));
\r
1344 if (fgStackLinkNumberChecker) {
\r
1345 if (fHC->fLayerHCheader * 2 + fHC->fSideHCheader != fHC->fLayer * 2 + fHC->fSide) {
\r
1346 if (fgDebugFlag) AliDebug(11,Form("Missmatch: Layer number between HC header %d and GTU link mask %d | %s",
\r
1347 fHC->fLayerHCheader, fHC->fLayer, DumpStackInfo(fStack)));
\r
1352 // SLOW GEOM : consistancy check with geometry
\r
1353 if (fHC->fDET < 0 || fHC->fDET >= AliTRDgeometry::kNdet) {
\r
1354 if (fgDebugFlag) AliDebug(11,Form("Wrong detector %d", fHC->fDET));
\r
1355 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongDet, "Wrong Det");
\r
1359 if (fHC->fSM != fGeometry->GetSector(fHC->fDET) || fHC->fSM <0 || fHC->fSM >= AliTRDgeometry::kNsector) {
\r
1360 if (fgDebugFlag) AliDebug(11,Form("Wrong SM(sector) %d (Geometry says: %d) Stack=%d Layer=%d Det=%d",
\r
1361 fHC->fSM, fGeometry->GetSector(fHC->fDET), fHC->fStack, fHC->fLayer, fHC->fDET));
\r
1362 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongSM, "Wrong SM");
\r
1366 if (fHC->fROC < 0) {
\r
1367 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC");
\r
1371 if (fHC->fRowMax < 1) {
\r
1372 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC Row Max");
\r
1376 if (fHC->fColMax < 1) {
\r
1377 if (fRawReader) fRawReader->AddMajorErrorLog(kHCHeaderWrongROC, "Wrong ROC Col Max");
\r
1384 //------------------------------------------------------------
\r
1385 Bool_t AliTRDrawFastStream::DecodeMCMheader()
\r
1388 // decode the mcm header
\r
1390 DecodeMCMheader(fpPos, &fMCM);
\r
1392 if (fHC->fEOTECorrupted == kTRUE) {
\r
1397 fMCM.fROW = fTRDfeeParam->GetPadRowFromMCM(fMCM.fROB, fMCM.fMCM);
\r
1399 if ((fHC->fRawVMajor > 2 && fHC->fRawVMajor <5) || ((fHC->fRawVMajor & 32) == 32)) { //cover old and new version definition of ZS data
\r
1401 if ( fpPos < fpEnd ) {
\r
1402 DecodeMask(fpPos, &fMCM);
\r
1403 if (fHC->fEOTECorrupted == kTRUE) {
\r
1407 MCMADCwordsWithTbins(fHC->fTimeBins, &fMCM);
\r
1408 fMCM.fAdcDataPos = fpPos + 1;
\r
1411 if (fgDebugFlag) AliDebug(11,"Expected ADC mask word. Fail due to buffer END.");
\r
1412 if (fRawReader) fRawReader->AddMajorErrorLog(kMCMADCMaskMissing,"Missing");
\r
1413 fHC->fBufferCorrupted = kTRUE;
\r
1418 UInt_t dummyMask = MCM_DUMMY_ADCMASK_VAL;
\r
1419 DecodeMask(&dummyMask, &fMCM);
\r
1420 MCMADCwordsWithTbins(fHC->fTimeBins, &fMCM);
\r
1421 fMCM.fAdcDataPos = fpPos + 1;
\r
1423 if (IsMCMheaderOK() == kFALSE)
\r
1429 //--------------------------------------------------------
\r
1430 void AliTRDrawFastStream::DecodeMCMheader(const UInt_t *word, struct AliTRDrawMCM *mcm) const
\r
1433 // decode the mcm header
\r
1435 UInt_t vword = *word;
\r
1437 if (vword == END_OF_TRACKLET_MARKERNEW) {
\r
1438 if (fWarnError) AliError(Form("There should be MCM header. We meet END_OF_TRACKLET_MARKER 0x%08x",vword));
\r
1439 fHC->fEOTECorrupted = kTRUE; //to finish data reading of this HC
\r
1442 mcm->fMCMhdCorrupted = MCM_HEADER_MASK_ERR(vword); //if MCM header mask has error
\r
1443 if (fgDebugFlag && mcm->fMCMhdCorrupted != 0) {
\r
1444 fHC->fDataCorrupted = kTRUE;
\r
1445 AliDebug(11,Form("Wrong MCM header mask 0x%08x.\n", *fpPos));
\r
1448 mcm->fROB = MCM_ROB_NUMBER(vword);
\r
1449 mcm->fMCM = MCM_MCM_NUMBER(vword);
\r
1450 mcm->fEvCounter = MCM_EVENT_COUNTER(vword);
\r
1451 mcm->fPos = (UInt_t*)word;
\r
1454 //--------------------------------------------------------
\r
1455 UInt_t AliTRDrawFastStream::GetMCMadcMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const
\r
1458 // get the adc mask
\r
1460 UInt_t vword = *word;
\r
1462 mcm->fADCMask = 0;
\r
1463 mcm->fADCcount = 0;
\r
1464 mcm->fADCMaskWord = vword;
\r
1466 if (vword == END_OF_TRACKLET_MARKERNEW) {
\r
1467 if (fWarnError) AliError(Form("There should be MCMadcMask. We meet END_OF_TRACKLET_MARKER 0x%08x",vword));
\r
1468 fHC->fEOTECorrupted = kTRUE; //to finish data reading of this HC
\r
1471 if ( MCM_ADCMASK_MASK_ERR(vword) == 0 ) {
\r
1472 mcm->fADCMask = MCM_ADCMASK_VAL(vword);
\r
1473 mcm->fADCcount = MCM_ADCMASK_NADC(~vword);
\r
1476 mcm->fADCMask = 0xffffffff;
\r
1477 mcm->fADCmaskCorrupted = 1; // mcm adc mask error
\r
1478 fHC->fDataCorrupted = kTRUE;
\r
1479 if (fgDebugFlag) AliDebug(11,Form("Wrong ADC Mask word 0x%08x.\n", *fpPos));
\r
1482 return mcm->fADCMask;
\r
1485 //--------------------------------------------------------
\r
1486 void AliTRDrawFastStream::DecodeMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const
\r
1489 // decode the adc mask - adcs to be read out
\r
1491 mcm->fSingleADCwords = 0;
\r
1493 mcm->fADCMask = GetMCMadcMask(word, mcm);
\r
1495 if (mcm->fADCMask > 0) {
\r
1496 for (Int_t i = 0; i < TRDMAXADC; i++) {
\r
1497 mcm->fADCchannel[mcm->fADCmax] = 0;
\r
1498 if ( IS_BIT_SET(mcm->fADCMask,i) ) {
\r
1499 mcm->fADCchannel[mcm->fADCmax] = i;
\r
1504 if (mcm->fADCcount != mcm->fADCmax && fHC->fRawVMajor >= 32) { // backward compatibility
\r
1505 mcm->fADCmaskCorrupted += 2;
\r
1506 fHC->fDataCorrupted = kTRUE;
\r
1507 if (fgDebugFlag) AliDebug(11,Form("ADC counts from ADCMask are different %d %d : ADCMask word 0x%08x\n",
\r
1508 mcm->fADCcount, mcm->fADCmax, *fMCM.fPos));
\r
1512 //--------------------------------------------------------
\r
1513 void AliTRDrawFastStream::MCMADCwordsWithTbins(UInt_t fTbins, struct AliTRDrawMCM *mcm) const
\r
1516 // count the expected mcm words for a given tbins
\r
1518 mcm->fSingleADCwords = 0;
\r
1519 mcm->fSingleADCwords = (fTbins-1)/3+1;
\r
1520 if (fTbins > 32) mcm->fSingleADCwords = 10; // if the timebin is more than 30, then fix the number of adc words to 10
\r
1523 //------------------------------------------------------------
\r
1524 Bool_t AliTRDrawFastStream::IsMCMheaderOK()
\r
1527 // check the mcm header
\r
1529 if (fgLastROB != fMCM.fROB) {
\r
1531 if (fgLastROB== -1) fgLastROB = fMCM.fROB;
\r
1534 Int_t matchingcounter = 0;
\r
1535 for (Int_t i=fgLastIndex+1; i<16; i++) {
\r
1536 if ( fMCM.fMCM == fgMCMordering[i] ) {
\r
1538 matchingcounter++;
\r
1542 if (matchingcounter == 0) {
\r
1543 fMCM.fMCMhdCorrupted += 2;
\r
1544 AliDebug(11,Form("MCM number from last MCM is larger: MCM # from current MCM %d \n", fMCM.fMCM));
\r
1548 if ( fgLastHC == fHC->fLayer*2 + fHC->fSide ) {
\r
1549 if ( fMCM.fROB < fgLastROB ) {
\r
1550 if((fMCM.fMCMhdCorrupted & 2) == 0) fMCM.fMCMhdCorrupted += 2;
\r
1551 AliDebug(11,Form("ROB number from last MCM is larger: ROB # from current MCM %d \n", fMCM.fROB));
\r
1553 else fgLastROB = fMCM.fROB;
\r
1556 fgLastHC = fHC->fLayer*2 + fHC->fSide;
\r
1558 if (fEventCounter == 0) {
\r
1559 fEventCounter = fMCM.fEvCounter;
\r
1562 if (fEventCounter != fMCM.fEvCounter) {
\r
1563 fMCM.fMCMhdCorrupted += 4;
\r
1564 if (fgDebugFlag) AliDebug(11,Form("Event number(%d) of current MCM is different from that(%d) of reference MCM %s.\n"
\r
1565 , fMCM.fEvCounter, fEventCounter, DumpMCMinfo(&fMCM)));
\r
1568 if (fEventCounter < fLastEventCounter) {
\r
1569 fMCM.fMCMhdCorrupted += 8;
\r
1570 if (fgDebugFlag) AliDebug(11,Form("Event from the past? Current %d Last %d %s.\n", fEventCounter, fLastEventCounter, DumpMCMinfo(&fMCM)));
\r
1573 if ( fMCM.fADCmaskCorrupted > 0 )
\r
1576 if ( fMCM.fMCMhdCorrupted > 0 )
\r
1582 //------------------------------------------------------------
\r
1583 Bool_t AliTRDrawFastStream::DecodeADC(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits,
\r
1584 AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2,
\r
1585 AliTRDSignalIndex *indexes)
\r
1588 // decode single ADC channel
\r
1590 if(fADCnumber%2==1) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL1);
\r
1591 if(fADCnumber%2==0) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL2);
\r
1594 Bool_t isWritten = kFALSE;
\r
1596 for (Int_t iw = 0; iw < fMCM.fSingleADCwords; iw++) {
\r
1597 if (HC_HEADER_MASK_ERR(*fpPos) == 0 || *fpPos == END_OF_TRACKLET_MARKERNEW) {
\r
1598 if (fWarnError) AliError(Form("There should be ADC data. We meet HC header or END_OF_TRACKLET_MARKER 0x%08x",*fpPos));
\r
1599 fHC->fEOTECorrupted = kTRUE;
\r
1603 if (fMaskADCword != ADC_WORD_MASK(*fpPos)) {
\r
1604 if (fgDebugFlag) AliDebug(11,Form("Wrong ADC data mask! [Expected mask: 0x%08x Current mask: 0x%08x] ADC channel number: %02d MCM= %s ",
\r
1605 fMaskADCword, ADC_WORD_MASK(*fpPos), fADCnumber, DumpMCMinfo(&fMCM)));
\r
1606 // encode adc level error codes
\r
1607 Int_t index = 21*(fMCM.fMCM + 16*int(fMCM.fROB/2)) + fADCnumber;
\r
1608 fHC->fErrorCodes[index+66] += 1;
\r
1609 if (!isWritten) {
\r
1610 fHC->fErrorCodes[index+66] += (fADCnumber << 4);;
\r
1611 fHC->fErrorCodes[index+66] += (fMCM.fMCM << 9);;
\r
1612 fHC->fErrorCodes[index+66] += (fMCM.fROB << 13);;
\r
1613 isWritten = kTRUE;
\r
1615 fMCM.fDataCorrupted = kTRUE;
\r
1616 fHC->fDataCorrupted = kTRUE;
\r
1620 // decode and put into the digit container
\r
1621 Int_t adcSignals[3];
\r
1622 adcSignals[0] = ((*fpPos & 0x00000ffc) >> 2);
\r
1623 adcSignals[1] = ((*fpPos & 0x003ff000) >> 12);
\r
1624 adcSignals[2] = ((*fpPos & 0xffc00000) >> 22);
\r
1626 if(GetCol() < 0 || (!fSharedPadsOn & fIsShared)) {fpPos++; continue;};
\r
1628 for (Int_t i = 0; i < 3; i++) {
\r
1629 digits->SetDataByAdcCol(GetRow(), GetExtendedCol(), fTbinADC + i, adcSignals[i]);
\r
1630 indexes->AddIndexRC(GetRow(), GetCol());
\r
1631 if (digitsManager->UsesDictionaries()) {
\r
1632 track0->SetData(GetRow(), GetCol(), fTbinADC + i, 0);
\r
1633 track1->SetData(GetRow(), GetCol(), fTbinADC + i, 0);
\r
1634 track2->SetData(GetRow(), GetCol(), fTbinADC + i, 0);
\r
1644 //------------------------------------------------------------
\r
1645 Bool_t AliTRDrawFastStream::DecodeADCExtended(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits,
\r
1646 AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2,
\r
1647 AliTRDSignalIndex *indexes)
\r
1650 // decode single ADC channel
\r
1652 if(fADCnumber%2==1) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL1);
\r
1653 if(fADCnumber%2==0) fMaskADCword = ADC_WORD_MASK(ADCDATA_VAL2);
\r
1655 Bool_t isWritten = kFALSE; //for error code recording
\r
1657 fTbinADC = ((*fpPos & 0x000000fc) >> 2);
\r
1658 fMCM.fSingleADCwords = ((*fpPos & 0x00000f00) >> 8);
\r
1660 Int_t adcFirst2Signals[2];
\r
1661 adcFirst2Signals[0] = ((*fpPos & 0x003ff000) >> 12);
\r
1662 adcFirst2Signals[1] = ((*fpPos & 0xffc00000) >> 22);
\r
1664 for (Int_t i = 0; i < 2; i++) {
\r
1665 digits->SetDataByAdcCol(GetRow(), GetExtendedCol(), fTbinADC + i, adcFirst2Signals[i]);
\r
1666 indexes->AddIndexRC(GetRow(), GetCol());
\r
1667 if (digitsManager->UsesDictionaries()) {
\r
1668 track0->SetData(GetRow(), GetCol(), fTbinADC + i, 0);
\r
1669 track1->SetData(GetRow(), GetCol(), fTbinADC + i, 0);
\r
1670 track2->SetData(GetRow(), GetCol(), fTbinADC + i, 0);
\r
1675 for (Int_t iw = 0; iw < fMCM.fSingleADCwords-1; iw++) {
\r
1676 if (HC_HEADER_MASK_ERR(*fpPos) == 0 || *fpPos == END_OF_TRACKLET_MARKERNEW) {
\r
1677 if (fWarnError) AliError(Form("There should be ADC data. We meet HC header or END_OF_TRACKLET_MARKER 0x%08x",*fpPos));
\r
1678 fHC->fEOTECorrupted = kTRUE;
\r
1682 if (fMaskADCword != ADC_WORD_MASK(*fpPos)) {
\r
1683 if (fgDebugFlag) AliDebug(11,Form("Wrong ADC data mask! [Expected mask: 0x%08x Current mask: 0x%08x] ADC channel number: %02d MCM= %s ",
\r
1684 fMaskADCword, ADC_WORD_MASK(*fpPos), fADCnumber, DumpMCMinfo(&fMCM)));
\r
1685 // encode adc level error codes
\r
1686 Int_t index = 21*(fMCM.fMCM + 16*int(fMCM.fROB/2)) + fADCnumber;
\r
1687 fHC->fErrorCodes[index+66] += 1;
\r
1688 if (!isWritten) {
\r
1689 fHC->fErrorCodes[index+66] += (fADCnumber << 4);;
\r
1690 fHC->fErrorCodes[index+66] += (fMCM.fMCM << 9);;
\r
1691 fHC->fErrorCodes[index+66] += (fMCM.fROB << 13);;
\r
1692 isWritten = kTRUE;
\r
1694 fMCM.fDataCorrupted = kTRUE;
\r
1695 fHC->fDataCorrupted = kTRUE;
\r
1699 // decode and put into the digit container
\r
1700 Int_t adcSignals[3];
\r
1701 adcSignals[0] = ((*fpPos & 0x00000ffc) >> 2);
\r
1702 adcSignals[1] = ((*fpPos & 0x003ff000) >> 12);
\r
1703 adcSignals[2] = ((*fpPos & 0xffc00000) >> 22);
\r
1705 if(GetCol() < 0 || (!fSharedPadsOn & fIsShared)) {fpPos++; continue;};
\r
1706 for (Int_t i = 0; i < 3; i++) {
\r
1707 digits->SetDataByAdcCol(GetRow(), GetExtendedCol(), fTbinADC + 2 + i, adcSignals[i]);
\r
1708 indexes->AddIndexRC(GetRow(), GetCol());
\r
1709 if (digitsManager->UsesDictionaries()) {
\r
1710 track0->SetData(GetRow(), GetCol(), fTbinADC + 2 + i, 0);
\r
1711 track1->SetData(GetRow(), GetCol(), fTbinADC + 2 + i, 0);
\r
1712 track2->SetData(GetRow(), GetCol(), fTbinADC + 2 + i, 0);
\r
1722 //------------------------------------------------------------
\r
1723 Bool_t AliTRDrawFastStream::SeekEndOfData()
\r
1726 // go to end of data marker
\r
1728 Int_t fEndOfDataCount = 0;
\r
1729 fNWordsCounter = 0;
\r
1731 while ( fpPos < fpEnd && *fpPos != ENDOFRAWDATAMARKER ) {
\r
1735 while ( fpPos < fpEnd && *fpPos == ENDOFRAWDATAMARKER ) {
\r
1736 fEndOfDataCount++;
\r
1743 //------------------------------------------------------------
\r
1744 Bool_t AliTRDrawFastStream::SeekNextMCMheader()
\r
1747 // go to mcm marker
\r
1751 while ( *fpPos != ENDOFRAWDATAMARKER && fpPos < fpEnd ) {
\r
1752 if (MCM_HEADER_MASK_ERR(*fpPos) == 0 && MCM_HEADER_MASK_ERR(*(fpPos+1)) == 0) {
\r
1753 if (fgDebugFlag) AliDebug(11,Form("Found : Pos 0x%p : Val 0x%08x", fpPos, *fpPos));
\r
1756 if ( *fpPos == END_OF_TRACKLET_MARKERNEW) {
\r
1757 fHC->fEOTECorrupted = kTRUE;
\r
1767 //------------------------------------------------------------
\r
1768 Bool_t AliTRDrawFastStream::SkipMCMdata(UInt_t iw)
\r
1771 // skip mcm data words due to corruption
\r
1773 if (fgDebugFlag) AliDebug(11,Form("Skip %d words due to MCM header corruption.",iw));
\r
1774 UInt_t iwcounter = 0;
\r
1775 while ( *fpPos != ENDOFRAWDATAMARKER && iwcounter < iw) {
\r
1776 if ( *fpPos == END_OF_TRACKLET_MARKERNEW) {
\r
1777 if (fgDebugFlag) AliDebug(11,"Met END_OF_TRACKLET_MARKERNEW");
\r
1778 fHC->fEOTECorrupted = kTRUE;
\r
1785 if (iwcounter == iw) {
\r
1790 if (fgDebugFlag) AliDebug(11,"Met ENDOFRAWDATAMARKER");
\r
1794 //------------------------------------------------------------
\r
1795 Bool_t AliTRDrawFastStream::SetGlobalNTimebins()
\r
1797 // get number of time bin info from HC headers then set
\r
1799 while (SetNTimebins()==kFALSE){
\r
1800 if (fgDebugFlag) AliDebug(11,Form("Failed to get number of time bin information from the %dth HC",nHCs));
\r
1807 //------------------------------------------------------------
\r
1808 Bool_t AliTRDrawFastStream::SetNTimebins()
\r
1810 // goes to the HC header position
\r
1811 while (!(*fpPosTemp == END_OF_TRACKLET_MARKERNEW) && fpPosTemp < fpEnd) {
\r
1814 while (*fpPosTemp == END_OF_TRACKLET_MARKERNEW) {
\r
1821 if (!(vword = *fpPosTemp)) {
\r
1822 fGlobalNTimeBins = 30; // default number of timebins
\r
1826 // get the number of time bins
\r
1827 if (HC_HEADER_MASK_ERR(vword) == 0) {
\r
1828 fGlobalNTimeBins = HC_NTIMEBINS(vword);
\r
1829 if (fGlobalNTimeBins > 64 || fGlobalNTimeBins < 10) return kFALSE; // minimal protection
\r
1837 //------------------------------------------------------------
\r
1838 Bool_t AliTRDrawFastStream::DumpWords(UInt_t *px, UInt_t iw, UInt_t marker)
\r
1841 // dump given number of words for debugging
\r
1843 TString tsreturn = Form("\n[ Dump Sequence at 0x%p ] : ", px);
\r
1844 for (UInt_t i = 0; i < iw; i++) {
\r
1845 if ( iw != 0 && px + iw > fpEnd)
\r
1847 if (i % 8 == 0) tsreturn += "\n ";
\r
1848 if (marker != 0 && marker == px[i]) tsreturn += Form(" *>0x%08x<* ", px[i]);
\r
1849 else tsreturn += Form("0x%08x ", px[i]);
\r
1853 AliInfo(tsreturn.Data());
\r
1858 //--------------------------------------------------------
\r
1859 const char *AliTRDrawFastStream::DumpSMInfo(const struct AliTRDrawSM *sm)
\r
1862 // format the string with the sm info
\r
1864 return Form("[ SM Info 0x%08x] : Hsize %d TrackletEnable %d Stacks %d %d %d %d %d",
\r
1865 *sm->fPos, sm->fHeaderSize, sm->fTrackletEnable,
\r
1866 sm->fStackActive[0], sm->fStackActive[1], sm->fStackActive[2],
\r
1867 sm->fStackActive[3], sm->fStackActive[4]);
\r
1870 //--------------------------------------------------------
\r
1871 const char *AliTRDrawFastStream::DumpStackInfo(const struct AliTRDrawStack *st)
\r
1874 // format the string with the stack info
\r
1876 return Form("[ Stack Info 0x%08x ] : Hsize %d Links Active %d %d %d %d %d %d %d %d %d %d %d %d",
\r
1877 *st->fPos, st->fHeaderSize,
\r
1878 st->fLinksActive[0], st->fLinksActive[1], st->fLinksActive[2], st->fLinksActive[3],
\r
1879 st->fLinksActive[4], st->fLinksActive[5], st->fLinksActive[6], st->fLinksActive[7],
\r
1880 st->fLinksActive[8], st->fLinksActive[9], st->fLinksActive[10], st->fLinksActive[11]);
\r
1883 //--------------------------------------------------------
\r
1884 const char *AliTRDrawFastStream::DumpHCinfoH0(const struct AliTRDrawHC *hc)
\r
1887 // dump the hc header word 0 in strings
\r
1890 return Form("Unable to dump. Null received as parameter!?!");
\r
1892 return Form("[ HC[0] at 0x%p ] : 0x%08x Info is : RawV %d SM %d Stack %d Layer %d Side %d DCSboard %d",
\r
1893 hc->fPos[0], *(hc->fPos[0]), hc->fRawVMajor, fRawReader->GetEquipmentId()-1024,
\r
1894 hc->fStack, hc->fLayer, hc->fSide, hc->fDCSboard);
\r
1897 //--------------------------------------------------------
\r
1898 const char *AliTRDrawFastStream::DumpHCinfoH1(const struct AliTRDrawHC *hc)
\r
1901 // dump the hc header word 1 in strings
\r
1904 return Form("Unable to dump. Null received as parameter!?!");
\r
1906 return Form("[ HC[1] at 0x%p ] : 0x%08x Info is : TBins %d BCcount %d PreTrigCount %d PreTrigPhase %d",
\r
1907 hc->fPos[1], *(hc->fPos[1]), hc->fTimeBins, hc->fBunchCrossCounter, hc->fPreTriggerCounter, hc->fPreTriggerPhase);
\r
1910 //--------------------------------------------------------
\r
1911 const char *AliTRDrawFastStream::DumpMCMinfo(const struct AliTRDrawMCM *mcm)
\r
1914 // dump mcm info in strings
\r
1917 return Form("Unable to dump. Null received as parameter!?!");
\r
1919 return Form("[ MCM 0x%08x ] : ROB %d MCM %d EvCounter %d", *(mcm->fPos), mcm->fROB, mcm->fMCM, mcm->fEvCounter);
\r
1922 //--------------------------------------------------------
\r
1923 const char *AliTRDrawFastStream::DumpMCMadcMask(const struct AliTRDrawMCM *mcm)
\r
1926 // mcm adc mask in strings
\r
1929 return Form("Unable to dump. Null received as parameter!?!");
\r
1931 TString tsreturn = Form("[Word] : 0x%08x => [Mask] : 0x%08x : ", mcm->fADCMaskWord, mcm->fADCMask);
\r
1932 for (Int_t i = 0; i < TRDMAXADC; i++) {
\r
1933 tsreturn += Form("%d ", mcm->fADCchannel[i]);
\r
1936 return tsreturn.Data();
\r