X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ZDC%2FAliZDCRawStream.cxx;h=19e396c22f3912ce7d7e2d5de801ef105926444f;hb=df7e8023225bb00c3af0c6ac6898cd8e31226c5f;hp=6b386e3d61cbc69e3914b5110c79215c00f79818;hpb=786b72f5013d4aeda848f2fd8c5c3bf6f2ce4b55;p=u%2Fmrichter%2FAliRoot.git

diff --git a/ZDC/AliZDCRawStream.cxx b/ZDC/AliZDCRawStream.cxx
index 6b386e3d61c..19e396c22f3 100644
--- a/ZDC/AliZDCRawStream.cxx
+++ b/ZDC/AliZDCRawStream.cxx
@@ -26,8 +26,11 @@
 //									     //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include <TSystem.h>
 #include "AliZDCRawStream.h"
 #include "AliRawReader.h"
+#include "AliRawDataHeader.h"
+#include "AliRawEventHeaderBase.h"
 #include "AliLog.h"
 
 ClassImp(AliZDCRawStream)
@@ -36,31 +39,194 @@ ClassImp(AliZDCRawStream)
 //_____________________________________________________________________________
 AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
   fRawReader(rawReader),
-  fRawADC(0),	 
-  fADCModule(0),
+  fBuffer(0),
+  fReadOutCard(-1),
+  fEvType(0),
+  fPosition(0),
+  fIsCalib(kFALSE),
+  fIsDARCHeader(kFALSE),
+  fIsHeaderMapping(kFALSE),
+  fIsChMapping(kFALSE),
+  fIsADCDataWord(kFALSE),
+  fIsADCHeader(kFALSE),
+  fIsADCEOB(kFALSE),
+  fSODReading(kFALSE),
+  fIsMapRead(kFALSE),
+  fReadCDH(kFALSE),
+  fDeadfaceOffset(-1),
+  fDeadbeefOffset(-1),
+  fDataOffset(0),
+  fModType(-1),
+  fADCModule(-1),
+  fADCNChannels(-1),	 
   fADCChannel(-1),	 
   fADCValue(-1),	 
-  fADCGain(0),
-  fIsADCDataWord(kFALSE)
+  fADCGain(-1),
+  fIsUnderflow(kFALSE),
+  fIsOverflow(kFALSE),
+  fScGeo(0),	  
+  fScNWords(0),	  
+  fScTriggerSource(0),	  
+  fScTriggerNumber(0),
+  fIsScEventGood(kTRUE),
+  fIsScHeaderRead(kFALSE),
+  fScStartCounter(0),
+  fScEvCounter(0),
+  fIsScalerWord(kFALSE),
+  fDetPattern(0),
+  fTrigCountNWords(0),
+  fIsTriggerScaler(kFALSE),
+  fTrigCountStart(0),
+  fMBTrigInput(0),	   
+  fCentralTrigInput(0), 
+  fSCentralTrigInput(0),
+  fEMDTrigInput(0),     
+  fL0Received(0),	   
+  fMBtrig2CTP(0),	   
+  fCentralTrig2CTP(0),  
+  fSCentralTrig2CTP(0), 
+  fEMDTrig2CTP(0),	      
+  fTrigHistNWords(0),
+  fIsTriggerHistory(kFALSE),
+  fTrigHistStart(0),
+  fPileUpBit1stWord(0),
+  fL0Bit1stWord(0),
+  fCentralTrigHist(0),
+  fMBTrigHist(0),
+  fPileUpBit2ndWord(0),
+  fL0Bit2ndWord(0), 
+  fSCentralTrigHist(0),
+  fEMDTrigHist(0),
+  fNChannelsOn(0),
+  fCurrentCh(-1),
+  fCabledSignal(-1),
+  fCurrScCh(-1),
+  fCurrTDCCh(-1),
+  fIsADCEventGood(kTRUE),
+  fIsL0BitSet(kTRUE),
+  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();
   fRawReader->Select("ZDC");
+  //
+  const int kNch = 48;
+  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(j<3) fTDCMap[i][j]=-1;
+      }
+    }
+  }
+  
+  for(Int_t k=0; k<4; k++) fCPTInput[k] = 0;
+
 }
 
 //_____________________________________________________________________________
 AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
