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