DCCEEEventBlock.cc

Go to the documentation of this file.

#include "EventFilter/EcalRawToDigi/interface/DCCDataUnpacker.h"
#include "EventFilter/EcalRawToDigi/interface/EcalDCCHeaderRuntypeDecoder.h"
#include "EventFilter/EcalRawToDigi/interface/EcalElectronicsMapper.h"
#include "EventFilter/EcalRawToDigi/interface/DCCMemBlock.h"


#include "EventFilter/EcalRawToDigi/interface/DCCEEEventBlock.h"
#include "EventFilter/EcalRawToDigi/interface/DCCFEBlock.h"
#include "EventFilter/EcalRawToDigi/interface/DCCSCBlock.h"
#include "EventFilter/EcalRawToDigi/interface/DCCEETCCBlock.h"
#include "EventFilter/EcalRawToDigi/interface/DCCEESRPBlock.h"
#include <sys/time.h>

#include <iomanip>
#include <sstream>


DCCEEEventBlock::DCCEEEventBlock( DCCDataUnpacker * u,EcalElectronicsMapper * m, bool hU, bool srpU, bool tccU, bool feU, bool memU, bool forceToKeepFRdata) : 
  DCCEventBlock(u,m,hU,srpU,tccU,feU,memU,forceToKeepFRdata) 
{
  
  //Builds a tower unpacker block
  towerBlock_ = new DCCSCBlock(u,m,this,feUnpacking_,forceToKeepFRdata_); 
  
  //Builds a srp unpacker block
  srpBlock_   = new DCCEESRPBlock(u,m,this,srpUnpacking_);
  
  //Builds a tcc unpacker block
  tccBlock_   = new DCCEETCCBlock(u,m,this,tccUnpacking_);
  
 
}