-  TObject(stream)
+  TObject(stream),
+  fRawReader(stream.fRawReader),
+  fBuffer(stream.GetRawBuffer()),
+  fReadOutCard(stream.GetReadOutCard()),
+  fEvType(stream.fEvType),
+  fPosition(stream.fPosition),
+  fIsCalib(stream.fIsCalib),
+  fIsDARCHeader(stream.fIsDARCHeader), 
+  fIsHeaderMapping(stream.fIsHeaderMapping),
+  fIsChMapping(stream.fIsChMapping),
+  fIsADCDataWord(stream.fIsADCDataWord), 
+  fIsADCHeader(stream.fIsADCHeader), 
+  fIsADCEOB(stream.fIsADCEOB), 
+  fSODReading(stream.fSODReading),
+  fIsMapRead(stream.fIsMapRead),
+  fReadCDH(stream.fReadCDH),
+  fDeadfaceOffset(stream.GetDeadfaceOffset()),
+  fDeadbeefOffset(stream.GetDeadbeefOffset()),
+  fDataOffset(stream.GetDataOffset()),
+  fModType(stream.GetModType()),
+  fADCModule(stream.GetADCModule()),	 
+  fADCNChannels(stream.GetADCNChannels()),	 
+  fADCChannel(stream.GetADCChannel()),	 
+  fADCValue(stream.GetADCValue()),	 
+  fADCGain(stream.GetADCGain()),
+  fIsUnderflow(stream.fIsUnderflow),
+  fIsOverflow(stream.fIsOverflow),
+  fScGeo(stream.GetScGeo()),	  
+  fScNWords(stream.GetScNWords()),	  
+  fScTriggerSource(stream.GetScTriggerSource()),	  
+  fScTriggerNumber(stream.fScTriggerNumber),
+  fIsScEventGood(stream.fIsScEventGood),
+  fIsScHeaderRead(stream.fIsScHeaderRead),
+  fScStartCounter(stream.fScStartCounter),
+  fScEvCounter(stream.fScEvCounter),
+  fIsScalerWord(stream.fIsScalerWord),
+  fDetPattern(stream.fDetPattern),
+  fTrigCountNWords(stream.fTrigCountNWords),
+  fIsTriggerScaler(stream.fIsTriggerScaler),
+  fTrigCountStart(stream.fTrigCountStart),
+  fMBTrigInput(stream.fMBTrigInput),	   
+  fCentralTrigInput(stream.fCentralTrigInput), 
+  fSCentralTrigInput(stream.fSCentralTrigInput),
+  fEMDTrigInput(stream.fEMDTrigInput),     
+  fL0Received(stream.fL0Received),	   
+  fMBtrig2CTP(stream.fMBtrig2CTP),	   
+  fCentralTrig2CTP(stream.fCentralTrig2CTP),  
+  fSCentralTrig2CTP(stream.fSCentralTrig2CTP), 
+  fEMDTrig2CTP(stream.fEMDTrig2CTP),	      
+  fTrigHistNWords(stream.fTrigHistNWords),
+  fIsTriggerHistory(stream.fIsTriggerHistory),
+  fTrigHistStart(stream.fTrigHistStart),
+  fPileUpBit1stWord(stream.fPileUpBit1stWord),
+  fL0Bit1stWord(stream.fL0Bit1stWord), 
+  fCentralTrigHist(stream.fCentralTrigHist),
+  fMBTrigHist(stream.fMBTrigHist),
+  fPileUpBit2ndWord(stream.fPileUpBit2ndWord),
+  fL0Bit2ndWord(stream.fL0Bit2ndWord), 
+  fSCentralTrigHist(stream.fSCentralTrigHist),
+  fEMDTrigHist(stream.fEMDTrigHist),
+  fNChannelsOn(stream.fNChannelsOn),
+  fCurrentCh(stream.fCurrentCh),
+  fCabledSignal(stream.GetCabledSignal()),
+  fCurrScCh(stream.fCurrScCh),
+  fCurrTDCCh(stream.fCurrTDCCh),
+  fIsADCEventGood(stream.fIsADCEventGood),
+  fIsL0BitSet(stream.fIsL0BitSet),
+  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
-  fRawADC = stream.GetADCRaw();	 
+  const int kNch = 48;
   for(Int_t j=0; j<2; j++) fSector[j] = stream.GetSector(j);	 
-  fADCModule = stream.GetADCModule();	 
-  fADCChannel = stream.GetADCChannel();	 
-  fADCValue = stream.GetADCValue();	 
-  fADCGain = stream.GetADCGain();	 
-  fIsADCDataWord = stream.IsADCDataWord(); 
-    
+  for(Int_t i=0; i<kNch; i++){
+    for(Int_t j=0; j<5; j++){
+      fMapADC[i][j] = stream.fMapADC[i][j];
+      if(i<32) fScalerMap[i][j] = stream.fMapADC[i][j];
+    }
+  }
+  
+  for(Int_t k=0; k<4; k++) fCPTInput[k] = stream.fCPTInput[k];
 }
 
 //_____________________________________________________________________________
