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