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