void DCCEEEventBlock::unpack(const uint64_t * buffer, size_t numbBytes, unsigned int expFedId){
  
  reset();
  
  eventSize_ = numbBytes;        
  data_      = buffer;
  
  // First Header Word of fed block
  fedId_             = ((*data_)>>H_FEDID_B)   & H_FEDID_MASK;
  bx_                = ((*data_)>>H_BX_B   )   & H_BX_MASK;
  l1_                = ((*data_)>>H_L1_B   )   & H_L1_MASK;
  triggerType_       = ((*data_)>>H_TTYPE_B)   & H_TTYPE_MASK;
  
  // Check if fed id is the same as expected...
  if( fedId_ != expFedId  ){ 

  if( ! DCCDataUnpacker::silentMode_ ){  
    edm::LogWarning("IncorrectEvent")
      <<"\n For event L1A: "<<l1_
      <<"\n Expected FED id is: "<<expFedId<<" while current FED id is: "<<fedId_
      <<"\n => Skipping to next fed block...";
    }
  
  //TODO : add this to an error event collection
  
  return;
  } 
  
  // Check if this event is an empty event 
  if( eventSize_ == EMPTYEVENTSIZE ){ 
    if( ! DCCDataUnpacker::silentMode_ ){
      edm::LogWarning("IncorrectEvent")
        <<"\n Event L1A: "<<l1_<<" is empty for fed: "<<fedId_
        <<"\n => Skipping to next fed block...";
    }
    return;
    
  } 
  
  //Check if event size allows at least building the header
  else if( eventSize_ < HEADERSIZE ){    
    if( ! DCCDataUnpacker::silentMode_ ){
      edm::LogError("IncorrectEvent")
        <<"\n Event L1A: "<<l1_<<" in fed: "<< fedId_
        <<"\n Event size is "<<eventSize_<<" bytes while the minimum is "<<HEADERSIZE<<" bytes"
        <<"\n => Skipping to next fed block..."; 
     }
    
    //TODO : add this to a dcc size error collection  
    
    return;
    
  }
  
  //Second Header Word of fed block
  data_++;
  
  blockLength_   =   (*data_ )                 & H_EVLENGTH_MASK;
  dccErrors_     =   ((*data_)>>H_ERRORS_B)    & H_ERRORS_MASK;
  runNumber_     =   ((*data_)>>H_RNUMB_B )    & H_RNUMB_MASK;
  
  
  if( eventSize_ != blockLength_*8 ){
    if( ! DCCDataUnpacker::silentMode_ ){
      edm::LogError("IncorrectEvent")
        <<"\n Event L1A: "<<l1_<<" in fed: "<< fedId_
        <<"\n size is "<<eventSize_<<" bytes while "<<(blockLength_*8)<<" are set in the event header "
        <<"\n => Skipping to next fed block..."; 
      //TODO : add this to a dcc size error collection 
     }
    return;
    
  }  
  
  //Third Header Word  of fed block
  data_++;

  // bits 0.. 31 of the 3rd DCC header word
  runType_              = (*data_) & H_RTYPE_MASK;
  
  fov_                  = ((*data_)>>H_FOV_B) & H_FOV_MASK;

  // bits 32.. 47 of the 3rd DCC header word
  detailedTriggerType_ = ((*data_) >> H_DET_TTYPE_B) & H_DET_TTYPE_MASK;

  //Forth Header Word
  data_++;
  orbitCounter_        = ((*data_)>>H_ORBITCOUNTER_B)  & H_ORBITCOUNTER_MASK;
  sr_                  = ((*data_)>>H_SR_B)            & B_MASK;
  zs_                  = ((*data_)>>H_ZS_B)            & B_MASK;
  tzs_                 = ((*data_)>>H_TZS_B)           & B_MASK;

  // MEM (forces readout of MEM channels if enabled)is only used in the EE DCCs and for FOV >1 
  mem_  = ((*data_)>>H_MEM_B) & B_MASK;
  if( fov_ < 2) { mem_ = 0;}
  

  bool ignoreSR(true);
  
  srChStatus_          = ((*data_)>>H_SRCHSTATUS_B)    & H_CHSTATUS_MASK;
  
  // getting TCC channel status bits
  tccChStatus_[0] = ((*data_)>>H_TCC1CHSTATUS_B)   & H_CHSTATUS_MASK; 
  tccChStatus_[1] = ((*data_)>>H_TCC2CHSTATUS_B)   & H_CHSTATUS_MASK;
  tccChStatus_[2] = ((*data_)>>H_TCC3CHSTATUS_B)   & H_CHSTATUS_MASK;
  tccChStatus_[3] = ((*data_)>>H_TCC4CHSTATUS_B)   & H_CHSTATUS_MASK;
    
  // FE  channel Status data
  int channel(0);
  for( int dw = 0; dw<5; dw++ ){
    data_++;
    for( int i = 0; i<14; i++, channel++){
      unsigned int shift = i*4; //each channel has 4 bits
      feChStatus_[channel] = ( (*data_)>>shift ) &  H_CHSTATUS_MASK ;
    }
  }
   
  // debugging
  //display(cout);
  
  
  // pointer for the 
  std::vector<short>::iterator it;
  
  // Update number of available dwords
  dwToEnd_ = blockLength_ - HEADERLENGTH ;
   
  int STATUS = unpackTCCBlocks();

  if(  STATUS != STOP_EVENT_UNPACKING && (feUnpacking_ || srpUnpacking_) ){
    
    //NMGA note : SR comes before TCC blocks 
    // Emmanuelle please change this in the digi to raw
  
    // Unpack SRP block
    if(srChStatus_ != CH_TIMEOUT &&  srChStatus_ != CH_DISABLED){
      STATUS = srpBlock_->unpack(&data_,&dwToEnd_);
      if ( STATUS == BLOCK_UNPACKED ){ ignoreSR = false; }
    }
  }

  // See number of FE channels that we need according to the trigger type //
  // TODO : WHEN IN LOCAL MODE WE SHOULD CHECK RUN TYPE                        
  unsigned int numbChannels(0);
  
  if(       triggerType_ == PHYSICTRIGGER      ){ numbChannels = 68; }
  else if ( triggerType_ == CALIBRATIONTRIGGER ){ numbChannels = 70; }
  else {
    if( ! DCCDataUnpacker::silentMode_ ){
      edm::LogError("IncorrectEvent")
        <<"\n Event L1A: "<<l1_<<" in fed: "<< fedId_
        <<"\n Event has an unsupported trigger type "<<triggerType_
        <<"\n => Skipping to next fed block..."; 
      //TODO : add this to a dcc trigger type error collection 
    }
    return;
  }
  
  // note: there is no a-priori check that number_active_channels_from_header
  //          equals number_channels_found_in_data.
  //          The checks are doing f.e. by f.e. only.
  
  if( feUnpacking_ || memUnpacking_ ){                                                      
    it = feChStatus_.begin();
    
    // fields for tower recovery code
    unsigned int next_tower_id = 1000;
    const uint64_t* next_data = data_;
    unsigned int next_dwToEnd = dwToEnd_;
    
    // looping over FE channels, i.e. tower blocks
    for( unsigned int chNumber=1; chNumber<= numbChannels && STATUS!=STOP_EVENT_UNPACKING; chNumber++, it++ ){                        
      //for( unsigned int i=1; chNumber<= numbChannels; chNumber++, it++ ){                        
      
      const short chStatus(*it);
      
      // skip unpacking if channel disabled
      if (chStatus == CH_DISABLED) {
        continue;
      }
      
      // force MEM readout if mem_ is enabled in EEs regardless on ch suppress status flag
      if (chStatus == CH_SUPPRESS && !mem_ ) {
        continue;
      }
      
      // issuiung messages for problematic cases, even though handled by the DCC
      // and skip channel
      if (chStatus == CH_TIMEOUT || chStatus == CH_HEADERERR ||
          chStatus == CH_LINKERR || chStatus == CH_LENGTHERR ||
          chStatus == CH_IFIFOFULL || chStatus == CH_L1AIFIFOFULL)
      {
        if (! DCCDataUnpacker::silentMode_) {
          const int val = unpacker_->getCCUValue(fedId_, chNumber);
          const bool ttProblem = (val == 13) || (val == 14);
          if (! ttProblem) {
            edm::LogWarning("IncorrectBlock")
              << "Bad channel status: " << chStatus
              << " in the DCC channel: " << chNumber
              << " (LV1 " << l1_ << " fed " << fedId_ << ")\n"
              << "  => DCC channel is not being unpacked";
          }
        }
        continue;
      }
      
      // preserve data pointer
      const uint64_t* const prev_data = data_;
      const unsigned int prev_dwToEnd = dwToEnd_;
      
      // skip corrupted/problematic data block
      if (chNumber >= next_tower_id) {
        data_ = next_data;
        dwToEnd_ = next_dwToEnd;
        next_tower_id = 1000;
      }
      
      
      // Unpack Tower (Xtal Block)
      if (feUnpacking_ && chNumber <= 68) {
        
        //  in case of SR (data are 0 suppressed)
        if (sr_) {
          const bool applyZS =
            (fov_ == 0) ||      // backward compatibility with FOV = 0;
            ignoreSR ||
            (chStatus == CH_FORCEDZS1) ||
            ((srpBlock_->srFlag(chNumber) & SRP_SRVAL_MASK) != SRP_FULLREADOUT);
            
          STATUS = towerBlock_->unpack(&data_,&dwToEnd_,applyZS,chNumber);

            // If there is a decision to fully suppress data this is updated in channel status by the dcc
            //if ( ( srpBlock_->srFlag(chNumber) & SRP_SRVAL_MASK) != SRP_NREAD ){
            //    STATUS = towerBlock_->unpack(&data_,&dwToEnd_,applyZS,chNumber);
            //}
        }
        // no SR (possibly 0 suppression flags)
        else {
          // if tzs_ data are not really suppressed, even though zs flags are calculated
          if(tzs_){ zs_ = false;}
          STATUS = towerBlock_->unpack(&data_,&dwToEnd_,zs_,chNumber);
        }
      }
      
      // Unpack Mem blocks
      if(memUnpacking_        && chNumber>68 )
        {
          STATUS = memBlock_->unpack(&data_,&dwToEnd_,chNumber);
        }
      
      
      // corruption recovery
      if (STATUS == SKIP_BLOCK_UNPACKING) {
        data_ = prev_data;
        dwToEnd_ = prev_dwToEnd;
        
        next_tower_id = next_tower_search(chNumber);
        
        next_data = data_;
        next_dwToEnd = dwToEnd_;
        
        data_ = prev_data;
        dwToEnd_ = prev_dwToEnd;
      }
      
    }
    // closing loop over FE/TTblock channels
    
  }// check if we need to perform unpacking of FE or mem data
  
  
  if(headerUnpacking_) addHeaderToCollection();
  
}




int DCCEEEventBlock::unpackTCCBlocks(){

  int STATUS(BLOCK_UNPACKED);
  std::vector<short>::iterator it;
  unsigned int tccChId(0);
  for(it=tccChStatus_.begin();it!=tccChStatus_.end();it++, tccChId++){
    if( (*it) != CH_TIMEOUT &&  (*it) != CH_DISABLED){
      STATUS = tccBlock_->unpack(&data_,&dwToEnd_,tccChId);
          if(STATUS == STOP_EVENT_UNPACKING) break;
    }
  }
  return STATUS;
  
}