@@ -79,6 +245,131 @@ AliZDCRawStream::~AliZDCRawStream()
 
 }
 
+//_____________________________________________________________________________
+void AliZDCRawStream::ReadChMap()
+{
+  // Reading channel map
+  const int kNch = 48;
+  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] = chMap->GetADCSignalCode(i);
+    fMapADC[i][3] = chMap->GetDetector(i);
+    fMapADC[i][4] = chMap->GetSector(i);
+  }
+  fIsMapRead = kTRUE;
+}
+
+//_____________________________________________________________________________
+void AliZDCRawStream::ReadCDHHeader()
+{
+  // Reading CDH 
+  const AliRawDataHeader* header = fRawReader->GetDataHeader();
+  if(!header) {
+      AliError(" No CDH in raw data streaming");
+      fRawReader->AddMajorErrorLog(kCDHError);
+      return;
+  }
+  else{
+    //printf("\t AliZDCRawStream::ReadCDHHeader -> Data Size = %x\n",fRawReader->GetDataSize());
+
+    UChar_t message = header->GetAttributes();
+    //printf("\t AliZDCRawStream::ReadCDHHeader -> Attributes %x\n",message);
+    
+    if((message & 0xf0) == 0x0){ // PHYSICS RUN
+       //printf("\t PHYSICS RUN raw data found\n");
+    }
+    else if((message & 0xf0) == 0x10){ // COSMIC RUN
+       //printf("\t STANDALONE_COSMIC RUN raw data found\n");
+    }
+    else if((message & 0xf0) == 0x20){ // PEDESTAL RUN
+       //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
+    }
+    else if((message & 0xf0) == 0x30){ // LASER RUN
+       //printf("\t STANDALONE_LASER RUN raw data found\n");
+    }
+    else if((message & 0xf0) == 0x40){ // CALIBRATION_CENTRAL RUN
+       //printf("\t CALIBRATION_CENTRAL RUN raw data found\n");
+    }
+    else if((message & 0xf0) == 0x50){ // CALIBRATION_SEMICENTRAL
+       //printf("\t CALIBRATION_SEMICENTRAL RUN raw data found\n");
+    }
+    else if((message & 0xf0) == 0x60){ // CALIBRATION_MB
+       //printf("\t CALIBRATION_MB RUN raw data found\n");
+    }
+    else if((message & 0xf0) == 0x70){ // CALIBRATION_EMD
+       //printf("\t CALIBRATION_EMD RUN raw data found\n");
+    }
+    // *** Checking the bit indicating the used readout card
+    // (the payload is different in the 2 cases!)
+    if((message & 0x08) == 0){  // ** DARC card
+       fReadOutCard = 0;
+       fIsDARCHeader = kTRUE;
+       //AliInfo("\t ZDC readout card used: DARC");
+    }
+    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);    
+    
+/*    UInt_t status = header->GetStatus();
+    //printf("\t AliZDCRawStream::ReadCDHHeader -> status = %d\n",status);
+    if((status & 0x000f) == 0x0001){
+      AliDebug(2,"CDH -> DARC trg0 overlap error");
+      fRawReader->AddMajorErrorLog(kDARCError);
+    }
+    if((status & 0x000f) == 0x0002){
+      AliDebug(2,"CDH -> DARC trg0 missing error");
+      fRawReader->AddMajorErrorLog(kDARCError);
+    }
+    if((status & 0x000f) == 0x0004){
+      AliDebug(2,"CDH -> DARC data parity error");
+      fRawReader->AddMajorErrorLog(kDARCError);
+    }
+    if((status & 0x000f) == 0x0008){
+      AliDebug(2,"CDH -> DARC ctrl parity error");
+      fRawReader->AddMajorErrorLog(kDARCError);
+    }
+    //
+    if((status & 0x00f0) == 0x0010){
+      AliDebug(2,"CDH -> DARC trg unavailable");
+      fRawReader->AddMajorErrorLog(kDARCError);
+    }
+    if((status & 0x00f0) == 0x0020){
+      AliDebug(2,"CDH -> DARC FEE error");
+      fRawReader->AddMajorErrorLog(kDARCError);
+    }
+    //
+    if((status & 0x0f00) == 0x0200){
+      AliDebug(2,"CDH -> DARC L1 time violation");
+      fRawReader->AddMajorErrorLog(kDARCError);
+    }
+    if((status & 0x0f00) == 0x0400){
+      AliDebug(2,"CDH -> DARC L2 time-out");
+      fRawReader->AddMajorErrorLog(kDARCError);
+    }
+    if((status & 0x0f00) == 0x0800){
+      AliDebug(2,"CDH -> DARC prepulse time violation");
+      fRawReader->AddMajorErrorLog(kDARCError);
+    }
+    //
+    if((status & 0xf000) == 0x1000){
+      AliDebug(2,"CDH -> DARC other error");
+      fRawReader->AddMajorErrorLog(kDARCError);
+    }
+    */
+  }
+  
+}
 
 //_____________________________________________________________________________
 Bool_t AliZDCRawStream::Next()
