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