1st update of raw data streaming class
[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   fEvType(0),
44   fPosition(0),
45   fIsCalib(kFALSE),
46   fIsDARCHeader(kFALSE),
47   fIsHeaderMapping(kFALSE),
48   fIsChMapping(kFALSE),
49   fIsADCDataWord(kFALSE),
50   fIsADCHeader(kFALSE),
51   fIsADCEOB(kFALSE),
52   fSODReading(kFALSE),
53   fIsMapRead(kFALSE),
54   fDARCEvBlockLenght(0),  
55   fDARCBlockAttributes(0),
56   fDeadfaceOffset(0),
57   fDeadbeefOffset(0),
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   fNChannelsOn(0),
76   fCurrentCh(-1),
77   fCabledSignal(-1),
78   fCurrScCh(-1),
79   fIsEventGood(kTRUE),
80   fIsL0BitSet(kTRUE),
81   fIsPileUpOff(kTRUE)
82 {
83   // Create an object to read ZDC raw digits
84   fRawReader->Reset();
85   fRawReader->Select("ZDC");
86   //
87   const int kNch = 48;
88   for(Int_t i=0; i<kNch; i++){
89     for(Int_t j=0; j<5; j++){
90       fMapADC[i][j]=-1;
91       if(i<32) fScalerMap[i][j]=-1;
92     }
93   }
94
95 }
96
97 //_____________________________________________________________________________
98 AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
99   TObject(stream),
100   fRawReader(stream.fRawReader),
101   fBuffer(stream.GetRawBuffer()),
102   fEvType(stream.fEvType),
103   fPosition(stream.fPosition),
104   fIsCalib(stream.fIsCalib),
105   fIsDARCHeader(stream.fIsDARCHeader), 
106   fIsHeaderMapping(stream.fIsHeaderMapping),
107   fIsChMapping(stream.fIsChMapping),
108   fIsADCDataWord(stream.fIsADCDataWord), 
109   fIsADCHeader(stream.fIsADCHeader), 
110   fIsADCEOB(stream.fIsADCEOB), 
111   fSODReading(stream.fSODReading),
112   fIsMapRead(stream.fIsMapRead),
113   fDARCEvBlockLenght(stream.fDARCEvBlockLenght),  
114   fDARCBlockAttributes(stream.fDARCBlockAttributes),
115   fDeadfaceOffset(stream.GetDeadfaceOffset()),
116   fDeadbeefOffset(stream.GetDeadbeefOffset()),
117   fDataOffset(stream.GetDataOffset()),
118   fModType(stream.GetModType()),
119   fADCModule(stream.GetADCModule()),     
120   fADCNChannels(stream.GetADCNChannels()),       
121   fADCChannel(stream.GetADCChannel()),   
122   fADCValue(stream.GetADCValue()),       
123   fADCGain(stream.GetADCGain()),
124   fIsUnderflow(stream.fIsUnderflow),
125   fIsOverflow(stream.fIsOverflow),
126   fScGeo(stream.GetScGeo()),      
127   fScNWords(stream.GetScNWords()),        
128   fScTriggerSource(stream.GetScTriggerSource()),          
129   fScTriggerNumber(stream.fScTriggerNumber),
130   fIsScEventGood(stream.fIsScEventGood),
131   fIsScHeaderRead(stream.fIsScHeaderRead),
132   fScStartCounter(stream.fScStartCounter),
133   fScEvCounter(stream.fScEvCounter),
134   fNChannelsOn(stream.fNChannelsOn),
135   fCurrentCh(stream.fCurrentCh),
136   fCabledSignal(stream.GetCabledSignal()),
137   fCurrScCh(stream.fCurrScCh),
138   fIsEventGood(stream.fIsEventGood),
139   fIsL0BitSet(stream.fIsL0BitSet),
140   fIsPileUpOff(stream.fIsPileUpOff)
141
142 {
143   // Copy constructor
144   const int kNch = 48;
145   for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);     
146   for(Int_t i=0; i<kNch; i++){
147     for(Int_t j=0; j<5; j++){
148       fMapADC[i][j] = stream.fMapADC[i][j];
149       if(i<32) fScalerMap[i][j] = stream.fMapADC[i][j];
150     }
151   }
152 }
153
154 //_____________________________________________________________________________
155 AliZDCRawStream& AliZDCRawStream::operator = (const AliZDCRawStream& 
156                                               /* stream */)
157 {
158   // Assignment operator
159   Fatal("operator =", "assignment operator not implemented");
160   return *this;
161 }
162
163 //_____________________________________________________________________________
164 AliZDCRawStream::~AliZDCRawStream()
165 {
166 // Destructor
167
168 }
169
170 //_____________________________________________________________________________
171 void AliZDCRawStream::ReadChMap()
172 {
173   // Reading channel map
174   const int kNch = 48;
175   //printf("\t Reading ZDC ADC mapping from OCDB\n");
176   AliZDCChMap * chMap = GetChMap();
177   //chMap->Print("");
178   for(Int_t i=0; i<kNch; i++){
179     fMapADC[i][0] = chMap->GetADCModule(i);
180     fMapADC[i][1] = chMap->GetADCChannel(i);
181     fMapADC[i][2] = -1;
182     fMapADC[i][3] = chMap->GetDetector(i);
183     fMapADC[i][4] = chMap->GetSector(i);
184   }
185   fIsMapRead = kTRUE;
186 }
187
188 //_____________________________________________________________________________
189 void AliZDCRawStream::ReadCDHHeader()
190 {
191   // Reading CDH 
192   const AliRawDataHeader* header = fRawReader->GetDataHeader();
193   if(!header) {
194       AliError(" No CDH in raw data streaming");
195       fRawReader->AddMajorErrorLog(kCDHError);
196       return;
197   }
198   else{
199     //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %d\n",fRawReader->GetDataSize());
200
201     fDARCEvBlockLenght = header->fSize;
202     //printf("\t AliZDCRawStream::ReadCDHHeader -> fDARCEvBlockLenght = %d\n",fDARCEvBlockLenght);
203     
204     UChar_t message = header->GetAttributes();
205     //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
206     
207     if(message == 0x0){ // PHYSICS RUN
208        //printf("\t PHYSICS RUN raw data found\n");
209     }
210     else if(message == 0x10){ // COSMIC RUN
211        //printf("\t STANDALONE_COSMIC RUN raw data found\n");
212     }
213     else if(message == 0x20){ // PEDESTAL RUN
214        //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
215     }
216     else if(message == 0x30){ // LASER RUN
217        //printf("\t STANDALONE_LASER RUN raw data found\n");
218     }
219     else if(message == 0x40){ // CALIBRATION_CENTRAL RUN
220        //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
221     }
222     else if(message == 0x50){ // CALIBRATION_SEMICENTRAL
223        //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
224     }
225     else if(message == 0x60){ // CALIBRATION_MB
226        //printf("\t CALIBRATION_MB RUN raw data found\n");
227     }
228     else if(message == 0x70){ // CALIBRATION_EMD
229        //printf("\t CALIBRATION_EMD RUN raw data found\n");
230     }
231     
232     if(header->GetL1TriggerMessage() & 0x1){ // Calibration bit set in CDH
233       fIsCalib = kTRUE;
234     }
235     //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
236     //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);    
237     
238     UInt_t status = header->GetStatus();
239     //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
240     if((status & 0x000f) == 0x0001){
241       AliDebug(2,"CDH -> DARC trg0 overlap error");
242       fRawReader->AddMajorErrorLog(kDARCError);
243     }
244     if((status & 0x000f) == 0x0002){
245       AliDebug(2,"CDH -> DARC trg0 missing error");
246       fRawReader->AddMajorErrorLog(kDARCError);
247     }
248     if((status & 0x000f) == 0x0004){
249       AliDebug(2,"CDH -> DARC data parity error");
250       fRawReader->AddMajorErrorLog(kDARCError);
251     }
252     if((status & 0x000f) == 0x0008){
253       AliDebug(2,"CDH -> DARC ctrl parity error");
254       fRawReader->AddMajorErrorLog(kDARCError);
255     }
256     //
257     if((status & 0x00f0) == 0x0010){
258       AliDebug(2,"CDH -> DARC trg unavailable");
259       fRawReader->AddMajorErrorLog(kDARCError);
260     }
261     if((status & 0x00f0) == 0x0020){
262       AliDebug(2,"CDH -> DARC FEE error");
263       fRawReader->AddMajorErrorLog(kDARCError);
264     }
265     //
266     if((status & 0x0f00) == 0x0200){
267       AliDebug(2,"CDH -> DARC L1 time violation");
268       fRawReader->AddMajorErrorLog(kDARCError);
269     }
270     if((status & 0x0f00) == 0x0400){
271       AliDebug(2,"CDH -> DARC L2 time-out");
272       fRawReader->AddMajorErrorLog(kDARCError);
273     }
274     if((status & 0x0f00) == 0x0800){
275       AliDebug(2,"CDH -> DARC prepulse time violation");
276       fRawReader->AddMajorErrorLog(kDARCError);
277     }
278     //
279     if((status & 0xf000) == 0x1000){
280       AliDebug(2,"CDH -> DARC other error");
281       fRawReader->AddMajorErrorLog(kDARCError);
282     }
283   }
284   //
285   fIsDARCHeader = kTRUE;
286 }
287
288 //_____________________________________________________________________________
289 Bool_t AliZDCRawStream::Next()
290 {
291   // Read the next raw digit
292   // Returns kFALSE if there is no digit left
293
294   if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
295   const int kNch = 48;
296   Bool_t readScaler = kFALSE;
297   Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kPUGeo=29, kTrigScales=30, kTrigHistory=31;
298   fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE; 
299   fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
300   fIsUnderflow = kFALSE; fIsOverflow = kFALSE; 
301   fSector[0] = fSector[1] = -1;
302   
303   fEvType = fRawReader->GetType();
304   if(fPosition==0){
305     //if(fEvType==7 || fEvType ==8){ //Physics or calibration event
306       //ReadEventHeader();
307       ReadCDHHeader();
308     //}
309     fCurrentCh=0; fCurrScCh=0; fNChannelsOn=0;
310     // Ch. debug
311     //printf("\n  AliZDCRawStream::Next() - ev. type %d",fEvType);
312   }
313   
314   // Ch. debug
315   //printf("\n  AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
316   
317   // *** End of ZDC event
318   if(fBuffer == 0xcafefade){
319     //printf("\n-> AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
320     return kFALSE;
321   }
322   
323   // -------------------------------------------
324   // --- DARC header
325   // -------------------------------------------
326   // If the CDH has been read then 
327   // the DARC header must follow
328   if(fIsDARCHeader){
329     //printf("\t ---- DARC header ----\n");
330     if(fIsCalib){
331       fDeadfaceOffset = 9;
332       fDeadbeefOffset = 25;
333       readScaler = kTRUE;
334     }
335     else{
336       fDeadfaceOffset = 1;
337       fDeadbeefOffset = 7;
338     }
339     fDataOffset = 1+fDeadbeefOffset;
340     fIsDARCHeader = kFALSE;
341   }
342
343     
344   // -------------------------------------------
345   // --- Start of data event
346   // --- decoding mapping of connected ADC ch.
347   // -------------------------------------------
348   // In the SOD event ADC ch. mapping is written
349   if(fEvType==10 && fSODReading){
350     //printf("\n-> AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
351     
352     if(fPosition>fDataOffset){
353       if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
354         if(fPosition==(fDataOffset+1)){ 
355            printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
356            fCurrentCh=0; fCurrScCh=0;   
357         }
358         else{
359           printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
360           //printf("AliZDCRawStream: fSODReading after SOD reading set to %d\n", fSODReading);
361           return kFALSE;
362         }
363       }
364       else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
365         fPosition++;
366         return kFALSE;
367       }
368       else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
369         fIsHeaderMapping = kTRUE;
370         fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
371         fModType = ((fBuffer & 0x7ff00)>>8); 
372         fADCNChannels = (fBuffer & 0xff);          // # of channels following the header
373         //
374         printf("  ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
375       }
376       else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
377         fADCChannel = ((fBuffer & 0x3fff0000)>>16);
378         fCabledSignal = (fBuffer&0xffff);
379         //
380         if(fModType==1){ // ******** ADCs ********************************
381            // Channel signal
382           if((fBuffer&0x40000000)>>30==0){ // high range chain ADC
383             fIsChMapping = kTRUE;
384             fMapADC[fCurrentCh][0] = fADCModule;
385             fMapADC[fCurrentCh][1] = fADCChannel;
386             fMapADC[fCurrentCh][2] = fCabledSignal;
387             //  - No. of channels on
388             fNChannelsOn++;
389             //
390             // Determining detector and sector
391             // -----------------------------------------
392             //  For the decoding of the following lines 
393             //  look the enum in AliZDCRawStream.h file
394             // -----------------------------------------
395             if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
396               || fCabledSignal==24 || fCabledSignal==48){
397               fMapADC[fCurrentCh][3] = 4; //ZNA
398               //
399               if(fCabledSignal==2 || fCabledSignal==26)       fMapADC[fCurrentCh][4]=0;
400               else if(fCabledSignal==3 || fCabledSignal==27)  fMapADC[fCurrentCh][4]=1;
401               else if(fCabledSignal==4 || fCabledSignal==28)  fMapADC[fCurrentCh][4]=2;
402               else if(fCabledSignal==5 || fCabledSignal==29)  fMapADC[fCurrentCh][4]=3;
403               else if(fCabledSignal==6 || fCabledSignal==30)  fMapADC[fCurrentCh][4]=4;
404               else if(fCabledSignal==24 || fCabledSignal==48) fMapADC[fCurrentCh][4]=5; //Reference PTM
405             }
406             else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
407               fMapADC[fCurrentCh][3] = 5; //ZPA
408               //
409               if(fCabledSignal==7 || fCabledSignal==31)       fMapADC[fCurrentCh][4]=0;
410               else if(fCabledSignal==8 || fCabledSignal==32)  fMapADC[fCurrentCh][4]=1;
411               else if(fCabledSignal==9 || fCabledSignal==33)  fMapADC[fCurrentCh][4]=2;
412               else if(fCabledSignal==10 || fCabledSignal==34) fMapADC[fCurrentCh][4]=3;
413               else if(fCabledSignal==11 || fCabledSignal==35) fMapADC[fCurrentCh][4]=4;
414             }
415             else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
416                || fCabledSignal==25 || fCabledSignal==49){
417               fMapADC[fCurrentCh][3] = 1; //ZNC
418               //
419               if(fCabledSignal==12 || fCabledSignal==36)      fMapADC[fCurrentCh][4]=0;
420               else if(fCabledSignal==13 || fCabledSignal==37) fMapADC[fCurrentCh][4]=1;
421               else if(fCabledSignal==14 || fCabledSignal==38) fMapADC[fCurrentCh][4]=2;
422               else if(fCabledSignal==15 || fCabledSignal==39) fMapADC[fCurrentCh][4]=3;
423               else if(fCabledSignal==16 || fCabledSignal==40) fMapADC[fCurrentCh][4]=4;
424               else if(fCabledSignal==25 || fCabledSignal==49) fMapADC[fCurrentCh][4]=5; //Reference PTM
425             }
426             else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
427               fMapADC[fCurrentCh][3] = 2; //ZPC
428               //
429               if(fCabledSignal==17 || fCabledSignal==41)      fMapADC[fCurrentCh][4]=0;
430               else if(fCabledSignal==18 || fCabledSignal==42) fMapADC[fCurrentCh][4]=1;
431               else if(fCabledSignal==19 || fCabledSignal==43) fMapADC[fCurrentCh][4]=2;
432               else if(fCabledSignal==20 || fCabledSignal==44) fMapADC[fCurrentCh][4]=3;
433               else if(fCabledSignal==21 || fCabledSignal==45) fMapADC[fCurrentCh][4]=4;
434             }
435             else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
436               fMapADC[fCurrentCh][3] = 3; // ZEM
437               //
438               if(fCabledSignal==22 || fCabledSignal==46)      fMapADC[fCurrentCh][4]=1;
439               else if(fCabledSignal==23 || fCabledSignal==47) fMapADC[fCurrentCh][4]=2;
440             }
441             //Ch. debug
442             //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
443             //printf("  det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
444             //
445             fCurrentCh++;
446             //
447           } // high range channels
448         }// ModType=1 (ADC mapping)
449         else if(fModType==2){  // ******** VME scaler **************************
450           fIsChMapping = kTRUE;
451           fScalerMap[fCurrScCh][0] = fADCModule;
452           fScalerMap[fCurrScCh][1] = fADCChannel;
453           fScalerMap[fCurrScCh][2] = fCabledSignal;
454           //
455           // Determining detector and sector
456           // -----------------------------------------
457           //  For the decoding of the following lines 
458           //  look the enum in AliZDCRawStream.h file
459           // -----------------------------------------
460           // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
461           if(fCabledSignal>=2 && fCabledSignal<=6){
462             fScalerMap[fCurrScCh][3] = 4; //ZNA
463             //
464             if(fCabledSignal==2 )      fScalerMap[fCurrScCh][4]=0;
465             else if(fCabledSignal==3)  fScalerMap[fCurrScCh][4]=1;
466             else if(fCabledSignal==4)  fScalerMap[fCurrScCh][4]=2;
467             else if(fCabledSignal==5)  fScalerMap[fCurrScCh][4]=3;
468             else if(fCabledSignal==6)  fScalerMap[fCurrScCh][4]=4;
469           }
470           else if(fCabledSignal>=7 && fCabledSignal<=11){
471             fScalerMap[fCurrScCh][3] = 5; //ZPA
472             //
473             if(fCabledSignal==7 )      fScalerMap[fCurrScCh][4]=0;
474             else if(fCabledSignal==8)  fScalerMap[fCurrScCh][4]=1;
475             else if(fCabledSignal==9)  fScalerMap[fCurrScCh][4]=2;
476             else if(fCabledSignal==10) fScalerMap[fCurrScCh][4]=3;
477             else if(fCabledSignal==11) fScalerMap[fCurrScCh][4]=4;
478           }
479           else if(fCabledSignal>=12 && fCabledSignal<=16){
480             fScalerMap[fCurrScCh][3] = 1; //ZNC
481             //
482             if(fCabledSignal==12)      fScalerMap[fCurrScCh][4]=0;
483             else if(fCabledSignal==13) fScalerMap[fCurrScCh][4]=1;
484             else if(fCabledSignal==14) fScalerMap[fCurrScCh][4]=2;
485             else if(fCabledSignal==15) fScalerMap[fCurrScCh][4]=3;
486             else if(fCabledSignal==16) fScalerMap[fCurrScCh][4]=4;
487           }
488           else if(fCabledSignal>=17 && fCabledSignal<=21){
489             fScalerMap[fCurrScCh][3] = 2; //ZPC
490             //
491             if(fCabledSignal==17)      fScalerMap[fCurrScCh][4]=0;
492             else if(fCabledSignal==18) fScalerMap[fCurrScCh][4]=1;
493             else if(fCabledSignal==19) fScalerMap[fCurrScCh][4]=2;
494             else if(fCabledSignal==20) fScalerMap[fCurrScCh][4]=3;
495             else if(fCabledSignal==21) fScalerMap[fCurrScCh][4]=4;
496           }
497           else if(fCabledSignal==22 || fCabledSignal==23){
498             fScalerMap[fCurrScCh][3] = 3; // ZEM
499             //
500             if(fCabledSignal==22 )     fScalerMap[fCurrScCh][4]=1;
501             else if(fCabledSignal==23) fScalerMap[fCurrScCh][4]=2;
502           }
503           // Ch debug.
504           //printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
505           //if(fCabledSignal!=0 && fCabledSignal!=1) printf("  det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
506           //else printf("  Signal void/not connected\n");
507           
508           fCurrScCh++;
509         }
510         else if(fModType==3){ // **** scalers from trigger card
511           //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);         
512         }
513         else if(fModType==4){ // **** trigger history from trigger card
514           //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
515         }
516         else if(fModType==5){ // **** pattern unit
517           //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
518         }
519       }//reading channel mapping
520     }
521     fPosition++;
522     return kTRUE;
523   } // SOD event
524   
525   // -------------------------------------------
526   // --- DARC data
527   // -------------------------------------------
528   if(fPosition<fDeadfaceOffset){
529     fPosition++;
530     return kTRUE;
531   }
532   else if(fPosition==fDeadfaceOffset){
533     if(fBuffer != 0xdeadface){
534       AliWarning(" NO deadface after DARC data");
535       fRawReader->AddMajorErrorLog(kDARCError);  
536     }
537     else{
538       fPosition++;
539       return kTRUE;
540     }
541   }
542   
543   // -------------------------------------------
544   // --- DARC global data
545   // -------------------------------------------
546   else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset){
547     fPosition++;
548     return kTRUE;
549   }
550   else if(fPosition==fDeadbeefOffset){
551     if(fBuffer != 0xdeadbeef){
552       AliWarning(" NO deadbeef after DARC global data");
553       fRawReader->AddMajorErrorLog(kDARCError);  
554     }
555     else{
556       fPosition++;
557       return kTRUE;
558     }
559   }
560
561   // -------------------------------------------
562   // --- ZDC data
563   // --- ADCs + VME scaler + trigger card + P.U.
564   // -------------------------------------------
565   else if(fPosition>=fDataOffset){
566     
567     //printf("AliZDCRawStream: fSODReading = %d\n", fSODReading);
568     if(!fSODReading && !fIsMapRead) ReadChMap();
569     
570     // Not valid datum before the event 
571     // there MUST be a NOT valid datum before the event!!!
572     if(fPosition==fDataOffset){
573       //printf("\t **** ZDC data begin ****\n");
574       if((fBuffer & 0x07000000) != 0x06000000){
575         fRawReader->AddMajorErrorLog(kZDCDataError);
576       }
577       else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
578         fIsEventGood = kFALSE;
579       }
580     }
581     
582     // If the not valid datum isn't followed by the 1st ADC header
583     // the event is corrupted (i.e., 2 gates arrived before trigger)
584     else if(fPosition==fDataOffset+1){
585       if((fBuffer & 0x07000000) != 0x02000000){
586         AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
587         fRawReader->AddMajorErrorLog(kZDCDataError);
588         fIsEventGood = kFALSE;
589       }
590     }
591      
592     // Get geo address of current word
593     // - ADC GEO = 0, 1, 2, 3
594     // - VME scaler GEO = 8
595     // - PU GEO = 29
596     // - Trigger card scales GEO = 30
597     // - Trigger card history GEO = 31
598     fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
599     //printf("  AliZDCRawStream -> Module GEO address %d\n",fADCModule);
600     
601     // ************************************ ADC MODULES ************************************
602     if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo){
603       // *** ADC header
604       if((fBuffer & 0x07000000) == 0x02000000){
605         fIsADCHeader = kTRUE;
606         fADCNChannels = ((fBuffer & 0x00003f00)>>8);
607         //printf("  AliZDCRawStream -> ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
608       }
609       // *** ADC data word
610       else if((fBuffer & 0x07000000) == 0x00000000){
611         fIsADCDataWord = kTRUE;
612         fADCChannel = ((fBuffer & 0x1e0000) >> 17);
613         fADCGain = ((fBuffer & 0x10000) >> 16);       
614         fADCValue = (fBuffer & 0xfff);  
615         //
616         //printf("  AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
617         //  fADCModule,fADCChannel,fADCGain,fADCValue);
618         
619         // Checking if the channel map for the ADCs has been provided/read
620         if(fMapADC[0][0]==-1){
621           printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n");
622           return kFALSE;
623         }
624         //
625         /*for(Int_t ci=0; ci<kNch; ci++){
626           printf("  %d mod %d ch %d det %d sec %d\n",ci,fMapADC[ci][0],
627           fMapADC[ci][1], fMapADC[ci][3], fMapADC[ci][4]);
628         }*/
629                 
630         // Scan of the map to assign the correct volumes
631         Int_t foundMapEntry = kFALSE;
632         for(Int_t k=0; k<kNch; k++){
633            if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){
634              fSector[0] = fMapADC[k][3];
635              fSector[1] = fMapADC[k][4];
636              foundMapEntry = kTRUE;
637              break;
638            } 
639         }
640         if(foundMapEntry==kFALSE){
641           AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n",
642               fPosition,fADCModule,fADCChannel));
643         }
644         //
645         //printf("AliZDCRawStream -> ADCmod. %d ch. %d -> det %d sec %d\n",
646         //  fADCModule,fADCChannel,fSector[0],fSector[1]);
647         
648         // Final checks
649         if(foundMapEntry==kTRUE){
650           if(fSector[0]<1 || fSector[0]>5){
651             AliWarning(Form(" No valid detector assignment: %d",fSector[0]));
652             fRawReader->AddMajorErrorLog(kInvalidSector);
653           }
654           //
655           if(fSector[1]<0 || fSector[1]>5){
656             AliWarning(Form(" No valid sector assignment: %d",fSector[1]));
657             fRawReader->AddMajorErrorLog(kInvalidSector);
658           }
659           //
660           if(fADCModule<0 || fADCModule>3){
661             AliError(Form(" No valid ADC module: %d",fADCModule));
662             fRawReader->AddMajorErrorLog(kInvalidADCModule);
663           }
664         }
665
666         // Checking the underflow and overflow bits
667         if(fBuffer & 0x1000)       fIsUnderflow = kTRUE;
668         else if (fBuffer & 0x2000) fIsOverflow = kTRUE; 
669                 
670       }//ADC data word
671       // *** ADC EOB
672       else if((fBuffer & 0x07000000) == 0x04000000){
673         fIsADCEOB = kTRUE;
674         //printf("  AliZDCRawStream -> EOB --------------------------\n");
675       }
676     }//ADC module
677     // ************************************ VME MODULES ************************************
678     else if(fADCModule == kScalerGeo){
679       if(fBuffer & 0x04000000 && fIsScHeaderRead==kFALSE){ // *** Scaler header
680         fScGeo = (fBuffer & 0xf8000000)>>27;       
681         fScNWords = (fBuffer & 0x00fc0000)>>18;    
682         fScTriggerSource = (fBuffer & 0x00030000)>>16;     
683         fScTriggerNumber = (fBuffer & 0x0000ffff);
684         fIsScHeaderRead = kTRUE; 
685         fScStartCounter = (Int_t) (fPosition);
686         //Ch. debug
687         //printf("  AliZDCRawStream -> SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
688         //   fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
689       } 
690       else if(!(fBuffer & 0x04000000)){
691         fIsScEventGood = kFALSE;
692       }
693     }
694     else if(fADCModule == kPUGeo){
695       // still to be implemented!!! Not yet in data!!!
696     }
697     else if(fADCModule == kTrigScales){
698       
699     }
700     else if(fADCModule == kTrigHistory){
701     } 
702     //  Reading VME scaler data 
703     if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
704       fADCModule = fScGeo;
705       fScEvCounter = fBuffer;
706       Int_t nWords = (Int_t) (fScNWords);
707       if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
708       //Ch. debug
709       //printf("  AliZDCRawStream -> scaler datum %d", fScEvCounter);
710     }
711     
712   }
713   fPosition++;
714
715   return kTRUE;
716 }
717
718 //_____________________________________________________________________________
719 AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri) 
720 {
721   // Setting the storage
722   
723   AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri); 
724
725   return storage; 
726 }
727
728
729 //_____________________________________________________________________________
730 AliZDCChMap* AliZDCRawStream::GetChMap() const
731 {
732
733   // Getting calibration object for ZDC
734
735   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
736   if(!entry) AliFatal("No calibration data loaded!");  
737
738   AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
739   if(!calibdata) AliFatal("Wrong calibration object in calibration  file!");
740
741   return calibdata;
742 }