@@ -86,100 +377,630 @@ Bool_t AliZDCRawStream::Next()
   // Read the next raw digit
   // Returns kFALSE if there is no digit left
 
-  if(!fRawReader->ReadNextInt((UInt_t&) fRawADC)) return kFALSE;
-  fIsADCDataWord = kFALSE;
+  if(!fRawReader->ReadNextInt((UInt_t&) fBuffer)) return kFALSE;
+  const int kNch = 48;
   //
+  fIsHeaderMapping = kFALSE; fIsChMapping = kFALSE; 
+  fIsADCHeader = kFALSE; fIsADCDataWord = kFALSE; fIsADCEOB = kFALSE;
+  fIsZDCTDCdatum = kFALSE; fIsADDChannel = kFALSE; fIsADDTDCdatum=kFALSE;
+  fIsUnderflow = kFALSE; fIsOverflow = kFALSE; fIsScalerWord = kFALSE;
+  fSector[0] = fSector[1] = -1;
+  for(Int_t kl=0; kl<4; kl++) fCPTInput[kl] = 0;
+
+  fEvType = fRawReader->GetType();
+  if(fPosition==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");
+    return kFALSE;
+  }
+  
+  // -------------------------------------------
   // --- DARC header
-  if((fRawADC == 0xe52b6300) || (fRawADC == 0xe52c0300) ||  (fRawADC == 0xffffffff) ||
-     (fRawADC == 0xdeadface) || (fRawADC == 0xdeadbeef)){
-    //printf("    This is a DARC header!!!\n");
+  // -------------------------------------------
+  // If the CDH has been read then 
+  // the DARC header must follow
+  if(fReadOutCard==0 && fIsDARCHeader){
+    //printf("\t ---- DARC header ----\n");
+    if(fIsCalib){
+      fDeadfaceOffset = 9;
+      fDeadbeefOffset = 25;
+    }
+    else{
+      fDeadfaceOffset = 1;
+      fDeadbeefOffset = 7;
+    }
+    fDataOffset = 1+fDeadbeefOffset;
+    fIsDARCHeader = kFALSE;
   }
-  // --- End of data
-  else if(fRawADC == 0xcafefade){
-    //printf("    End of data!\n");
-  } 
-  // --- ADC buffer
-  else{
-    Bool_t firstADCHeader = kTRUE;
-    //
-    if((fRawADC & 0x6000000) == 0x6000000){ // Not valid datum BEFORE valid data!
-      firstADCHeader = kFALSE;
-      //printf("    AliZDCRawStream -> Not valid datum in ADC module!!! %d\n",fADCModule);
+    
+  // ---------------------------------------------
+  // --- Start of data event (SOD)             ---
+  // --- decoding mapping of connected ADC ch. ---
+  // ---------------------------------------------
+  // In the SOD event ADC ch. mapping is written
+  if(fEvType==10){
+   if(fSODReading){
+    
+    if(fPosition>=fDataOffset){
+      if((fBuffer&0xff000001) == 0xff000001){ // ************** Mapping
+        // 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; fCurrTDCCh=0;	
+        }
+	else{
+	  printf(" ------ AliZDCRawStream -> End of ZDC StartOfData event ------\n\n");
+          fSODReading = kFALSE;
+	  return kFALSE;
+	}
+      }
+      else if((fBuffer&0xff000002) == 0xff000002){ // ************** Threshold settings
+        fPosition++;
+	return kFALSE; // !!!!!!!!!!!!!!!!!!!!!  For the moment thresholds are not read
+      }
+      else if((fBuffer&0x80000000)>>31 == 1){ // --- Mapping header
+        fIsHeaderMapping = kTRUE;
+	fADCModule = ((fBuffer & 0x7f000000)>>24); // GEO address!!!
+	fModType = ((fBuffer & 0x7ff00)>>8); 
+	fADCNChannels = (fBuffer & 0xff);          // # of channels following the header
+	//
+	printf("  ******** GEO %d, mod. type %d, #ch. %d\n",fADCModule,fModType,fADCNChannels);
+      }
+      else if((fBuffer&0x80000000)>>31 == 0){ // --- Mapping channel
+	fADCChannel = ((fBuffer & 0x3fff0000)>>16);
+	fCabledSignal = (fBuffer&0xffff);
+        //
+	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;
+	    fMapADC[fCurrentCh][2] = fCabledSignal;
+	    //  - No. of channels on
+	    fNChannelsOn++;
+	    //
+	    // Determining detector and sector
+	    // -----------------------------------------
+	    //  For the decoding of the following lines 
+	    //  look the enum in AliZDCRawStream.h file
+	    // -----------------------------------------
+	    if((fCabledSignal>=2 && fCabledSignal<=6) || (fCabledSignal>=26 && fCabledSignal<=30)
+	      || fCabledSignal==24 || fCabledSignal==48){
+	      fMapADC[fCurrentCh][3] = 4; //ZNA
+	      //
+	      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==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==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==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==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);
+	    //printf("  det. %d sec. %d\n",fMapADC[fCurrentCh][3],fMapADC[fCurrentCh][4]);
+	    //
+	    fCurrentCh++;
+	    //
+	  } // high range channels
+        }// ModType=1 (ADC mapping)
+        else if(fModType == kV830){  // ******** VME scaler **************************
+          fIsChMapping = kTRUE;
+	  fScalerMap[fCurrScCh][0] = fADCModule;
+	  fScalerMap[fCurrScCh][1] = fADCChannel;
+	  fScalerMap[fCurrScCh][2] = fCabledSignal;
+	  //
+	  // Determining detector and sector
+	  // -----------------------------------------
+	  //  For the decoding of the following lines 
+	  //  look the enum in AliZDCRawStream.h file
+	  // -----------------------------------------
+	  // NOT CONSIDERING OUT OF TIME OR REFERENCE SIGNALS FOR SCALER!!!!!
+	  if((fCabledSignal>=2 && fCabledSignal<=6) ||
+	     (fCabledSignal>=61 && fCabledSignal<=65)){
+	    fScalerMap[fCurrScCh][3] = 4; //ZNA
+	    //
+	    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) ||
+	     (fCabledSignal>=66 && fCabledSignal<=70)){
+	    fScalerMap[fCurrScCh][3] = 5; //ZPA
+	    //
+	    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) ||
+	     (fCabledSignal>=71 && fCabledSignal<=75)){
+	    fScalerMap[fCurrScCh][3] = 1; //ZNC
+	    //
+	    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) ||
+	     (fCabledSignal>=76 && fCabledSignal<=80)){
+	    fScalerMap[fCurrScCh][3] = 2; //ZPC
+	    //
+	    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 ||
+	          fCabledSignal==81 || fCabledSignal==82){
+	    fScalerMap[fCurrScCh][3] = 3; // ZEM
+	    //
+	    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");*/
+	  
+          fCurrScCh++;
+        }
+	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 == kTRGI){ // **** trigger history from trigger card
+      	  //printf("\t Trigger card ch. %d, signal %d\n",fADCChannel,fCabledSignal);
+        }
+	else if(fModType == kPU){ // **** pattern unit
+      	  //printf("\t P.U. mod. %d ch. %d, signal %d\n",fADCModule,fADCChannel,fCabledSignal);
+        }*/
+      }//reading channel mapping
     }
