DCCEEEventBlock Class Reference

#include <DCCEEEventBlock.h>

Inheritance diagram for DCCEEEventBlock:

Public Member Functions
	DCCEEEventBlock (DCCDataUnpacker *u, EcalElectronicsMapper *m, bool hU, bool srpU, bool tccU, bool feU, bool memU, bool forceToKeepFRdata)
void	unpack (const uint64_t *buffer, size_t bufferSize, unsigned int expFedId)
Public Member Functions inherited from DCCEventBlock
unsigned int	bx ()
	DCCEventBlock (DCCDataUnpacker *u, EcalElectronicsMapper *m, bool hU, bool srpU, bool tccU, bool feU, bool memU, bool forceToKeepFRdata)
void	display (std::ostream &o)
void	enableFeIdChecks ()
void	enableSyncChecks ()
unsigned int	fov ()
short	getHLTChannel (int channel)
unsigned int	l1A ()
unsigned int	mem ()
void	reset ()
void	setFESyncNumbers (short l1, short bx, short id)
void	setHLTChannel (int channel, short value)
void	setSRPSyncNumbers (short l1, short bx)
void	setTCCSyncNumbers (short l1, short bx, short id)
unsigned int	smId ()
DCCDataUnpacker *	unpacker ()
void	updateCollectors ()
virtual	~DCCEventBlock ()

Protected Member Functions
int	unpackTCCBlocks ()
Protected Member Functions inherited from DCCEventBlock
void	addHeaderToCollection ()
unsigned int	next_tower_search (const unsigned int current_tower_id)

Additional Inherited Members
Protected Attributes inherited from DCCEventBlock
unsigned int	blockLength_
unsigned int	bx_
const uint64_t *	data_
unsigned int	dccErrors_
std::unique_ptr< EcalRawDataCollection > *	dccHeaders_
unsigned int	detailedTriggerType_
unsigned int	dwToEnd_
unsigned int	eventSize_
std::vector< short >	feBx_
std::vector< short >	feChStatus_
unsigned int	fedId_
std::vector< short >	feLv1_
bool	feUnpacking_
bool	forceToKeepFRdata_
unsigned int	fov_
bool	headerUnpacking_
std::vector< short >	hlt_
unsigned int	l1_
EcalElectronicsMapper *	mapper_
unsigned int	mem_
DCCMemBlock *	memBlock_
bool	memUnpacking_
unsigned int	orbitCounter_
unsigned int	runNumber_
unsigned int	runType_
unsigned int	smId_
unsigned int	sr_
unsigned int	srChStatus_
DCCSRPBlock *	srpBlock_
short	srpBx_
short	srpLv1_
bool	srpUnpacking_
DCCTCCBlock *	tccBlock_
std::vector< short >	tccBx_
std::vector< short >	tccChStatus_
std::vector< short >	tccLv1_
bool	tccUnpacking_
DCCFEBlock *	towerBlock_
unsigned int	triggerType_
unsigned int	tzs_
DCCDataUnpacker *	unpacker_
unsigned int	zs_

Detailed Description

Definition at line 24 of file DCCEEEventBlock.h.

Constructor & Destructor Documentation

DCCEEEventBlock::DCCEEEventBlock	(	DCCDataUnpacker *	u,
		EcalElectronicsMapper *	m,
		bool	hU,
		bool	srpU,
		bool	tccU,
		bool	feU,
		bool	memU,
		bool	forceToKeepFRdata
	)

Definition at line 18 of file DCCEEEventBlock.cc.

References DCCEventBlock::feUnpacking_, DCCEventBlock::forceToKeepFRdata_, DCCEventBlock::srpBlock_, DCCEventBlock::srpUnpacking_, DCCEventBlock::tccBlock_, DCCEventBlock::tccUnpacking_, and DCCEventBlock::towerBlock_.

                                                                                                                                                           : 
  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_);
  
 
}

Member Function Documentation

