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