-    else if((fRawADC & 0x4000000) == 0x4000000){ // ADC EOB
-      //printf("    AliZDCRawStream -> ADC %d End Of Block - Event no. %d\n\n",fADCModule, (fRawADC & 0xffffff));
-      fSector[0] = fSector[1] = 99;
-    } 
-    else if((fRawADC & 0x2000000) == 0x2000000){ // ADC Header
-      //printf("  fRawADC %x\n",fRawADC);
-      // Reading the GEO address to determine ADC module
-      fADCModule = (fRawADC & 0xf8000000) >> 27;
-      fADCModule ++;
+   } // if fSODREading
+   fPosition++;
+   return kTRUE;
+  } // ------------------------------- SOD event
+  
+  // -------------------------------------------
+  // --- DARC data
+  // -------------------------------------------
+  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 && 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{
+      fPosition++;
+      return kTRUE;
+    }
+  } // ------------------------------- End of DARC data
+  
+  // ---------------------------------------------
+  // --- ZDC data
+  // --- ADCs + VME scaler + trigger card + P.U.
+  // ---------------------------------------------
+  else if(fPosition>=fDataOffset){
+    
+    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){ 
+        //printf("\t **** ZDC data begin ****\n");
+        if((fBuffer & 0x07000000) != 0x06000000){
+          fRawReader->AddMajorErrorLog(kZDCDataError);
+        }
+        //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)
-      if(fADCModule == 1) firstADCHeader = kTRUE;
-      //if(fADCModule == 1) printf(" fADCModule %d, firstADCHeader %d\n",fADCModule,firstADCHeader);
-      //printf("  AliZDCRawStream -> HEADER: ADC mod. %d contains %d data words \n",fADCModule,((fRawADC & 0x3f00) >> 8));
-    }
-    else{ // ADC data word
-      fIsADCDataWord = kTRUE;
-      //printf(" fRawADC = %x firstADCHeader %d\n",fRawADC,firstADCHeader);
-      //
-      if(!(fRawADC & 0x1000) && !(fRawADC & 0x2000) && firstADCHeader){ // Valid ADC data
-        fADCGain = (fRawADC & 0x10000) >> 16;
-        fADCValue = (fRawADC & 0xfff);   
-        //
-        fADCChannel = (fRawADC & 0x1e0000) >> 17;
-	//
-	// If raw data corresponds to an ADC ch. without physical signal
-	// fsector[0] = fSector[1] = -1
-	for(Int_t i=0; i<2; i++)fSector[i] = -1;
-        //if(fSector[0]!=-1) printf(" \t \t ADC Data Word: ADC ch. %d",fADCChannel);
-	//
-        if(fADCModule==1 || fADCModule==3){  //1st & 3rd ADC modules
-          if(fADCChannel >= 0 && fADCChannel <= 4){ 
-            fSector[0] = 1; // ZN1
-            fSector[1] = fADCChannel;
-          } 
-          else if(fADCChannel >= 8 && fADCChannel <= 12){
-            fSector[0] = 2; // ZP1
-            fSector[1] = fADCChannel-8;
-          } 
-          else if(fADCChannel == 5 || fADCChannel == 13){
-            fSector[0] = 3; // ZEM 1,2
-            fSector[1] = ((fADCChannel-5)/8)+1;
-          }
+      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);
+          fIsADCEventGood = kFALSE;
+	  fPosition++;
+	  return kFALSE;
         }
-        else if(fADCModule==2 || fADCModule==4){  //2nd & 4rth ADC modules
-          if(fADCChannel >= 0 && fADCChannel <= 4){ 
-            fSector[0] = 4; // ZN2
-          fSector[1] = fADCChannel;
-          } 
-          else if(fADCChannel >= 8 && fADCChannel <= 12){
-            fSector[0] = 5; // ZP2
-            fSector[1] = fADCChannel-8;
-          } 
-          else if(fADCChannel == 5 || fADCChannel == 13){
-            fSector[0] = (fADCChannel-5)*3/8+1; // PM Ref 1,2
-            fSector[1] = 5;
+      }
+    }
+     
+    // Get geo address of current word
+    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 && 
+       !fIsTriggerHistory && !fIsScHeaderRead && !fIsTriggerScaler){
+      // *** ADC header
+      if((fBuffer & 0x07000000) == 0x02000000){
+        fIsADCHeader = kTRUE;
+    	fADCNChannels = ((fBuffer & 0x00003f00)>>8);
+    	//printf("  AliZDCRawStream -> ADC HEADER: mod.%d has %d ch. \n",fADCModule,fADCNChannels);
+      }
+      // *** ADC data word
+      else if((fBuffer & 0x07000000) == 0x00000000){
+        fIsADCDataWord = kTRUE;
+        fADCChannel = ((fBuffer & 0x1e0000) >> 17);
+        fADCGain = ((fBuffer & 0x10000) >> 16);       
+        fADCValue = (fBuffer & 0xfff);  
+    	//
+	//printf("  AliZDCRawStream -> ADC DATUM: mod. %d ch. %d gain %d value %d\n",
+	  //fADCModule,fADCChannel,fADCGain,fADCValue);
+	
+	// Checking if the channel map for the ADCs has been provided/read
+	if(fMapADC[0][0]==-1){
+	  printf("\t ATTENTION!!! No ADC mapping has been found/provided!!!\n");
+	  return kFALSE;
+	}
+	//
+	/*for(Int_t ci=0; ci<kNch; ci++){
+	  printf("  %d mod %d ch %d det %d sec %d\n",ci,fMapADC[ci][0],
+          fMapADC[ci][1], fMapADC[ci][3], fMapADC[ci][4]);
+	}*/
+		
+	// Scan of the map to assign the correct volumes
+	Int_t foundMapEntry = kFALSE;
+	for(Int_t k=0; k<kNch; k++){
+	   if(fADCModule==fMapADC[k][0] && fADCChannel==fMapADC[k][1]){
+	     fSector[0] = fMapADC[k][3];
+	     fSector[1] = fMapADC[k][4];
+	     foundMapEntry = kTRUE;
+	     break;
+	   } 
+	}
+	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));
+	}
+
+	// Final checks
+	if(foundMapEntry==kTRUE && fEvType==7){
+	  if(fSector[0]<1 || fSector[0]>5){
+            AliWarning(Form(" No valid detector assignment: %d",fSector[0]));
+            fRawReader->AddMajorErrorLog(kInvalidSector);
+	  }
+	  //
+	  if(fSector[1]<0 || fSector[1]>5){
+            AliWarning(Form(" No valid sector assignment: %d",fSector[1]));
+            fRawReader->AddMajorErrorLog(kInvalidSector);
+	  }
+	  //
+	  if(fADCModule<0 || fADCModule>3){
+            AliError(Form(" No valid ADC module: %d",fADCModule));
+            fRawReader->AddMajorErrorLog(kInvalidADCModule);
           }
-        }
-        else{
-          AliWarning("    AliZDCRawStream -> No valid ADC module\n");
-          fRawReader->AddMajorErrorLog(kInvalidADCModule);
-        }
-        //printf("  ADC %d ch %d range %d -> det %d quad %d value %x\n",
-        //   fADCModule, fADCChannel, fADCGain, fSector[0], fSector[1], fADCValue);//Chiara debugging
+	}
+
+	// Checking the underflow and overflow bits
+        if(fBuffer & 0x1000)       fIsUnderflow = kTRUE;
+	else if (fBuffer & 0x2000) fIsOverflow = kTRUE; 
+        	
+      }//ADC data word
+      // *** ADC EOB
+      else if((fBuffer & 0x07000000) == 0x04000000){
+        fIsADCEOB = kTRUE;
+    	//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
+        fScGeo = (fBuffer & 0xf8000000)>>27;	   
+        fScNWords = (fBuffer & 0x00fc0000)>>18;	   
+        fScTriggerSource = (fBuffer & 0x00030000)>>16;	   
+        fScTriggerNumber = (fBuffer & 0x0000ffff);
+        fIsScHeaderRead = kTRUE; 
+	fScStartCounter = fPosition;
+        //Ch. debug
+        //printf("  AliZDCRawStream -> VME SCALER HEADER: geo %d Nwords %d TrigSource %d TrigNo. %d\n",
+        //   fScGeo,fScNWords,fScTriggerSource,fScTriggerNumber);
+      } 
+      // Commented by C.O. & M.G. (23/09/2011)
+      //else if(!(fBuffer & 0x04000000) && fIsScHeaderRead==kFALSE){
+      //  fIsScEventGood = kFALSE;
+      //}
+    }
+    // *********************************** PATTERN UNIT ***********************************
+    else if(fADCModule == kPUGeo){
+      // still to be implemented!!! Not yet in data!!!
+      fDetPattern = (fBuffer & 0x0000003f);
+      // Ch. debug
+      //printf("  AliZDCRawStream -> Pattern Unit\n");
       
-      }// Valid ADC data
-      else if(fRawADC & 0x1000){ 
-        //printf("  ADC %d ch %d range %d  overflow\n",fADCModule, (fRawADC & 0x1e0000) >> 17, fADCGain); // Overflow
+    }
+    // ******************************** TRIGGER CARD COUNTS ********************************
+    else if(fADCModule == kTrigScales){
+      if(fIsTriggerScaler == kFALSE){
+        fTrigCountNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
+        fTrigCountStart = fPosition;
+	fIsTriggerScaler = kTRUE;
+      }
+      // Ch. debug
+      //printf("  AliZDCRawStream -> Trigger Scaler header\n");      
+    }
+    // ********************************** TRIGGER HISTORY **********************************
+    else if(fADCModule == kTrigHistory){
+      if(fIsTriggerHistory == kFALSE){
+        fTrigHistNWords = (Int_t) ((fBuffer & 0xfc0000)>>17);
+	fTrigHistStart = fPosition;
+        fIsTriggerHistory = kTRUE;
       }
-      else if(fRawADC & 0x2000){ 
-        //printf("  ADC %d ch %d range %d  underflow\n",fADCModule, (fRawADC & 0x1e0000) >> 17, fADCGain); // Underflow
+      // Ch. debug
+      //printf("  AliZDCRawStream -> Trigger History header\n");
+      
+    } 
+    // ********************************** VME SCALER DATA **********************************
+    //  Reading VME scaler data 
+    if(fIsScHeaderRead && fPosition>=fScStartCounter+1){ // *** Scaler word
+      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 %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);
       }
