ALIROOT-5420 Changes for CDH v3
[u/mrichter/AliRoot.git] / ZDC / AliZDCRawStream.cxx
index 8b958f2..19e396c 100644 (file)
@@ -52,6 +52,7 @@ AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
   fIsADCEOB(kFALSE),
   fSODReading(kFALSE),
   fIsMapRead(kFALSE),
+  fReadCDH(kFALSE),
   fDeadfaceOffset(-1),
   fDeadbeefOffset(-1),
   fDataOffset(0),
@@ -71,6 +72,7 @@ AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
   fIsScHeaderRead(kFALSE),
   fScStartCounter(0),
   fScEvCounter(0),
+  fIsScalerWord(kFALSE),
   fDetPattern(0),
   fTrigCountNWords(0),
   fIsTriggerScaler(kFALSE),
@@ -99,9 +101,20 @@ AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
   fCurrentCh(-1),
   fCabledSignal(-1),
   fCurrScCh(-1),
+  fCurrTDCCh(-1),
   fIsADCEventGood(kTRUE),
   fIsL0BitSet(kTRUE),
-  fIsPileUpEvent(kFALSE)
+  fIsPileUpEvent(kFALSE),
+  fIsADDChannel(kFALSE),
+  fADDADCdatum(0),
+  fIsTDCHeaderRead(kFALSE),
+  fTDCStartCounter(0),
+  fIsZDCTDCHeader(kFALSE),
+  fIsZDCTDCdatum(kFALSE),
+  fZDCTDCdatum(0),
+  fIsADDTDCHeader(kFALSE),
+  fIsADDTDCdatum(kFALSE),
+  fADDTDCdatum(0)
 {
   // Create an object to read ZDC raw digits
   fRawReader->Reset();
@@ -111,7 +124,10 @@ AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
   for(Int_t i=0; i<kNch; i++){
     for(Int_t j=0; j<5; j++){
       fMapADC[i][j]=-1;
-      if(i<32) fScalerMap[i][j]=-1;
+      if(i<32){
+        fScalerMap[i][j]=-1;
+        if(j<3) fTDCMap[i][j]=-1;
+      }
     }
   }
   
@@ -136,6 +152,7 @@ AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
   fIsADCEOB(stream.fIsADCEOB), 
   fSODReading(stream.fSODReading),
   fIsMapRead(stream.fIsMapRead),
+  fReadCDH(stream.fReadCDH),
   fDeadfaceOffset(stream.GetDeadfaceOffset()),
   fDeadbeefOffset(stream.GetDeadbeefOffset()),
   fDataOffset(stream.GetDataOffset()),
@@ -155,6 +172,7 @@ AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
   fIsScHeaderRead(stream.fIsScHeaderRead),
   fScStartCounter(stream.fScStartCounter),
   fScEvCounter(stream.fScEvCounter),
+  fIsScalerWord(stream.fIsScalerWord),
   fDetPattern(stream.fDetPattern),
   fTrigCountNWords(stream.fTrigCountNWords),
   fIsTriggerScaler(stream.fIsTriggerScaler),
@@ -183,10 +201,20 @@ AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
   fCurrentCh(stream.fCurrentCh),
   fCabledSignal(stream.GetCabledSignal()),
   fCurrScCh(stream.fCurrScCh),
+  fCurrTDCCh(stream.fCurrTDCCh),
   fIsADCEventGood(stream.fIsADCEventGood),
   fIsL0BitSet(stream.fIsL0BitSet),
-  fIsPileUpEvent(stream.fIsPileUpEvent)
-
+  fIsPileUpEvent(stream.fIsPileUpEvent),
+  fIsADDChannel(stream.fIsADDChannel),
+  fADDADCdatum(stream.fADDADCdatum),
+  fIsTDCHeaderRead(stream.fIsTDCHeaderRead),
+  fTDCStartCounter(stream.fTDCStartCounter),
+  fIsZDCTDCHeader(stream.fIsZDCTDCHeader),
+  fIsZDCTDCdatum(stream.fIsZDCTDCdatum),
+  fZDCTDCdatum(stream.fZDCTDCdatum),
+  fIsADDTDCHeader(stream.fIsADDTDCHeader),
+  fIsADDTDCdatum(stream.fIsADDTDCdatum),
+  fADDTDCdatum(stream.fADDTDCdatum)
 {
   // Copy constructor
   const int kNch = 48;
@@ -222,13 +250,13 @@ void AliZDCRawStream::ReadChMap()
 {
   // Reading channel map
   const int kNch = 48;
-  //printf("\t Reading ZDC ADC mapping from OCDB\n");
+  AliDebug(2,"\t Reading ZDC ADC mapping from OCDB\n");
   AliZDCChMap * chMap = GetChMap();
   //chMap->Print("");
   for(Int_t i=0; i<kNch; i++){
     fMapADC[i][0] = chMap->GetADCModule(i);
     fMapADC[i][1] = chMap->GetADCChannel(i);
-    fMapADC[i][2] = -1;
+    fMapADC[i][2] = chMap->GetADCSignalCode(i);
     fMapADC[i][3] = chMap->GetDetector(i);
     fMapADC[i][4] = chMap->GetSector(i);
   }
@@ -246,33 +274,33 @@ void AliZDCRawStream::ReadCDHHeader()
       return;
   }
   else{
-    printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
+    //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
 
     UChar_t message = header->GetAttributes();
-    printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
+    //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
     
-    if(message == 0x0){ // PHYSICS RUN
+    if((message & 0xf0) == 0x0){ // PHYSICS RUN
        //printf("\t PHYSICS RUN raw data found\n");
     }
-    else if(message == 0x10){ // COSMIC RUN
+    else if((message & 0xf0) == 0x10){ // COSMIC RUN
        //printf("\t STANDALONE_COSMIC RUN raw data found\n");
     }
-    else if(message == 0x20){ // PEDESTAL RUN
+    else if((message & 0xf0) == 0x20){ // PEDESTAL RUN
        //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
     }
-    else if(message == 0x30){ // LASER RUN
+    else if((message & 0xf0) == 0x30){ // LASER RUN
        //printf("\t STANDALONE_LASER RUN raw data found\n");
     }
-    else if(message == 0x40){ // CALIBRATION_CENTRAL RUN
+    else if((message & 0xf0) == 0x40){ // CALIBRATION_CENTRAL RUN
        //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
     }
-    else if(message == 0x50){ // CALIBRATION_SEMICENTRAL
+    else if((message & 0xf0) == 0x50){ // CALIBRATION_SEMICENTRAL
        //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
     }
-    else if(message == 0x60){ // CALIBRATION_MB
+    else if((message & 0xf0) == 0x60){ // CALIBRATION_MB
        //printf("\t CALIBRATION_MB RUN raw data found\n");
     }
-    else if(message == 0x70){ // CALIBRATION_EMD
+    else if((message & 0xf0) == 0x70){ // CALIBRATION_EMD
        //printf("\t CALIBRATION_EMD RUN raw data found\n");
     }
     // *** Checking the bit indicating the used readout card
@@ -280,18 +308,20 @@ void AliZDCRawStream::ReadCDHHeader()
     if((message & 0x08) == 0){  // ** DARC card
        fReadOutCard = 0;
        fIsDARCHeader = kTRUE;
+       //AliInfo("\t ZDC readout card used: DARC");
     }
-    else if((message & 0x08) == 1){  // ** ZRC card
+    else if((message & 0x08) == 0x08){  // ** ZRC card
        fReadOutCard = 1;
+       //AliInfo("\t ZDC readout card used: ZRC");
     }
 
     if(header->GetL1TriggerMessage() & 0x1){ // Calibration bit set in CDH
       fIsCalib = kTRUE;
     }
-    printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
-    printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);    
+    //printf("\t AliZDCRawStream::ReadCDHHeader -> L1TriggerMessage %x\n",header->GetL1TriggerMessage());
+    //printf("\t AliZDCRawStream::ReadCDHHeader -> Calibration bit = %d\n",fIsCalib);    
     
-    UInt_t status = header->GetStatus();
+/*    UInt_t status = header->GetStatus();
     //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
     if((status & 0x000f) == 0x0001){
       AliDebug(2,"CDH -> DARC trg0 overlap error");
@@ -336,6 +366,7 @@ void AliZDCRawStream::ReadCDHHeader()
       AliDebug(2,"CDH -> DARC other error");
       fRawReader->AddMajorErrorLog(kDARCError);
     }
+    */
   }
   
 }
@@ -348,31 +379,29 @@ Bool_t AliZDCRawStream::Next()
 
   if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
   const int kNch = 48;
-  Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kPUGeo=29, kTrigScales=30, kTrigHistory=31;
+  //
   fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE; 
   fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
-  fIsUnderflow = kFALSE; fIsOverflow = kFALSE; 
+  fIsZDCTDCdatum = kFALSE; fIsADDChannel = kFALSE; fIsADDTDCdatum=kFALSE;
+  fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE;
   fSector[0] = fSector[1] = -1;
-//  fTrigCountNWords = 9; fTrigHistNWords = 2;
   for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
 
   fEvType = fRawReader->GetType();
   if(fPosition==0){
-    //if(fEvType==7 || fEvType ==8){ //Physics or calibration event
-      //ReadEventHeader();
-      ReadCDHHeader();
-    //}
-    fCurrentCh=0; fCurrScCh=0; fNChannelsOn=0;
+    ReadCDHHeader();
+    // Needed to read simulated raw data (temporary solution?)
+    if(!fReadCDH) fReadOutCard=1;
+    fCurrentCh=0; fCurrScCh=0;  fCurrTDCCh=0;fNChannelsOn=0;
     // Ch. debug
     //printf("\n  AliZDCRawStream::Next() - ev. type %d",fEvType);
   }
-  
   // Ch. debug
   //printf("\n  AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
   
   // *** End of ZDC event
   if(fBuffer == 0xcafefade){
-    //printf("\n-> AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
+    //printf("\n  AliZDCRawStream::Next() ***** End of ZDC event *****\n\n");
     return kFALSE;
   }
   
@@ -394,31 +423,31 @@ Bool_t AliZDCRawStream::Next()
     fDataOffset = 1+fDeadbeefOffset;
     fIsDARCHeader = kFALSE;
   }
-
     
   // ---------------------------------------------
   // --- Start of data event (SOD)             ---
   // --- decoding mapping of connected ADC ch. ---
   // ---------------------------------------------
   // In the SOD event ADC ch. mapping is written
-  if(fEvType==10 && fSODReading){
-    //printf("\n-> AliZDCRawStream::Next() - fBuffer[%d] = %x\n",fPosition, fBuffer);
+  if(fEvType==10){
+   if(fSODReading){
     
-    if(fPosition>fDataOffset){
+    if(fPosition>=fDataOffset){
       if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
-        if(fPosition==(fDataOffset+1)){ 
+        // DARC 1st datum @ fDataOffset+1 \ ZRC 1st valid datum @ fDataOffset=0
+        if((fPosition==fDataOffset+1) || (fPosition==fDataOffset)){ 
           printf("\n\n ------ AliZDCRawStream -> Reading mapping from StartOfData event ------\n");
-          fCurrentCh=0; fCurrScCh=0;   
+          fCurrentCh=0; fCurrScCh=0; fCurrTDCCh=0;     
         }
        else{
          printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
-          //printf("AliZDCRawStream: fSODReading after SOD reading set to %d\n", fSODReading);
+          fSODReading = kFALSE;
          return kFALSE;
        }
       }
       else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
         fPosition++;
-       return kFALSE;
+       return kFALSE; // !!!!!!!!!!!!!!!!!!!!!  For the moment thresholds are not read
       }
       else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
         fIsHeaderMapping = kTRUE;
@@ -432,9 +461,9 @@ Bool_t AliZDCRawStream::Next()
        fADCChannel = ((fBuffer & 0x3fff0000)>>16);
        fCabledSignal = (fBuffer&0xffff);
         //
-       if(fModType==1){ // ******** ADCs ********************************
-           // Channel signal
-         if((fBuffer&0x40000000)>>30==0){ // high range chain ADC
+       if(fModType == kV965){ // ******** ADCs ********************************
+          // Channel signal
+         if((fBuffer&0x40000000)>>30==0 && fADCModule<=kLastADCGeo){ // *ZDC* high range chain ADC
             fIsChMapping = kTRUE;
            fMapADC[fCurrentCh][0] = fADCModule;
            fMapADC[fCurrentCh][1] = fADCChannel;
@@ -451,47 +480,47 @@ Bool_t AliZDCRawStream::Next()
              || fCabledSignal==24 || fCabledSignal==48){
              fMapADC[fCurrentCh][3] = 4; //ZNA
              //
-             if(fCabledSignal==2 || fCabledSignal==26)       fMapADC[fCurrentCh][4]=0;
-             else if(fCabledSignal==3 || fCabledSignal==27)  fMapADC[fCurrentCh][4]=1;
-             else if(fCabledSignal==4 || fCabledSignal==28)  fMapADC[fCurrentCh][4]=2;
-             else if(fCabledSignal==5 || fCabledSignal==29)  fMapADC[fCurrentCh][4]=3;
-             else if(fCabledSignal==6 || fCabledSignal==30)  fMapADC[fCurrentCh][4]=4;
-             else if(fCabledSignal==24 || fCabledSignal==48) fMapADC[fCurrentCh][4]=5; //Reference PTM
+             if(fCabledSignal==kZNAC || fCabledSignal==kZNACoot)       fMapADC[fCurrentCh][4]=0;
+             else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1oot)  fMapADC[fCurrentCh][4]=1;
+             else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2oot)  fMapADC[fCurrentCh][4]=2;
+             else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3oot)  fMapADC[fCurrentCh][4]=3;
+             else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4oot)  fMapADC[fCurrentCh][4]=4;
+             else if(fCabledSignal==kZDCAMon || fCabledSignal==kZDCAMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
            }
            else if((fCabledSignal>=7 && fCabledSignal<=11) || (fCabledSignal>=31 && fCabledSignal<=35)){
              fMapADC[fCurrentCh][3] = 5; //ZPA
              //
-             if(fCabledSignal==7 || fCabledSignal==31)       fMapADC[fCurrentCh][4]=0;
-             else if(fCabledSignal==8 || fCabledSignal==32)  fMapADC[fCurrentCh][4]=1;
-             else if(fCabledSignal==9 || fCabledSignal==33)  fMapADC[fCurrentCh][4]=2;
-             else if(fCabledSignal==10 || fCabledSignal==34) fMapADC[fCurrentCh][4]=3;
-             else if(fCabledSignal==11 || fCabledSignal==35) fMapADC[fCurrentCh][4]=4;
+             if(fCabledSignal==kZPAC || fCabledSignal==kZPACoot)      fMapADC[fCurrentCh][4]=0;
+             else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1oot) fMapADC[fCurrentCh][4]=1;
+             else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2oot) fMapADC[fCurrentCh][4]=2;
+             else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3oot) fMapADC[fCurrentCh][4]=3;
+             else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4oot) fMapADC[fCurrentCh][4]=4;
            }
            else if((fCabledSignal>=12 && fCabledSignal<=16) || (fCabledSignal>=36 && fCabledSignal<=40)
               || fCabledSignal==25 || fCabledSignal==49){
              fMapADC[fCurrentCh][3] = 1; //ZNC
              //
-             if(fCabledSignal==12 || fCabledSignal==36)      fMapADC[fCurrentCh][4]=0;
-             else if(fCabledSignal==13 || fCabledSignal==37) fMapADC[fCurrentCh][4]=1;
-             else if(fCabledSignal==14 || fCabledSignal==38) fMapADC[fCurrentCh][4]=2;
-             else if(fCabledSignal==15 || fCabledSignal==39) fMapADC[fCurrentCh][4]=3;
-             else if(fCabledSignal==16 || fCabledSignal==40) fMapADC[fCurrentCh][4]=4;
-             else if(fCabledSignal==25 || fCabledSignal==49) fMapADC[fCurrentCh][4]=5; //Reference PTM
+             if(fCabledSignal==kZNCC || fCabledSignal==kZNCCoot)      fMapADC[fCurrentCh][4]=0;
+             else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1oot) fMapADC[fCurrentCh][4]=1;
+             else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2oot) fMapADC[fCurrentCh][4]=2;
+             else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3oot) fMapADC[fCurrentCh][4]=3;
+             else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4oot) fMapADC[fCurrentCh][4]=4;
+             else if(fCabledSignal==kZDCCMon || fCabledSignal==kZDCCMonoot) fMapADC[fCurrentCh][4]=5; //Reference PTM
            }
            else if((fCabledSignal>=17 && fCabledSignal<=21) || (fCabledSignal>=41 && fCabledSignal<=45)){
              fMapADC[fCurrentCh][3] = 2; //ZPC
              //
-             if(fCabledSignal==17 || fCabledSignal==41)      fMapADC[fCurrentCh][4]=0;
-             else if(fCabledSignal==18 || fCabledSignal==42) fMapADC[fCurrentCh][4]=1;
-             else if(fCabledSignal==19 || fCabledSignal==43) fMapADC[fCurrentCh][4]=2;
-             else if(fCabledSignal==20 || fCabledSignal==44) fMapADC[fCurrentCh][4]=3;
-             else if(fCabledSignal==21 || fCabledSignal==45) fMapADC[fCurrentCh][4]=4;
+             if(fCabledSignal==kZPCC || fCabledSignal==kZPCCoot)   fMapADC[fCurrentCh][4]=0;
+             else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1oot) fMapADC[fCurrentCh][4]=1;
+             else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2oot) fMapADC[fCurrentCh][4]=2;
+             else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3oot) fMapADC[fCurrentCh][4]=3;
+             else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4oot) fMapADC[fCurrentCh][4]=4;
            }
            else if(fCabledSignal==22 || fCabledSignal==23 || fCabledSignal==46 || fCabledSignal==47){
              fMapADC[fCurrentCh][3] = 3; // ZEM
              //
-             if(fCabledSignal==22 || fCabledSignal==46)      fMapADC[fCurrentCh][4]=1;
-             else if(fCabledSignal==23 || fCabledSignal==47) fMapADC[fCurrentCh][4]=2;
+             if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1oot)      fMapADC[fCurrentCh][4]=1;
+             else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2oot) fMapADC[fCurrentCh][4]=2;
            }
            //Ch. debug
            //printf("\tADC mod. %d ch. %d signal %d ",fADCModule,fADCChannel,fCabledSignal);
