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