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