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