Unuseful print commented
[u/mrichter/AliRoot.git] / ZDC / AliZDCRawStream.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 ZDC digits in raw data.                     //
21 //                                                                           //
22 // It loops over all ZDC 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 // Getters provide information about the current digit.                      //
26 //                                                                           //
27 ///////////////////////////////////////////////////////////////////////////////
28
29 #include <TSystem.h>
30 #include "AliZDCRawStream.h"
31 #include "AliRawReader.h"
32 #include "AliRawDataHeader.h"
33 #include "AliRawEventHeaderBase.h"
34 #include "AliLog.h"
35
36 ClassImp(AliZDCRawStream)
37
38
39 //_____________________________________________________________________________
40 AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
41   fRawReader(rawReader),
42   fBuffer(0),
43   fReadOutCard(-1),
44   fEvType(0),
45   fPosition(0),
46   fIsCalib(kFALSE),
47   fIsDARCHeader(kFALSE),
48   fIsHeaderMapping(kFALSE),
49   fIsChMapping(kFALSE),
50   fIsADCDataWord(kFALSE),
51   fIsADCHeader(kFALSE),
52   fIsADCEOB(kFALSE),
53   fSODReading(kFALSE),
54   fIsMapRead(kFALSE),
55   fReadCDH(kTRUE),
56   fDeadfaceOffset(-1),
57   fDeadbeefOffset(-1),
58   fDataOffset(0),
59   fModType(-1),
60   fADCModule(-1),
61   fADCNChannels(-1),     
62   fADCChannel(-1),       
63   fADCValue(-1),         
64   fADCGain(-1),
65   fIsUnderflow(kFALSE),
66   fIsOverflow(kFALSE),
67   fScGeo(0),      
68   fScNWords(0),   
69   fScTriggerSource(0),    
70   fScTriggerNumber(0),
71   fIsScEventGood(kTRUE),
72   fIsScHeaderRead(kFALSE),
73   fScStartCounter(0),
74   fScEvCounter(0),
75   fIsScalerWord(kFALSE),
76   fDetPattern(0),
77   fTrigCountNWords(0),
78   fIsTriggerScaler(kFALSE),
79   fTrigCountStart(0),
80   fMBTrigInput(0),         
81   fCentralTrigInput(0), 
82   fSCentralTrigInput(0),
83   fEMDTrigInput(0),     
84   fL0Received(0),          
85   fMBtrig2CTP(0),          
86   fCentralTrig2CTP(0),  
87   fSCentralTrig2CTP(0), 
88   fEMDTrig2CTP(0),            
89   fTrigHistNWords(0),
90   fIsTriggerHistory(kFALSE),
91   fTrigHistStart(0),
92   fPileUpBit1stWord(0),
93   fL0Bit1stWord(0),
94   fCentralTrigHist(0),
95   fMBTrigHist(0),
96   fPileUpBit2ndWord(0),
97   fL0Bit2ndWord(0), 
98   fSCentralTrigHist(0),
99   fEMDTrigHist(0),
100   fNChannelsOn(0),
101   fCurrentCh(-1),
102   fCabledSignal(-1),
103   fCurrScCh(-1),
104   fCurrTDCCh(-1),
105   fIsADCEventGood(kTRUE),
106   fIsL0BitSet(kTRUE),
107   fIsPileUpEvent(kFALSE),
108   fIsADDChannel(kFALSE),
109   fADDADCdatum(0),
110   fIsTDCHeaderRead(kFALSE),
111   fTDCStartCounter(0),
112   fIsZDCTDCHeader(kFALSE),
113   fIsZDCTDCdatum(kFALSE),
114   fZDCTDCdatum(0),
115   fIsADDTDCHeader(kFALSE),
116   fIsADDTDCdatum(kFALSE),
117   fADDTDCdatum(0)
118 {
119   // Create an object to read ZDC raw digits
120   fRawReader->Reset();
121   fRawReader->Select("ZDC");
122   //
123   const int kNch = 48;
124   for(Int_t i=0; i<kNch; i++){
125     for(Int_t j=0; j<5; j++){
126       fMapADC[i][j]=-1;
127       if(i<32){
128         fScalerMap[i][j]=-1;
129         if(j<3) fTDCMap[i][j]=-1;
130       }
131     }
132   }
133   
134   for(Int_t k=0; k<4; k++) fCPTInput[k] = 0;
135
136 }
137
138 //_____________________________________________________________________________
139 AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
140   TObject(stream),
141   fRawReader(stream.fRawReader),
142   fBuffer(stream.GetRawBuffer()),
143   fReadOutCard(stream.GetReadOutCard()),
144   fEvType(stream.fEvType),
145   fPosition(stream.fPosition),
146   fIsCalib(stream.fIsCalib),
147   fIsDARCHeader(stream.fIsDARCHeader), 
148   fIsHeaderMapping(stream.fIsHeaderMapping),
149   fIsChMapping(stream.fIsChMapping),
150   fIsADCDataWord(stream.fIsADCDataWord), 
151   fIsADCHeader(stream.fIsADCHeader), 
152   fIsADCEOB(stream.fIsADCEOB), 
153   fSODReading(stream.fSODReading),
154   fIsMapRead(stream.fIsMapRead),
155   fReadCDH(stream.fReadCDH),
156   fDeadfaceOffset(stream.GetDeadfaceOffset()),
157   fDeadbeefOffset(stream.GetDeadbeefOffset()),
158   fDataOffset(stream.GetDataOffset()),
159   fModType(stream.GetModType()),
160   fADCModule(stream.GetADCModule()),     
161   fADCNChannels(stream.GetADCNChannels()),       
162   fADCChannel(stream.GetADCChannel()),   
163   fADCValue(stream.GetADCValue()),       
164   fADCGain(stream.GetADCGain()),
165   fIsUnderflow(stream.fIsUnderflow),
166   fIsOverflow(stream.fIsOverflow),
167   fScGeo(stream.GetScGeo()),      
168   fScNWords(stream.GetScNWords()),        
169   fScTriggerSource(stream.GetScTriggerSource()),          
170   fScTriggerNumber(stream.fScTriggerNumber),
171   fIsScEventGood(stream.fIsScEventGood),
172   fIsScHeaderRead(stream.fIsScHeaderRead),
173   fScStartCounter(stream.fScStartCounter),
174   fScEvCounter(stream.fScEvCounter),
175   fIsScalerWord(stream.fIsScalerWord),
176   fDetPattern(stream.fDetPattern),
177   fTrigCountNWords(stream.fTrigCountNWords),
178   fIsTriggerScaler(stream.fIsTriggerScaler),
179   fTrigCountStart(stream.fTrigCountStart),
180   fMBTrigInput(stream.fMBTrigInput),       
181   fCentralTrigInput(stream.fCentralTrigInput), 
182   fSCentralTrigInput(stream.fSCentralTrigInput),
183   fEMDTrigInput(stream.fEMDTrigInput),     
184   fL0Received(stream.fL0Received),         
185   fMBtrig2CTP(stream.fMBtrig2CTP),         
186   fCentralTrig2CTP(stream.fCentralTrig2CTP),  
187   fSCentralTrig2CTP(stream.fSCentralTrig2CTP), 
188   fEMDTrig2CTP(stream.fEMDTrig2CTP),          
189   fTrigHistNWords(stream.fTrigHistNWords),
190   fIsTriggerHistory(stream.fIsTriggerHistory),
191   fTrigHistStart(stream.fTrigHistStart),
192   fPileUpBit1stWord(stream.fPileUpBit1stWord),
193   fL0Bit1stWord(stream.fL0Bit1stWord), 
194   fCentralTrigHist(stream.fCentralTrigHist),
195   fMBTrigHist(stream.fMBTrigHist),
196   fPileUpBit2ndWord(stream.fPileUpBit2ndWord),
197   fL0Bit2ndWord(stream.fL0Bit2ndWord), 
198   fSCentralTrigHist(stream.fSCentralTrigHist),
199   fEMDTrigHist(stream.fEMDTrigHist),
200   fNChannelsOn(stream.fNChannelsOn),
201   fCurrentCh(stream.fCurrentCh),
202   fCabledSignal(stream.GetCabledSignal()),
203   fCurrScCh(stream.fCurrScCh),
204   fCurrTDCCh(stream.fCurrTDCCh),
205   fIsADCEventGood(stream.fIsADCEventGood),
206   fIsL0BitSet(stream.fIsL0BitSet),
207   fIsPileUpEvent(stream.fIsPileUpEvent),
208   fIsADDChannel(stream.fIsADDChannel),
209   fADDADCdatum(stream.fADDADCdatum),
210   fIsTDCHeaderRead(stream.fIsTDCHeaderRead),
211   fTDCStartCounter(stream.fTDCStartCounter),
212   fIsZDCTDCHeader(stream.fIsZDCTDCHeader),
213   fIsZDCTDCdatum(stream.fIsZDCTDCdatum),
214   fZDCTDCdatum(stream.fZDCTDCdatum),
215   fIsADDTDCHeader(stream.fIsADDTDCHeader),
216   fIsADDTDCdatum(stream.fIsADDTDCdatum),
217   fADDTDCdatum(stream.fADDTDCdatum)
218 {
219   // Copy constructor
220   const int kNch = 48;
221   for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);     
222   for(Int_t i=0; i<kNch; i++){
223     for(Int_t j=0; j<5; j++){
224       fMapADC[i][j] = stream.fMapADC[i][j];
225       if(i<32) fScalerMap[i][j] = stream.fMapADC[i][j];
226     }
227   }
228   
229   for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k];
230 }
231
232 //_____________________________________________________________________________
233 AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream& 
234                                               /* stream */)
235 {
236   // Assignment operator
237   Fatal("operator =", "assignment operator not implemented");
238   return *this;
239 }
240
241 //_____________________________________________________________________________
242 AliZDCRawStream::~AliZDCRawStream()
243 {
244 // Destructor
245
246 }
247
248 //_____________________________________________________________________________
249 void AliZDCRawStream::ReadChMap()
250 {
251   // Reading channel map
252   const int kNch = 48;
253   AliDebug(2,"\t Reading ZDC ADC mapping from OCDB\n");
254   AliZDCChMap * chMap = GetChMap();
255   //chMap->Print("");
256   for(Int_t i=0; i<kNch; i++){
257     fMapADC[i][0] = chMap->GetADCModule(i);
258     fMapADC[i][1] = chMap->GetADCChannel(i);
259     fMapADC[i][2] = chMap->GetADCSignalCode(i);
260     fMapADC[i][3] = chMap->GetDetector(i);
261     fMapADC[i][4] = chMap->GetSector(i);
262   }
263   fIsMapRead = kTRUE;
264 }
265
266 //_____________________________________________________________________________
267 void AliZDCRawStream::ReadCDHHeader()
268 {
269   // Reading CDH 
270   const AliRawDataHeader* header = fRawReader->GetDataHeader();
271   if(!header) {
272       AliError(" No CDH in raw data streaming");
273       fRawReader->AddMajorErrorLog(kCDHError);
274       return;
275   }
276   else{
277     //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
278
279     UChar_t message = header->GetAttributes();
280     //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
281     
282     if((message & 0xf0) == 0x0){ // PHYSICS RUN
283        //printf("\t PHYSICS RUN raw data found\n");
284     }
285     else if((message & 0xf0) == 0x10){ // COSMIC RUN
286        //printf("\t STANDALONE_COSMIC RUN raw data found\n");
287     }
288     else if((message & 0xf0) == 0x20){ // PEDESTAL RUN
289        //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
290     }
291     else if((message & 0xf0) == 0x30){ // LASER RUN
292        //printf("\t STANDALONE_LASER RUN raw data found\n");
293     }
294     else if((message & 0xf0) == 0x40){ // CALIBRATION_CENTRAL RUN
295        //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
296     }
297     else if((message & 0xf0) == 0x50){ // CALIBRATION_SEMICENTRAL
298        //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
299     }
300     else if((message & 0xf0) == 0x60){ // CALIBRATION_MB
301        //printf("\t CALIBRATION_MB RUN raw data found\n");
302     }
303     else if((message & 0xf0) == 0x70){ // CALIBRATION_EMD
304        //printf("\t CALIBRATION_EMD RUN raw data found\n");
305     }
306     // *** Checking the bit indicating the used readout card
307     // (the payload is different in the 2 cases!)
308     if((message & 0x08) == 0){  // ** DARC card
309        fReadOutCard = 0;
310        fIsDARCHeader = kTRUE;
311        //AliInfo("\t ZDC readout card used: DARC");
312     }
313     else if((message & 0x08) == 0x08){  // ** ZRC card
314        fReadOutCard = 1;
315        //AliInfo("\t ZDC readout card used: ZRC");
316     }
317
318     if(header->GetL1TriggerMessage() & 0x1){ // Calibration bit set in CDH
319       fIsCalib = kTRUE;
320     }
321     //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
322     //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);    
323     
324 /*    UInt_t status = header->GetStatus();
325     //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
326     if((status & 0x000f) == 0x0001){
327       AliDebug(2,"CDH -> DARC trg0 overlap error");
328       fRawReader->AddMajorErrorLog(kDARCError);
329     }
330     if((status & 0x000f) == 0x0002){
331       AliDebug(2,"CDH -> DARC trg0 missing error");
332       fRawReader->AddMajorErrorLog(kDARCError);
333     }
334     if((status & 0x000f) == 0x0004){
335       AliDebug(2,"CDH -> DARC data parity error");
336       fRawReader->AddMajorErrorLog(kDARCError);
337     }
338     if((status & 0x000f) == 0x0008){
339       AliDebug(2,"CDH -> DARC ctrl parity error");
340       fRawReader->AddMajorErrorLog(kDARCError);
341     }
342     //
343     if((status & 0x00f0) == 0x0010){
344       AliDebug(2,"CDH -> DARC trg unavailable");
345       fRawReader->AddMajorErrorLog(kDARCError);
346     }
347     if((status & 0x00f0) == 0x0020){
348       AliDebug(2,"CDH -> DARC FEE error");
349       fRawReader->AddMajorErrorLog(kDARCError);
350     }
351     //
352     if((status & 0x0f00) == 0x0200){
353       AliDebug(2,"CDH -> DARC L1 time violation");
354       fRawReader->AddMajorErrorLog(kDARCError);
355     }
356     if((status & 0x0f00) == 0x0400){
357       AliDebug(2,"CDH -> DARC L2 time-out");
358       fRawReader->AddMajorErrorLog(kDARCError);
359     }
360     if((status & 0x0f00) == 0x0800){
361       AliDebug(2,"CDH -> DARC prepulse time violation");
362       fRawReader->AddMajorErrorLog(kDARCError);
363     }
364     //
365     if((status & 0xf000) == 0x1000){
366       AliDebug(2,"CDH -> DARC other error");
367       fRawReader->AddMajorErrorLog(kDARCError);
368     }
369     */
370   }
371   
372 }
373
374 //_____________________________________________________________________________
375 Bool_t AliZDCRawStream::Next()
376 {
377   // Read the next raw digit
378   // Returns kFALSE if there is no digit left
379
380   if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
381   const int kNch = 48;
382   //
383   fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE; 
384   fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
385   fIsZDCTDCdatum = kFALSE; fIsADDChannel = kFALSE; fIsADDTDCdatum=kFALSE;
386   fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE;
387   fSector[0] = fSector[1] = -1;
388   for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
389
390   fEvType = fRawReader->GetType();
391   if(fPosition==0 && fReadCDH){
392     //if(fEvType==7 || fEvType ==8){ //Physics or calibration event
393       ReadCDHHeader();
394     //}
395     fCurrentCh=0; fCurrScCh=0;  fCurrTDCCh=0;fNChannelsOn=0;
396     // Ch. debug
397     //printf("\n  AliZDCRawStream::Next() - ev. type %d",fEvType);
398   }
399   // Needed to read simulated raw data (temporary solution?)
400   else if(fPosition==0 && !fReadCDH && fReadOutCard==-1) fReadOutCard=1;
401   
402   // Ch. debug
403   //printf("\n  AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
404   
405   // *** End of ZDC event
406   if(fBuffer == 0xcafefade){
407     //printf("\n  AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
408     return kFALSE;
409   }
410   
411   // -------------------------------------------
412   // --- DARC header
413   // -------------------------------------------
414   // If the CDH has been read then 
415   // the DARC header must follow
416   if(fReadOutCard==0 && fIsDARCHeader){
417     //printf("\t ---- DARC header ----\n");
418     if(fIsCalib){
419       fDeadfaceOffset = 9;
420       fDeadbeefOffset = 25;
421     }
422     else{
423       fDeadfaceOffset = 1;
424       fDeadbeefOffset = 7;
425     }
426     fDataOffset = 1+fDeadbeefOffset;
427     fIsDARCHeader = kFALSE;
428   }
429     
430   // ---------------------------------------------
431   // --- Start of data event (SOD)             ---
432   // --- decoding mapping of connected ADC ch. ---
433   // ---------------------------------------------
434   // In the SOD event ADC ch. mapping is written
435   if(fEvType==10){
436    if(fSODReading){
437     
438     if(fPosition>=fDataOffset){
439       if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
440         // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum @ fDataOffset=0
441         if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){ 
442            printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
443            fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;     
444         }
445         else{
446           printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
447           fSODReading = kFALSE;
448           return kFALSE;
449         }
450       }
451       else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
452         fPosition++;
453         return kFALSE; // !!!!!!!!!!!!!!!!!!!!!  For the moment thresholds are not read
454       }
455       else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
456         fIsHeaderMapping = kTRUE;
457         fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
458         fModType = ((fBuffer & 0x7ff00)>>8); 
459         fADCNChannels = (fBuffer & 0xff);          // # of channels following the header
460         //
461         printf("  ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
462       }
463       else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
464         fADCChannel = ((fBuffer & 0x3fff0000)>>16);
465         fCabledSignal = (fBuffer&0xffff);
466         //
467         if(fModType == kV965){ // ******** ADCs ********************************
468           // Channel signal
469           if((fBuffer&0x40000000)>>30==0 && fADCModule<=kLastADCGeo){ // *ZDC* high range chain ADC
470             fIsChMapping = kTRUE;
471             fMapADC[fCurrentCh][0] = fADCModule;
472             fMapADC[fCurrentCh][1] = fADCChannel;
473             fMapADC[fCurrentCh][2] = fCabledSignal;
474             //  - No. of channels on
475             fNChannelsOn++;
476             //
477             // Determining detector and sector
478             // -----------------------------------------
479             //  For the decoding of the following lines 
480             //  look the enum in AliZDCRawStream.h file
481             // -----------------------------------------
482             if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
483               || fCabledSignal==24 || fCabledSignal==48){
484               fMapADC[fCurrentCh][3] = 4; //ZNA
485               //
486               if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot)       fMapADC[fCurrentCh][4]=0;
487               else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1oot)  fMapADC[fCurrentCh][4]=1;
488               else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2oot)  fMapADC[fCurrentCh][4]=2;
489               else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3oot)  fMapADC[fCurrentCh][4]=3;
490               else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4oot)  fMapADC[fCurrentCh][4]=4;
491               else if(fCabledSignal==kZDCAMon || fCabledSignal==kZDCAMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
492             }
493             else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
494               fMapADC[fCurrentCh][3] = 5; //ZPA
495               //
496               if(fCabledSignal==kZPAC || fCabledSignal==kZPACoot)      fMapADC[fCurrentCh][4]=0;
497               else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1oot) fMapADC[fCurrentCh][4]=1;
498               else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2oot) fMapADC[fCurrentCh][4]=2;
499               else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3oot) fMapADC[fCurrentCh][4]=3;
500               else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4oot) fMapADC[fCurrentCh][4]=4;
501             }
502             else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
503                || fCabledSignal==25 || fCabledSignal==49){
504               fMapADC[fCurrentCh][3] = 1; //ZNC
505               //
506               if(fCabledSignal==kZNCC || fCabledSignal==kZNCCoot)      fMapADC[fCurrentCh][4]=0;
507               else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1oot) fMapADC[fCurrentCh][4]=1;
508               else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2oot) fMapADC[fCurrentCh][4]=2;
509               else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3oot) fMapADC[fCurrentCh][4]=3;
510               else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4oot) fMapADC[fCurrentCh][4]=4;
511               else if(fCabledSignal==kZDCCMon || fCabledSignal==kZDCCMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
512             }
513             else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
514               fMapADC[fCurrentCh][3] = 2; //ZPC
515               //
516               if(fCabledSignal==kZPCC || fCabledSignal==kZPCCoot)   fMapADC[fCurrentCh][4]=0;
517               else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1oot) fMapADC[fCurrentCh][4]=1;
518               else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2oot) fMapADC[fCurrentCh][4]=2;
519               else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3oot) fMapADC[fCurrentCh][4]=3;
520               else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4oot) fMapADC[fCurrentCh][4]=4;
521             }
522             else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
523               fMapADC[fCurrentCh][3] = 3; // ZEM
524               //
525               if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1oot)      fMapADC[fCurrentCh][4]=1;
526               else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2oot) fMapADC[fCurrentCh][4]=2;
527             }
528             //Ch. debug
529             //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
530             //printf("  det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
531             //
532             fCurrentCh++;
533             //
534           } // high range channels
535         }// ModType=1 (ADC mapping)
536         else if(fModType == kV830){  // ******** VME scaler **************************
537           fIsChMapping = kTRUE;
538           fScalerMap[fCurrScCh][0] = fADCModule;
539           fScalerMap[fCurrScCh][1] = fADCChannel;
540           fScalerMap[fCurrScCh][2] = fCabledSignal;
541           //
542           // Determining detector and sector
543           // -----------------------------------------
544           //  For the decoding of the following lines 
545           //  look the enum in AliZDCRawStream.h file
546           // -----------------------------------------
547           // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
548           if((fCabledSignal>=2 && fCabledSignal<=6) ||
549              (fCabledSignal>=61 && fCabledSignal<=65)){
550             fScalerMap[fCurrScCh][3] = 4; //ZNA
551             //
552             if(fCabledSignal==kZNAC || fCabledSignal==kZNACD)      fScalerMap[fCurrScCh][4]=0;
553             else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1D) fScalerMap[fCurrScCh][4]=1;
554             else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2D) fScalerMap[fCurrScCh][4]=2;
555             else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3D) fScalerMap[fCurrScCh][4]=3;
556             else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4D) fScalerMap[fCurrScCh][4]=4;
557           }
558           else if((fCabledSignal>=7 && fCabledSignal<=11) ||
559              (fCabledSignal>=66 && fCabledSignal<=70)){
560             fScalerMap[fCurrScCh][3] = 5; //ZPA
561             //
562             if(fCabledSignal==kZPAC || fCabledSignal==kZPACD)      fScalerMap[fCurrScCh][4]=0;
563             else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1D) fScalerMap[fCurrScCh][4]=1;
564             else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2D) fScalerMap[fCurrScCh][4]=2;
565             else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3D) fScalerMap[fCurrScCh][4]=3;
566             else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4D) fScalerMap[fCurrScCh][4]=4;
567           }
568           else if((fCabledSignal>=12 && fCabledSignal<=16) ||
569              (fCabledSignal>=71 && fCabledSignal<=75)){
570             fScalerMap[fCurrScCh][3] = 1; //ZNC
571             //
572             if(fCabledSignal==kZNCC || fCabledSignal==kZNCCD)      fScalerMap[fCurrScCh][4]=0;
573             else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1D) fScalerMap[fCurrScCh][4]=1;
574             else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2D) fScalerMap[fCurrScCh][4]=2;
575             else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3D) fScalerMap[fCurrScCh][4]=3;
576             else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4D) fScalerMap[fCurrScCh][4]=4;
577           }
578           else if((fCabledSignal>=17 && fCabledSignal<=21) ||
579              (fCabledSignal>=76 && fCabledSignal<=80)){
580             fScalerMap[fCurrScCh][3] = 2; //ZPC
581             //
582             if(fCabledSignal==kZPCC || fCabledSignal==kZPCCD) fScalerMap[fCurrScCh][4]=0;
583             else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1D)  fScalerMap[fCurrScCh][4]=1;
584             else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2D)  fScalerMap[fCurrScCh][4]=2;
585             else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3D)  fScalerMap[fCurrScCh][4]=3;
586             else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4D)  fScalerMap[fCurrScCh][4]=4;
587           }
588           else if(fCabledSignal==22 || fCabledSignal==23 ||
589                   fCabledSignal==81 || fCabledSignal==82){
590             fScalerMap[fCurrScCh][3] = 3; // ZEM
591             //
592             if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1D)      fScalerMap[fCurrScCh][4]=1;
593             else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2D) fScalerMap[fCurrScCh][4]=2;
594           }
595           // Ch debug.
596           /*printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
597           if(fCabledSignal!=0 && fCabledSignal!=1) printf("  det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
598           else printf("  Signal void/not connected\n");*/
599           
600           fCurrScCh++;
601         }
602         else if(fModType==KV1290 && fADCModule==kZDCTDCGeo){  // ******** ZDC TDC **************************
603           fIsChMapping = kTRUE;
604           fTDCMap[fCurrTDCCh][0] = fADCModule;
605           fTDCMap[fCurrTDCCh][1] = fADCChannel;
606           fTDCMap[fCurrTDCCh][2] = fCabledSignal;
607           
608           fCurrTDCCh++;
609           
610           // Ch debug.
611           //printf("\tZDC TDC: mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);        
612         }
613         /*else if(fModType == kTRG){ // **** scalers from trigger card
614           //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);         
615         }
616         else if(fModType == kTRGI){ // **** trigger history from trigger card
617           //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
618         }
619         else if(fModType == kPU){ // **** pattern unit
620           //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
621         }*/
622       }//reading channel mapping
623     }
624    } // if fSODREading
625    fPosition++;
626    return kTRUE;
627   } // ------------------------------- SOD event
628   
629   // -------------------------------------------
630   // --- DARC data
631   // -------------------------------------------
632   if(fPosition<fDeadfaceOffset && fReadOutCard==0){
633     fPosition++;
634     return kTRUE;
635   }
636   else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
637     if(fBuffer != 0xdeadface){
638       //AliWarning(" NO deadface after DARC data");
639       fRawReader->AddMajorErrorLog(kDARCError); 
640     }
641     else{
642       fPosition++;
643       return kTRUE;
644     }
645   }
646   else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
647     fPosition++;
648     return kTRUE;
649   }
650   else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
651     if(fBuffer != 0xdeadbeef){
652       //AliWarning(" NO deadbeef after DARC global data");
653       fRawReader->AddMajorErrorLog(kDARCError);  
654       fPosition++;
655       return kFALSE;
656     }
657     else{
658       fPosition++;
659       return kTRUE;
660     }
661   } // ------------------------------- End of DARC data
662   
663   // ---------------------------------------------
664   // --- ZDC data
665   // --- ADCs + VME scaler + trigger card + P.U.
666   // ---------------------------------------------
667   else if(fPosition>=fDataOffset){
668     
669     if(!fSODReading && !fIsMapRead) ReadChMap();
670     
671     //  !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
672     // Not valid datum before the event 
673     // there MUST be a NOT valid datum before the event!!!
674     if(fReadOutCard==0){
675       if(fPosition==fDataOffset){ 
676         //printf("\t **** ZDC data begin ****\n");
677         if((fBuffer & 0x07000000) != 0x06000000){
678           fRawReader->AddMajorErrorLog(kZDCDataError);
679         }
680         else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
681           fIsADCEventGood = kFALSE;
682         }
683       }
684     
685       // If the not valid datum isn't followed by the 1st ADC header
686       // the event is corrupted (i.e., 2 gates arrived before trigger)
687       else if(fPosition==fDataOffset+1){ 
688         if((fBuffer & 0x07000000) != 0x02000000){
689           AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
690           fRawReader->AddMajorErrorLog(kZDCDataError);
691           fIsADCEventGood = kFALSE;
692           fPosition++;
693           return kFALSE;
694         }
695       }
696     }
697      
698     // Get geo address of current word
699     if(fIsTDCHeaderRead && fIsZDCTDCHeader) fADCModule = kZDCTDCGeo;
700     else if(fIsTDCHeaderRead && fIsADDTDCHeader) fADCModule = kADDTDCGeo;
701     else fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
702     
703     // ************************************ ADC MODULES ************************************
704     if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo){
705       // *** ADC header
706       if((fBuffer & 0x07000000) == 0x02000000){
707         fIsADCHeader = kTRUE;
708         fADCNChannels = ((fBuffer & 0x00003f00)>>8);
709         //printf("  AliZDCRawStream -> ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
710       }
711       // *** ADC data word
712       else if((fBuffer & 0x07000000) == 0x00000000){
713         fIsADCDataWord = kTRUE;
714         fADCChannel = ((fBuffer & 0x1e0000) >> 17);
715         fADCGain = ((fBuffer & 0x10000) >> 16);       
716         fADCValue = (fBuffer & 0xfff);  
717         //
718         //printf("  AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
719         //  fADCModule,fADCChannel,fADCGain,fADCValue);
720         
721         // Checking if the channel map for the ADCs has been provided/read
722         if(fMapADC[0][0]==-1){
723           printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n");
724           return kFALSE;
725         }
726         //
727         /*for(Int_t ci=0; ci<kNch; ci++){
728           printf("  %d mod %d ch %d det %d sec %d\n",ci,fMapADC[ci][0],
729           fMapADC[ci][1], fMapADC[ci][3], fMapADC[ci][4]);
730         }*/
731                 
732         // Scan of the map to assign the correct volumes
733         Int_t foundMapEntry = kFALSE;
734         for(Int_t k=0; k<kNch; k++){
735            if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){
736              fSector[0] = fMapADC[k][3];
737              fSector[1] = fMapADC[k][4];
738              foundMapEntry = kTRUE;
739              break;
740            } 
741         }
742         if(foundMapEntry==kFALSE){
743           AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n",
744               fPosition,fADCModule,fADCChannel));
745         }
746
747         // Final checks
748         if(foundMapEntry==kTRUE){
749           if(fSector[0]<1 || fSector[0]>5){
750             AliWarning(Form(" No valid detector assignment: %d",fSector[0]));
751             fRawReader->AddMajorErrorLog(kInvalidSector);
752           }
753           //
754           if(fSector[1]<0 || fSector[1]>5){
755             AliWarning(Form(" No valid sector assignment: %d",fSector[1]));
756             fRawReader->AddMajorErrorLog(kInvalidSector);
757           }
758           //
759           if(fADCModule<0 || fADCModule>3){
760             AliError(Form(" No valid ADC module: %d",fADCModule));
761             fRawReader->AddMajorErrorLog(kInvalidADCModule);
762           }
763         }
764
765         // Checking the underflow and overflow bits
766         if(fBuffer & 0x1000)       fIsUnderflow = kTRUE;
767         else if (fBuffer & 0x2000) fIsOverflow = kTRUE; 
768                 
769       }//ADC data word
770       // *** ADC EOB
771       else if((fBuffer & 0x07000000) == 0x04000000){
772         fIsADCEOB = kTRUE;
773         //printf("  AliZDCRawStream -> EOB --------------------------\n");
774       }
775     }//ADC module
776     // ********************************* ADD ADC *********************************
777     else if(fADCModule == kADDADCGeo){
778       // *** ADC header
779       if((fBuffer & 0x07000000) == 0x02000000){
780         fIsADCHeader = kTRUE;
781         fADCNChannels = ((fBuffer & 0x00003f00)>>8);
782         //printf("  AliZDCRawStream -> ADD ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
783       }
784       // *** ADC data word
785       else if((fBuffer & 0x07000000) == 0x00000000){
786         fIsADDChannel = kTRUE;
787         fADCChannel = ((fBuffer & 0x1e0000) >> 17);
788         fADCGain = ((fBuffer & 0x10000) >> 16);       
789         fADCValue = (fBuffer & 0xfff);  
790         //
791         //printf("  ADD ADC DATUM -> mod. %d ch. %d gain %d value %d\n",
792         //  fADCModule,fADCChannel,fADCGain,fADCValue);
793       }
794       // *** ADC EOB
795       else if((fBuffer & 0x07000000) == 0x04000000){
796         fIsADCEOB = kTRUE;
797         //printf("  AliZDCRawStream -> EOB --------------------------\n");
798       }
799     }
800     // ********************************* TDC *********************************
801     else if(fADCModule==kTDCFakeGeo && fIsTDCHeaderRead==kFALSE){
802       // *** TDC header
803       fIsTDCHeaderRead = kTRUE;
804       fTDCStartCounter = fPosition;
805       // GEO address from TDC header
806       fADCModule = (Int_t) (fBuffer & 0x1f);
807       if(fADCModule==kZDCTDCGeo){ // *** ZDC TDC
808         fIsZDCTDCHeader = kTRUE;
809         //Ch. debug
810         //printf("  AliZDCRawStream -> ZDC TDC: mod.%d\n",fADCModule);
811       }
812       else if(fADCModule==kADDTDCGeo){ // *** ADD TDC
813         fIsADDTDCHeader = kTRUE;
814         //Ch. debug
815         //printf("  AliZDCRawStream -> ADD TDC: mod.%d\n",fADCModule);
816       }
817     }
818     // ********************************* VME SCALER HEADER *********************************
819     else if(fADCModule == kScalerGeo){
820       if(fBuffer & 0x04000000 && fIsScHeaderRead==kFALSE){ // *** Scaler header
821         fScGeo = (fBuffer & 0xf8000000)>>27;       
822         fScNWords = (fBuffer & 0x00fc0000)>>18;    
823         fScTriggerSource = (fBuffer & 0x00030000)>>16;     
824         fScTriggerNumber = (fBuffer & 0x0000ffff);
825         fIsScHeaderRead = kTRUE; 
826         fScStartCounter = fPosition;
827         //Ch. debug
828         //printf("  AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
829         //   fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
830       } 
831       else if(!(fBuffer & 0x04000000)){
832         fIsScEventGood = kFALSE;
833       }
834     }
835     // *********************************** PATTERN UNIT ***********************************
836     else if(fADCModule == kPUGeo){
837       // still to be implemented!!! Not yet in data!!!
838       fDetPattern = (fBuffer & 0x0000003f);
839       // Ch. debug
840       //printf("  AliZDCRawStream -> Pattern Unit\n");
841       
842     }
843     // ******************************** TRIGGER CARD COUNTS ********************************
844     else if(fADCModule == kTrigScales){
845       if(fIsTriggerScaler == kFALSE){
846         fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
847         fTrigCountStart = fPosition;
848         fIsTriggerScaler = kTRUE;
849       }
850       // Ch. debug
851       //printf("  AliZDCRawStream -> Trigger Scaler header\n");      
852     }
853     // ********************************** TRIGGER HISTORY **********************************
854     else if(fADCModule == kTrigHistory){
855       if(fIsTriggerHistory == kFALSE){
856         fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
857         fTrigHistStart = fPosition;
858         fIsTriggerHistory = kTRUE;
859       }
860       // Ch. debug
861       //printf("  AliZDCRawStream -> Trigger History header\n");
862       
863     } 
864     // ********************************** VME SCALER DATA **********************************
865     //  Reading VME scaler data 
866     if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
867       fADCModule=kScalerGeo; fIsADCDataWord=kFALSE; fIsScalerWord=kTRUE;
868       fScEvCounter = fBuffer;
869       Int_t nWords = (Int_t) (fScNWords);
870       if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
871       //Ch. debug
872       //printf("  AliZDCRawStream -> scaler datum %d", fScEvCounter);
873     }
874     // ********************************** ZDC TDC DATA **********************************
875     //  ZDC TDC data
876     if(fIsTDCHeaderRead && fIsZDCTDCHeader && fPosition>=fTDCStartCounter+1){ 
877       fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
878       if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
879         fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
880         fIsZDCTDCdatum = kTRUE;
881         fZDCTDCdatum = (Int_t) (fBuffer & 0x1fffff);
882         // Ch. debug
883         //printf("  AliZDCRawStream -> ZDC TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fZDCTDCdatum);
884       }
885       if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
886         // Trailer
887         fIsTDCHeaderRead = kFALSE;
888         // Ch. debug
889         //printf("  AliZDCRawStream -> ZDC TDC global trailer\n");
890       }
891     }
892     // ********************************** ADD TDC DATA **********************************
893     //  ADD TDC data
894     if(fIsTDCHeaderRead && fIsADDTDCHeader && fPosition>=fTDCStartCounter+1){ 
895       fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
896       if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
897         fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
898         fIsADDTDCdatum = kTRUE;
899         fADDTDCdatum = (Int_t) (fBuffer & 0x1fffff);
900         // Ch. debug
901         //printf("  AliZDCRawStream -> ADD TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fADDTDCdatum);
902       }
903       if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
904         // Trailer
905         fIsTDCHeaderRead = kFALSE;
906         // Ch. debug
907         //printf("  AliZDCRawStream -> ADD TDC global trailer\n");
908       }
909     }
910     // ******************************** TRIGGER SCALER DATA ********************************
911     //  Reading trigger scaler data 
912     if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
913       fADCModule = kTrigScales; fIsADCDataWord = kFALSE;        
914       if(fPosition == fTrigCountStart+1)      fMBTrigInput = fBuffer;               
915       else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;                  
916       else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
917       else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer; 
918       else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
919       else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;     
920       else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;  
921       else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer; 
922       else if(fPosition == fTrigCountStart+9){
923         fEMDTrig2CTP = fBuffer;       
924         fIsTriggerScaler = kFALSE;
925       }
926       // Ch. debug
927       //printf("  AliZDCRawStream -> Trigger Scaler datum %d\n", fPosition-fTrigCountStart);
928     }
929     // ******************************* TRIGGER HISTORY WORDS ******************************
930     //  Reading trigger history
931     if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
932         fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;     
933         if(fPosition == fTrigHistStart+1){
934           fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
935           fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;        
936           fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14; 
937           fMBTrigHist =  (fBuffer & 0x00007fff);        
938           //
939           fCPTInput[0] = (fBuffer & 0x00000080) >> 6;  // MB bit
940           fCPTInput[1] = (fBuffer & 0x00400000) >> 21; // CENTRAL bit
941         }
942         
943         else if(fPosition == fTrigHistStart+fTrigHistNWords){
944           fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
945           fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;      
946           fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14; 
947           fEMDTrigHist =  (fBuffer & 0x00007fff);        
948           //
949           fCPTInput[2] = (fBuffer & 0x00000080) >> 6;  // SEMICENTRAL bit
950           fCPTInput[3] = (fBuffer & 0x00400000) >> 21; // EMD bit
951           //
952           fIsTriggerHistory = kFALSE;
953           
954           // Checking if the event is good
955           // (1) both history word pile up bits must be = 0
956           if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
957           else{
958             fIsPileUpEvent = kTRUE;
959             printf("  AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
960                 fPileUpBit1stWord, fPileUpBit2ndWord);
961           }
962           // (2) both history word L0 bits must be = 1
963           if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
964           else{
965             fIsL0BitSet = kFALSE;
966             printf("  AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
967                 fL0Bit1stWord, fL0Bit2ndWord);
968           }
969         }       
970         // Ch. debug
971         //printf("  AliZDCRawStream -> Trigger history word %d\n", fPosition-fTrigHistStart);
972     }
973     
974   }
975
976   fPosition++;
977
978   return kTRUE;
979 }
980
981 //_____________________________________________________________________________
982 AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri) 
983 {
984   // Setting the storage
985   
986   AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri); 
987
988   return storage; 
989 }
990
991
992 //_____________________________________________________________________________
993 AliZDCChMap* AliZDCRawStream::GetChMap() const
994 {
995
996   // Getting calibration object for ZDC
997
998   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
999   if(!entry) AliFatal("No calibration data loaded!");  
1000
1001   AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
1002   if(!calibdata) AliFatal("Wrong calibration object in calibration  file!");
1003
1004   return calibdata;
1005 }