-    }// ADC word
-  }//Not DARC Header
+      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; fIsADCDataWord = kFALSE;	
+      if(fPosition == fTrigCountStart+1)      fMBTrigInput = fBuffer;		    
+      else if(fPosition == fTrigCountStart+2) fCentralTrigInput = fBuffer;		    
+      else if(fPosition == fTrigCountStart+3) fSCentralTrigInput = fBuffer;
+      else if(fPosition == fTrigCountStart+4) fEMDTrigInput = fBuffer; 
+      else if(fPosition == fTrigCountStart+5) fL0Received = fBuffer;
+      else if(fPosition == fTrigCountStart+6) fMBtrig2CTP = fBuffer;	 
+      else if(fPosition == fTrigCountStart+7) fCentralTrig2CTP = fBuffer;  
+      else if(fPosition == fTrigCountStart+8) fSCentralTrig2CTP = fBuffer; 
+      else if(fPosition == fTrigCountStart+9){
+        fEMDTrig2CTP = fBuffer;       
+        fIsTriggerScaler = kFALSE;
+      }
+      // Ch. debug
+      //printf("  AliZDCRawStream -> Trigger Scaler datum %d\n", fPosition-fTrigCountStart);
+    }
+    // ******************************* TRIGGER HISTORY WORDS ******************************
+    //  Reading trigger history
+    if(fIsTriggerHistory && fPosition>=fTrigHistStart+1){
+	fADCModule = kTrigHistory; fIsADCDataWord = kFALSE;	
+	if(fPosition == fTrigHistStart+1){
+	  fPileUpBit1stWord = (fBuffer & 0x80000000) >> 31;
+	  fL0Bit1stWord = (fBuffer & 0x40000000) >> 30;        
+	  fCentralTrigHist = (fBuffer & 0x3fff8000) >> 14; 
+	  fMBTrigHist =  (fBuffer & 0x00007fff);        
+	  //
+	  fCPTInput[0] = (fBuffer & 0x00000080) >> 6;  // MB bit
+	  fCPTInput[1] = (fBuffer & 0x00400000) >> 21; // CENTRAL bit
+        }
+	
+	else if(fPosition == fTrigHistStart+fTrigHistNWords){
+          fPileUpBit2ndWord = (fBuffer & 0x80000000) >> 31;
+          fL0Bit2ndWord = (fBuffer & 0x40000000) >> 30;	     
+          fSCentralTrigHist = (fBuffer & 0x3fff8000) >> 14; 
+          fEMDTrigHist =  (fBuffer & 0x00007fff); 	 
+          //
+          fCPTInput[2] = (fBuffer & 0x00000080) >> 6;  // SEMICENTRAL bit
+          fCPTInput[3] = (fBuffer & 0x00400000) >> 21; // EMD bit
+	  //
+	  fIsTriggerHistory = kFALSE;
+          
+	  // Checking if the event is good
+          // (1) both history word pile up bits must be = 0
+          if(fPileUpBit1stWord==0 && fPileUpBit2ndWord==0) fIsPileUpEvent = kFALSE;
+          else{
+            fIsPileUpEvent = kTRUE;
+	    printf("  AliZDCRawStream -> PILE UP EVENT: bitPileUp0 %d bitPileUp1 %d\n",
+	    	fPileUpBit1stWord, fPileUpBit2ndWord);
+          }
+	  // (2) both history word L0 bits must be = 1
+          if(fL0Bit1stWord==1 && fL0Bit2ndWord==1) fIsL0BitSet = kTRUE;
+          else{
+            fIsL0BitSet = kFALSE;
+	    printf("  AliZDCRawStream -> L0 wrongly set: bitL0word0 %d bitL0word1 %d\n",
+	    	fL0Bit1stWord, fL0Bit2ndWord);
+          }
+        }       
+        // Ch. debug
+        //printf("  AliZDCRawStream -> Trigger history word[%d] %x\n", fPosition, fBuffer);
+    }
+    
+  }
+
+  fPosition++;
 
   return kTRUE;
 }
+
+//_____________________________________________________________________________
+AliCDBStorage* AliZDCRawStream::SetStorage(const char *uri) 
+{
+  // Setting the storage
+  
+  AliCDBStorage *storage = AliCDBManager::Instance()->GetStorage(uri); 
+
+  return storage; 
+}
+
+
+//_____________________________________________________________________________
+AliZDCChMap* AliZDCRawStream::GetChMap() const
+{
+
+  // Getting calibration object for ZDC
+
+  AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/ChMap");
+  if(!entry) AliFatal("No calibration data loaded!");  
+
+  AliZDCChMap *calibdata = dynamic_cast<AliZDCChMap*> (entry->GetObject());
+  if(!calibdata) AliFatal("Wrong calibration object in calibration  file!");
+
+  return calibdata;
+}