#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) override

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 () override

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 22 of file DCCEEEventBlock.h.

Constructor & Destructor Documentation

◆ DCCEEEventBlock()

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

Definition at line 16 of file DCCEEEventBlock.cc.

References DCCEventBlock::feUnpacking_, DCCEventBlock::forceToKeepFRdata_, visualization-live-secondInstance_cfg::m, 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

◆ unpack()

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

overridevirtual

Reimplemented from DCCEventBlock.

Definition at line 35 of file DCCEEEventBlock.cc.

References DCCEventBlock::addHeaderToCollection(), B_MASK, BLOCK_UNPACKED, DCCEventBlock::blockLength_, edmScanValgrind::buffer, 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_, DCCSRPBlock::unpack(), DCCFEBlock::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();
 }

◆ unpackTCCBlocks()

int DCCEEEventBlock::unpackTCCBlocks ( )

overrideprotectedvirtual

Reimplemented from DCCEventBlock.

Definition at line 294 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;
 }

Public Member Functions