@@ -501,7 +530,7 @@ Bool_t AliZDCRawStream::Next()
            //
          } // high range channels
         }// ModType=1 (ADC mapping)
-        else if(fModType==2){  // ******** VME scaler **************************
+        else if(fModType == kV830){  // ******** VME scaler **************************
           fIsChMapping = kTRUE;
          fScalerMap[fCurrScCh][0] = fADCModule;
          fScalerMap[fCurrScCh][1] = fADCChannel;
@@ -513,132 +542,146 @@ Bool_t AliZDCRawStream::Next()
          //  look the enum in AliZDCRawStream.h file
          // -----------------------------------------
          // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
-         if(fCabledSignal>=2 && fCabledSignal<=6){
+         if((fCabledSignal>=2 && fCabledSignal<=6) ||
+            (fCabledSignal>=61 && fCabledSignal<=65)){
            fScalerMap[fCurrScCh][3] = 4; //ZNA
            //
-           if(fCabledSignal==2 )      fScalerMap[fCurrScCh][4]=0;
-           else if(fCabledSignal==3)  fScalerMap[fCurrScCh][4]=1;
-           else if(fCabledSignal==4)  fScalerMap[fCurrScCh][4]=2;
-           else if(fCabledSignal==5)  fScalerMap[fCurrScCh][4]=3;
-           else if(fCabledSignal==6)  fScalerMap[fCurrScCh][4]=4;
+           if(fCabledSignal==kZNAC || fCabledSignal==kZNACD)      fScalerMap[fCurrScCh][4]=0;
+           else if(fCabledSignal==kZNA1 || fCabledSignal==kZNA1D) fScalerMap[fCurrScCh][4]=1;
+           else if(fCabledSignal==kZNA2 || fCabledSignal==kZNA2D) fScalerMap[fCurrScCh][4]=2;
+           else if(fCabledSignal==kZNA3 || fCabledSignal==kZNA3D) fScalerMap[fCurrScCh][4]=3;
+           else if(fCabledSignal==kZNA4 || fCabledSignal==kZNA4D) fScalerMap[fCurrScCh][4]=4;
          }
-         else if(fCabledSignal>=7 && fCabledSignal<=11){
+         else if((fCabledSignal>=7 && fCabledSignal<=11) ||
+            (fCabledSignal>=66 && fCabledSignal<=70)){
            fScalerMap[fCurrScCh][3] = 5; //ZPA
            //
-           if(fCabledSignal==7 )      fScalerMap[fCurrScCh][4]=0;
-           else if(fCabledSignal==8)  fScalerMap[fCurrScCh][4]=1;
-           else if(fCabledSignal==9)  fScalerMap[fCurrScCh][4]=2;
-           else if(fCabledSignal==10) fScalerMap[fCurrScCh][4]=3;
-           else if(fCabledSignal==11) fScalerMap[fCurrScCh][4]=4;
+           if(fCabledSignal==kZPAC || fCabledSignal==kZPACD)      fScalerMap[fCurrScCh][4]=0;
+           else if(fCabledSignal==kZPA1 || fCabledSignal==kZPA1D) fScalerMap[fCurrScCh][4]=1;
+           else if(fCabledSignal==kZPA2 || fCabledSignal==kZPA2D) fScalerMap[fCurrScCh][4]=2;
+           else if(fCabledSignal==kZPA3 || fCabledSignal==kZPA3D) fScalerMap[fCurrScCh][4]=3;
+           else if(fCabledSignal==kZPA4 || fCabledSignal==kZPA4D) fScalerMap[fCurrScCh][4]=4;
          }
-         else if(fCabledSignal>=12 && fCabledSignal<=16){
+         else if((fCabledSignal>=12 && fCabledSignal<=16) ||
+            (fCabledSignal>=71 && fCabledSignal<=75)){
            fScalerMap[fCurrScCh][3] = 1; //ZNC
            //
-           if(fCabledSignal==12)      fScalerMap[fCurrScCh][4]=0;
-           else if(fCabledSignal==13) fScalerMap[fCurrScCh][4]=1;
-           else if(fCabledSignal==14) fScalerMap[fCurrScCh][4]=2;
-           else if(fCabledSignal==15) fScalerMap[fCurrScCh][4]=3;
-           else if(fCabledSignal==16) fScalerMap[fCurrScCh][4]=4;
+           if(fCabledSignal==kZNCC || fCabledSignal==kZNCCD)      fScalerMap[fCurrScCh][4]=0;
+           else if(fCabledSignal==kZNC1 || fCabledSignal==kZNC1D) fScalerMap[fCurrScCh][4]=1;
+           else if(fCabledSignal==kZNC2 || fCabledSignal==kZNC2D) fScalerMap[fCurrScCh][4]=2;
+           else if(fCabledSignal==kZNC3 || fCabledSignal==kZNC3D) fScalerMap[fCurrScCh][4]=3;
+           else if(fCabledSignal==kZNC4 || fCabledSignal==kZNC4D) fScalerMap[fCurrScCh][4]=4;
          }
-         else if(fCabledSignal>=17 && fCabledSignal<=21){
+         else if((fCabledSignal>=17 && fCabledSignal<=21) ||
+            (fCabledSignal>=76 && fCabledSignal<=80)){
            fScalerMap[fCurrScCh][3] = 2; //ZPC
            //
-           if(fCabledSignal==17)      fScalerMap[fCurrScCh][4]=0;
-           else if(fCabledSignal==18) fScalerMap[fCurrScCh][4]=1;
-           else if(fCabledSignal==19) fScalerMap[fCurrScCh][4]=2;
-           else if(fCabledSignal==20) fScalerMap[fCurrScCh][4]=3;
-           else if(fCabledSignal==21) fScalerMap[fCurrScCh][4]=4;
+           if(fCabledSignal==kZPCC || fCabledSignal==kZPCCD) fScalerMap[fCurrScCh][4]=0;
+           else if(fCabledSignal==kZPC1 || fCabledSignal==kZPC1D)  fScalerMap[fCurrScCh][4]=1;
+           else if(fCabledSignal==kZPC2 || fCabledSignal==kZPC2D)  fScalerMap[fCurrScCh][4]=2;
+           else if(fCabledSignal==kZPC3 || fCabledSignal==kZPC3D)  fScalerMap[fCurrScCh][4]=3;
+           else if(fCabledSignal==kZPC4 || fCabledSignal==kZPC4D)  fScalerMap[fCurrScCh][4]=4;
          }
-         else if(fCabledSignal==22 || fCabledSignal==23){
+         else if(fCabledSignal==22 || fCabledSignal==23 ||
+                 fCabledSignal==81 || fCabledSignal==82){
            fScalerMap[fCurrScCh][3] = 3; // ZEM
            //
-           if(fCabledSignal==22 )     fScalerMap[fCurrScCh][4]=1;
-           else if(fCabledSignal==23) fScalerMap[fCurrScCh][4]=2;
+           if(fCabledSignal==kZEM1 || fCabledSignal==kZEM1D)      fScalerMap[fCurrScCh][4]=1;
+           else if(fCabledSignal==kZEM2 || fCabledSignal==kZEM2D) fScalerMap[fCurrScCh][4]=2;
          }
          // Ch debug.
-         //printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
-         //if(fCabledSignal!=0 && fCabledSignal!=1) printf("  det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
-         //else printf("  Signal void/not connected\n");
+         /*printf("\t VME scaler mod. %d ch. %d, signal %d",fScalerMap[fCurrScCh][0],fADCChannel,fCabledSignal);
+         if(fCabledSignal!=0 && fCabledSignal!=1) printf("  det. %d sec. %d\n",fScalerMap[fCurrScCh][3],fScalerMap[fCurrScCh][4]);
+         else printf("  Signal void/not connected\n");*/
          
           fCurrScCh++;
         }
-       else if(fModType==3){ // **** scalers from trigger card
+       else if(fModType==KV1290 && fADCModule==kZDCTDCGeo){  // ******** ZDC TDC **************************
+          fIsChMapping = kTRUE;
+         fTDCMap[fCurrTDCCh][0] = fADCModule;
+         fTDCMap[fCurrTDCCh][1] = fADCChannel;
+         fTDCMap[fCurrTDCCh][2] = fCabledSignal;
+          
+         fCurrTDCCh++;
+         
+         // Ch debug.
+         //printf("\tZDC TDC: mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);        
+        }
+       /*else if(fModType == kTRG){ // **** scalers from trigger card
          //printf("\t Trigger scaler mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);         
         }
-       else if(fModType==4){ // **** trigger history from trigger card
+       else if(fModType == kTRGI){ // **** trigger history from trigger card
          //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
         }
-       else if(fModType==5){ // **** pattern unit
+       else if(fModType == kPU){ // **** pattern unit
          //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
-        }
+        }*/
       }//reading channel mapping
     }
-    fPosition++;
-    return kTRUE;
+   } // if fSODREading
+   fPosition++;
+   return kTRUE;
   } // ------------------------------- SOD event
   
   // -------------------------------------------
   // --- DARC data
   // -------------------------------------------
-  if(fReadOutCard == 0){
-    if(fPosition<fDeadfaceOffset){
+  if(fPosition<fDeadfaceOffset && fReadOutCard==0){
+    fPosition++;
+    return kTRUE;
+  }
+  else if(fPosition==fDeadfaceOffset && fReadOutCard==0){
+    if(fBuffer != 0xdeadface){
+      //AliWarning(" NO deadface after DARC data");
+      fRawReader->AddMajorErrorLog(kDARCError); 
+    }
+    else{
       fPosition++;
       return kTRUE;
     }
-    else if(fPosition==fDeadfaceOffset){
-      if(fBuffer != 0xdeadface){
-        AliWarning(" NO deadface after DARC data");
-        fRawReader->AddMajorErrorLog(kDARCError); 
-      }
-      else{
-        fPosition++;
-        return kTRUE;
-      }
+  }
+  else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset && fReadOutCard==0){
+    fPosition++;
+    return kTRUE;
+  }
+  else if(fPosition==fDeadbeefOffset && fReadOutCard==0){
+    if(fBuffer != 0xdeadbeef){
+      //AliWarning(" NO deadbeef after DARC global data");
+      fRawReader->AddMajorErrorLog(kDARCError);  
+      fPosition++;
+      return kFALSE;
     }
-    else if(fPosition>fDeadfaceOffset && fPosition<fDeadbeefOffset){
+    else{
       fPosition++;
       return kTRUE;
     }
-    else if(fPosition==fDeadbeefOffset){
-      if(fBuffer != 0xdeadbeef){
-        AliWarning(" NO deadbeef after DARC global data");
-        fRawReader->AddMajorErrorLog(kDARCError);  
-        fPosition++;
-        return kFALSE;
-      }
-      else{
-        fPosition++;
-        return kTRUE;
-      }
-    }
-  } // ------------------------------- DARC data
+  } // ------------------------------- End of DARC data
   
-  // -------------------------------------------
+  // ---------------------------------------------
   // --- ZDC data
   // --- ADCs + VME scaler + trigger card + P.U.
-  // -------------------------------------------
+  // ---------------------------------------------
   else if(fPosition>=fDataOffset){
     
-    //printf("AliZDCRawStream: fSODReading = %d\n", fSODReading);
     if(!fSODReading && !fIsMapRead) ReadChMap();
     
     //  !!!!!!!!!!!!!!! DARC readout card only !!!!!!!!!!!
     // Not valid datum before the event 
     // there MUST be a NOT valid datum before the event!!!
     if(fReadOutCard==0){
-      if(fPosition==fDataOffset){ // and con la darc
+      if(fPosition==fDataOffset){ 
         //printf("\t **** ZDC data begin ****\n");
         if((fBuffer & 0x07000000) != 0x06000000){
           fRawReader->AddMajorErrorLog(kZDCDataError);
         }
-        else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
-          fIsADCEventGood = kFALSE;
-        }
+        //else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
+        //  fIsADCEventGood = kFALSE;
+        //}
       }
     
       // If the not valid datum isn't followed by the 1st ADC header
       // the event is corrupted (i.e., 2 gates arrived before trigger)
-      else if(fPosition==fDataOffset+1){ // and con la darc
+      else if(fPosition==fDataOffset+1){ 
         if((fBuffer & 0x07000000) != 0x02000000){
           AliWarning("ZDC ADC -> The not valid datum is NOT followed by an ADC header!");
           fRawReader->AddMajorErrorLog(kZDCDataError);
@@ -650,15 +693,13 @@ Bool_t AliZDCRawStream::Next()
     }
      
     // Get geo address of current word
-    // - ADC GEO = 0, 1, 2, 3
-    // - VME scaler GEO = 8
-    // - PU GEO = 29
-    // - Trigger card scales GEO = 30
-    // - Trigger card history GEO = 31
-    fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
+    if(fIsTDCHeaderRead && fIsZDCTDCHeader) fADCModule = kZDCTDCGeo;
+    else if(fIsTDCHeaderRead && fIsADDTDCHeader) fADCModule = kADDTDCGeo;
+    else fADCModule = (Int_t) ((fBuffer & 0xf8000000)>>27);
     
     // ************************************ ADC MODULES ************************************
-    if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo){
+    if(fADCModule>=kFirstADCGeo && fADCModule<=kLastADCGeo && 
+       !fIsTriggerHistory && !fIsScHeaderRead && !fIsTriggerScaler){
       // *** ADC header
       if((fBuffer & 0x07000000) == 0x02000000){
         fIsADCHeader = kTRUE;
@@ -673,7 +714,7 @@ Bool_t AliZDCRawStream::Next()
         fADCValue = (fBuffer & 0xfff);  
        //
        //printf("  AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
-       //  fADCModule,fADCChannel,fADCGain,fADCValue);
+         //fADCModule,fADCChannel,fADCGain,fADCValue);
        
        // Checking if the channel map for the ADCs has been provided/read
        if(fMapADC[0][0]==-1){
@@ -696,16 +737,13 @@ Bool_t AliZDCRawStream::Next()
             break;
           } 
        }
-       if(foundMapEntry==kFALSE){
+       if(foundMapEntry==kFALSE && fEvType==7){
          AliWarning(Form(" No valid entry in ADC mapping for raw data %d ADCmod. %d ch. %d\n",
              fPosition,fADCModule,fADCChannel));
        }
-       //
-       //printf("AliZDCRawStream -> ADCmod. %d ch. %d -> det %d sec %d\n",
-       //  fADCModule,fADCChannel,fSector[0],fSector[1]);
-       
+
        // Final checks
-       if(foundMapEntry==kTRUE){
+       if(foundMapEntry==kTRUE && fEvType==7){
          if(fSector[0]<1 || fSector[0]>5){
             AliWarning(Form(" No valid detector assignment: %d",fSector[0]));
             fRawReader->AddMajorErrorLog(kInvalidSector);
@@ -730,9 +768,51 @@ Bool_t AliZDCRawStream::Next()
       // *** ADC EOB
       else if((fBuffer & 0x07000000) == 0x04000000){
         fIsADCEOB = kTRUE;
-       //printf("  AliZDCRawStream -> EOB --------------------------\n");
+       //printf("  AliZDCRawStream -> ADC EOB --------------------------\n");
       }
     }//ADC module
+    // ********************************* ADD ADC *********************************
+    else if(fADCModule == kADDADCGeo){
+      // *** ADC header
+      if((fBuffer & 0x07000000) == 0x02000000){
+        fIsADCHeader = kTRUE;
+       fADCNChannels = ((fBuffer & 0x00003f00)>>8);
+       //printf("  AliZDCRawStream -> ADD ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
+      }
+      // *** ADC data word
+      else if((fBuffer & 0x07000000) == 0x00000000){
+        fIsADDChannel = kTRUE;
+        fADCChannel = ((fBuffer & 0x1e0000) >> 17);
+        fADCGain = ((fBuffer & 0x10000) >> 16);       
+        fADCValue = (fBuffer & 0xfff);  
+       //
+       //printf("  ADD ADC DATUM -> mod. %d ch. %d gain %d value %d\n",
+       //  fADCModule,fADCChannel,fADCGain,fADCValue);
+      }
+      // *** ADC EOB
+      else if((fBuffer & 0x07000000) == 0x04000000){
+        fIsADCEOB = kTRUE;
+       //printf("  AliZDCRawStream -> ADD ADC EOB --------------------------\n");
+      }
+    }
+    // ********************************* TDC *********************************
+    else if(fADCModule==kTDCFakeGeo && fIsTDCHeaderRead==kFALSE){
+      // *** TDC header
+      fIsTDCHeaderRead = kTRUE;
+      fTDCStartCounter = fPosition;
+      // GEO address from TDC header
+      fADCModule = (Int_t) (fBuffer & 0x1f);
+      if(fADCModule==kZDCTDCGeo){ // *** ZDC TDC
+        fIsZDCTDCHeader = kTRUE;
+        //Ch. debug
+        //printf("  AliZDCRawStream -> ZDC TDC header: mod.%d\n",fADCModule);
+      }
+      else if(fADCModule==kADDTDCGeo){ // *** ADD TDC
+        fIsADDTDCHeader = kTRUE;
+        //Ch. debug
+        //printf("  AliZDCRawStream -> ADD TDC: mod.%d\n",fADCModule);
+      }
+    }
     // ********************************* VME SCALER HEADER *********************************
     else if(fADCModule == kScalerGeo){
       if(fBuffer & 0x04000000 && fIsScHeaderRead==kFALSE){ // *** Scaler header
@@ -746,9 +826,10 @@ Bool_t AliZDCRawStream::Next()
         //printf("  AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
         //   fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
       } 
-      else if(!(fBuffer & 0x04000000)){
-        fIsScEventGood = kFALSE;
-      }
+      // Commented by C.O. & M.G. (23/09/2011)
+      //else if(!(fBuffer & 0x04000000) && fIsScHeaderRead==kFALSE){
+      //  fIsScEventGood = kFALSE;
+      //}
     }
     // *********************************** PATTERN UNIT ***********************************
     else if(fADCModule == kPUGeo){
@@ -782,17 +863,55 @@ Bool_t AliZDCRawStream::Next()
     // ********************************** VME SCALER DATA **********************************
     //  Reading VME scaler data 
     if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
-      fADCModule = kScalerGeo;
+      fADCModule=kScalerGeo; 
+      fIsADCDataWord=kFALSE; 
+      fIsScalerWord=kTRUE;
       fScEvCounter = fBuffer;
       Int_t nWords = (Int_t) (fScNWords);
       if(fPosition == fScStartCounter+nWords) fIsScHeaderRead = kFALSE;
       //Ch. debug
-      //printf("  AliZDCRawStream -> scaler datum %d", fScEvCounter);
+      //printf("  AliZDCRawStream -> scaler datum %x \n", fScEvCounter);
+    }
+    // ********************************** ZDC TDC DATA **********************************
+    //  ZDC TDC data
+    if(fIsTDCHeaderRead && fIsZDCTDCHeader && fPosition>=fTDCStartCounter+1){ 
+      fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
+      if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
+        fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
+       fIsZDCTDCdatum = kTRUE;
+       fZDCTDCdatum = (Int_t) (fBuffer & 0x1fffff);
+        // Ch. debug
+        //printf("  AliZDCRawStream -> ZDC TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fZDCTDCdatum);
+      }
+      if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
+       // Trailer
+       fIsTDCHeaderRead = kFALSE;
+        // Ch. debug
+        //printf("  AliZDCRawStream -> ZDC TDC global trailer\n");
+      }
+    }
+    // ********************************** ADD TDC DATA **********************************
+    //  ADD TDC data
+    if(fIsTDCHeaderRead && fIsADDTDCHeader && fPosition>=fTDCStartCounter+1){ 
+      fIsADCDataWord=kFALSE; fIsScalerWord=kFALSE;
+      if(((fBuffer & 0xf0000000)==0x00000000) && (((fBuffer & 0x08000000) >> 27) == 0)){ // TDC datum
+        fADCChannel = (Int_t) ((fBuffer & 0x3e00000) >> 21);
+       fIsADDTDCdatum = kTRUE;
+       fADDTDCdatum = (Int_t) (fBuffer & 0x1fffff);
+        // Ch. debug
+        //printf("  AliZDCRawStream -> ADD TDC mod. %d ch. %d datum %d\n",fADCModule,fADCChannel,fADDTDCdatum);
+      }
+      if(((fBuffer & 0xf0000000) == 0x80000000) && ((fBuffer & 0x08000000) >> 27) == 0){
+       // Trailer
+       fIsTDCHeaderRead = kFALSE;
+        // Ch. debug
+        //printf("  AliZDCRawStream -> ADD TDC global trailer\n");
+      }
     }
     // ******************************** TRIGGER SCALER DATA ********************************
     //  Reading trigger scaler data 
     if(fIsTriggerScaler && fPosition>=fTrigCountStart+1){
-      fADCModule = kTrigScales;
+      fADCModule = kTrigScales; fIsADCDataWord = kFALSE;       
       if(fPosition == fTrigCountStart+1)      fMBTrigInput = fBuffer;              
       else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;                 
       else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
@@ -811,7 +930,7 @@ Bool_t AliZDCRawStream::Next()
     // ******************************* TRIGGER HISTORY WORDS ******************************
     //  Reading trigger history
     if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
-       fADCModule = kTrigHistory;      
+       fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;     
        if(fPosition == fTrigHistStart+1){
          fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
          fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;        
@@ -839,7 +958,7 @@ Bool_t AliZDCRawStream::Next()
           else{
             fIsPileUpEvent = kTRUE;
            printf("  AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
-               fPileUpBit1stWord, fPileUpBit2ndWord);
+               fPileUpBit1stWord, fPileUpBit2ndWord);
           }
          // (2) both history word L0 bits must be = 1
           if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
@@ -850,7 +969,7 @@ Bool_t AliZDCRawStream::Next()
           }
         }       
         // Ch. debug
-        //printf("  AliZDCRawStream -> Trigger history word %d\n", fPosition-fTrigHistStart);
+        //printf("  AliZDCRawStream -> Trigger history word[%d] %x\n", fPosition, fBuffer);
     }
     
   }