void DCCEEEventBlock::unpack ( const uint64_t *  buffer, size_t  bufferSize, unsigned int  expFedId  )

virtual

Reimplemented from DCCEventBlock.

Definition at line 36 of file DCCEEEventBlock.cc.

References DCCEventBlock::addHeaderToCollection(), B_MASK, BLOCK_UNPACKED, DCCEventBlock::blockLength_, DCCEventBlock::bx_, CALIBRATIONTRIGGER, CH_DISABLED, CH_FORCEDZS1, CH_HEADERERR, CH_IFIFOFULL, CH_L1AIFIFOFULL, CH_LENGTHERR, CH_LINKERR, CH_SUPPRESS, CH_TIMEOUT, DCCEventBlock::data_, DCCEventBlock::dccErrors_, DCCEventBlock::detailedTriggerType_, DCCEventBlock::dwToEnd_, EMPTYEVENTSIZE, DCCEventBlock::eventSize_, DCCEventBlock::feChStatus_, DCCEventBlock::fedId_, DCCEventBlock::feUnpacking_, DCCEventBlock::fov_, DCCDataUnpacker::getCCUValue(), H_BX_B, H_BX_MASK, H_CHSTATUS_MASK, H_DET_TTYPE_B, H_DET_TTYPE_MASK, H_ERRORS_B, H_ERRORS_MASK, H_EVLENGTH_MASK, H_FEDID_B, H_FEDID_MASK, H_FOV_B, H_FOV_MASK, H_L1_B, H_L1_MASK, H_MEM_B, H_ORBITCOUNTER_B, H_ORBITCOUNTER_MASK, H_RNUMB_B, H_RNUMB_MASK, H_RTYPE_MASK, H_SR_B, H_SRCHSTATUS_B, H_TCC1CHSTATUS_B, H_TCC2CHSTATUS_B, H_TCC3CHSTATUS_B, H_TCC4CHSTATUS_B, H_TTYPE_B, H_TTYPE_MASK, H_TZS_B, H_ZS_B, HEADERLENGTH, HEADERSIZE, DCCEventBlock::headerUnpacking_, mps_fire::i, DCCEventBlock::l1_, DCCEventBlock::mem_, DCCEventBlock::memBlock_, DCCEventBlock::memUnpacking_, DCCEventBlock::next_tower_search(), DCCEventBlock::orbitCounter_, PHYSICTRIGGER, DCCEventBlock::reset(), DCCEventBlock::runNumber_, DCCEventBlock::runType_, edm::shift, DCCDataUnpacker::silentMode_, SKIP_BLOCK_UNPACKING, DCCEventBlock::sr_, DCCEventBlock::srChStatus_, DCCSRPBlock::srFlag(), SRP_FULLREADOUT, SRP_NUMBFLAGS, SRP_SRVAL_MASK, DCCEventBlock::srpBlock_, DCCEventBlock::srpUnpacking_, STOP_EVENT_UNPACKING, DCCEventBlock::tccChStatus_, DCCEventBlock::towerBlock_, DCCEventBlock::triggerType_, DCCEventBlock::tzs_, DCCFEBlock::unpack(), DCCSRPBlock::unpack(), DCCMemBlock::unpack(), DCCEventBlock::unpacker_, unpackTCCBlocks(), heppy_batch::val, and DCCEventBlock::zs_.

Referenced by DCCDataUnpacker::unpack().

                                                                                            {
  
  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_,SRP_NUMBFLAGS);
      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 ( )

protectedvirtual

Reimplemented from DCCEventBlock.

Definition at line 314 of file DCCEEEventBlock.cc.

References BLOCK_UNPACKED, CH_DISABLED, CH_TIMEOUT, DCCEventBlock::data_, DCCEventBlock::dwToEnd_, STOP_EVENT_UNPACKING, DCCEventBlock::tccBlock_, DCCEventBlock::tccChStatus_, and DCCTCCBlock::unpack().

Referenced by unpack().

                                    {

  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;
  
}