#include <DCCTowerBlock.h>

Inheritance diagram for DCCTowerBlock:

Public Member Functions
	DCCTowerBlock (DCCDataUnpacker u, EcalElectronicsMapper m, DCCEventBlock *e, bool unpack, bool forceToKeepFRdata)

void	updateCollectors () override

Public Member Functions inherited from DCCFEBlock
	DCCFEBlock (DCCDataUnpacker u, EcalElectronicsMapper m, DCCEventBlock *e, bool unpack, bool forceToKeepFRdata)

void	display (std::ostream &o) override

void	enableFeIdChecks ()

unsigned int	getLength () override

virtual int	unpack (const uint64_t *data, unsigned int dwToEnd)

int	unpack (const uint64_t *data, unsigned int dwToEnd, bool zs, unsigned int expectedTowerID)

void	zsFlag (bool zs)

	~DCCFEBlock () override

Public Member Functions inherited from DCCDataBlockPrototype
	DCCDataBlockPrototype (DCCDataUnpacker unpacker, EcalElectronicsMapper mapper, DCCEventBlock *event, bool unpack=true)

void	enableSyncChecks ()

virtual int	unpack (const uint64_t *data, unsigned int dwToEnd)

virtual void	updateEventPointers ()

virtual	~DCCDataBlockPrototype ()

Protected Member Functions
void	fillEcalElectronicsError (std::unique_ptr< EcalElectronicsIdCollection > *) override

int	unpackXtalData (unsigned int stripID, unsigned int xtalID) override

Protected Attributes
std::unique_ptr< EBDigiCollection > *	digis_

std::unique_ptr< EBDetIdCollection > *	invalidChIds_

std::unique_ptr< EBDetIdCollection > *	invalidGains_

std::unique_ptr< EBDetIdCollection > *	invalidGainsSwitch_

EBDetId *	pDetId_

Protected Attributes inherited from DCCFEBlock
unsigned int	blockSize_

unsigned int	bx_

bool	checkFeId_

unsigned int	expTowerID_

unsigned int	expXtalTSamples_

bool	forceToKeepFRdata_

std::unique_ptr< EcalElectronicsIdCollection > *	invalidBlockLengths_

std::unique_ptr< EcalElectronicsIdCollection > *	invalidTTIds_

std::unique_ptr< EcalElectronicsIdCollection > *	invalidZSXtalIds_

unsigned int	l1_

unsigned int	lastStripId_

unsigned int	lastXtalId_

unsigned int	nTSamples_

unsigned int	numbDWInXtalBlock_

unsigned int	towerId_

unsigned int	unfilteredDataBlockLength_

unsigned int	xtalBlockSize_

short *	xtalGains_

bool	zs_

Protected Attributes inherited from DCCDataBlockPrototype
unsigned int	blockLength_

const uint64_t *	data_

const uint64_t **	datap_

unsigned int *	dwToEnd_

bool	error_

DCCEventBlock *	event_

EcalElectronicsMapper *	mapper_

bool	sync_

DCCDataUnpacker *	unpacker_

bool	unpackInternalData_

Detailed Description

Definition at line 22 of file DCCTowerBlock.h.

Constructor & Destructor Documentation

◆ DCCTowerBlock()

DCCTowerBlock::DCCTowerBlock	(	DCCDataUnpacker *	u,
		EcalElectronicsMapper *	m,
		DCCEventBlock *	e,
		bool	unpack,
		bool	forceToKeepFRdata
	)

Definition at line 8 of file DCCTowerBlock.cc.

10 : DCCFEBlock(u, m, e, unpack, forceToKeepFRdata) {}

Member Function Documentation

◆ fillEcalElectronicsError()

void DCCTowerBlock::fillEcalElectronicsError ( std::unique_ptr< EcalElectronicsIdCollection > * errorColection )

overrideprotectedvirtual

Reimplemented from DCCFEBlock.

Definition at line 263 of file DCCTowerBlock.cc.

                                                                                                        {
   const int activeDCC = mapper_->getActiveSM();
  
   if (NUMB_SM_EB_MIN_MIN <= activeDCC && activeDCC <= NUMB_SM_EB_PLU_MAX) {
     EcalElectronicsId *eleTp = mapper_->getTTEleIdPointer(activeDCC + TCCID_SMID_SHIFT_EB, expTowerID_);
     (*errorColection)->push_back(*eleTp);
   } else {
     if (!DCCDataUnpacker::silentMode_) {
       edm::LogWarning("IncorrectBlock") << "For event " << event_->l1A() << " there's fed: " << activeDCC
                                         << " activeDcc: " << mapper_->getActiveSM()
                                         << " but that activeDcc is not valid in EB.";
     }
   }
 }

References DCCDataBlockPrototype::event_, DCCFEBlock::expTowerID_, EcalElectronicsMapper::getActiveSM(), EcalElectronicsMapper::getTTEleIdPointer(), DCCEventBlock::l1A(), DCCDataBlockPrototype::mapper_, NUMB_SM_EB_MIN_MIN, NUMB_SM_EB_PLU_MAX, DCCDataUnpacker::silentMode_, and TCCID_SMID_SHIFT_EB.

Referenced by unpackXtalData().

◆ unpackXtalData()

int DCCTowerBlock::unpackXtalData	(	unsigned int	stripID,
		unsigned int	xtalID
	)

overrideprotectedvirtual

Reimplemented from DCCFEBlock.

Definition at line 23 of file DCCTowerBlock.cc.

                                                                                  {
   bool errorOnXtal(false);
  
   const uint16_t *xData_ = reinterpret_cast<const uint16_t *>(data_);
  
   // Get xtal data ids
   unsigned int stripId = (*xData_) & TOWER_STRIPID_MASK;
   unsigned int xtalId = ((*xData_) >> TOWER_XTALID_B) & TOWER_XTALID_MASK;
  
   // check id in case data are not 0suppressed
   if (!zs_ && (expStripID != stripId || expXtalID != xtalId)) {
     if (!DCCDataUnpacker::silentMode_) {
       edm::LogWarning("IncorrectBlock") << "For event L1A: " << event_->l1A() << ", fed " << mapper_->getActiveDCC()
                                         << " and tower " << towerId_ << "\n The expected strip is " << expStripID
                                         << " and " << stripId << " was found"
                                         << "\n The expected xtal  is " << expXtalID << " and " << xtalId
                                         << " was found";
     }
     // using expected cry_di to raise warning about xtal_id problem
     pDetId_ = (EBDetId *)mapper_->getDetIdPointer(towerId_, expStripID, expXtalID);
     (*invalidChIds_)->push_back(*pDetId_);
  
     // return here, so to skip all following checks
     lastXtalId_++;
     if (lastXtalId_ > NUMB_XTAL) {
       lastXtalId_ = 1;
       lastStripId_++;
     }
     data_ += numbDWInXtalBlock_;
     return BLOCK_UNPACKED;
  
     //keep these here in case the return is to be dropped
     stripId = expStripID;
     xtalId = expXtalID;
     errorOnXtal = true;
   }
  
   // check id in case of 0suppressed data
  
   else if (zs_) {
     // Check for valid Ids 1) values out of range
  
     if (stripId == 0 || stripId > 5 || xtalId == 0 || xtalId > 5) {
       if (!DCCDataUnpacker::silentMode_) {
         edm::LogWarning("IncorrectBlock")
             << "For event L1A: " << event_->l1A() << ", fed " << mapper_->getActiveDCC() << " and tower " << towerId_
             << "\n Invalid strip : " << stripId << " or xtal : " << xtalId << " ids ( last strip was: " << lastStripId_
             << " last ch was: " << lastXtalId_ << ")";
       }
  
       int st = lastStripId_;
       int ch = lastXtalId_;
       ch++;
       if (ch > NUMB_XTAL) {
         ch = 1;
         st++;
       }
       if (st > NUMB_STRIP) {
         ch = 1;
         st = 1;
       }
  
       // adding channel following the last valid
       //pDetId_ = (EBDetId*) mapper_->getDetIdPointer(towerId_,st,ch);
       //(*invalidChIds_)->push_back(*pDetId_);
       fillEcalElectronicsError(invalidZSXtalIds_);
  
       lastStripId_ = st;
       lastXtalId_ = ch;
  
       // return here, so to skip all following checks
       return SKIP_BLOCK_UNPACKING;
       errorOnXtal = true;  //keep it here in case the return is to be dropped
     } else {
       // Check for zs valid Ids 2) if channel-in-strip has increased wrt previous xtal
  
       // Check for zs valid Ids 2) if channel-in-strip has increased wrt previous xtal
       //                        3) if strip has increased wrt previous xtal
       if ((stripId == lastStripId_ && xtalId <= lastXtalId_) || (stripId < lastStripId_)) {
         if (!DCCDataUnpacker::silentMode_) {
           edm::LogWarning("IncorrectBlock")
               << "Xtal id was expected to increase but it didn't - last valid xtal id was " << lastXtalId_
               << " while current xtal is " << xtalId << " (LV1 " << event_->l1A() << " fed " << mapper_->getActiveDCC()
               << " tower " << towerId_ << ")";
         }
  
         int st = lastStripId_;
         int ch = lastXtalId_;
         ch++;
         if (ch > NUMB_XTAL) {
           ch = 1;
           st++;
         }
         if (st > NUMB_STRIP) {
           ch = 1;
           st = 1;
         }
  
         // adding channel following the last valid
         //pDetId_ = (EBDetId*) mapper_->getDetIdPointer(towerId_,st,ch);
         //(*invalidChIds_)->push_back(*pDetId_);
         fillEcalElectronicsError(invalidZSXtalIds_);
  
         lastStripId_ = st;
         lastXtalId_ = ch;
  
         // return here, so to skip all following checks
         return SKIP_BLOCK_UNPACKING;
         errorOnXtal = true;  //keep it here in case the return is to be dropped
       }
  
       // if channel id not proven wrong, update lastStripId_ and lastXtalId_
       lastStripId_ = stripId;
       lastXtalId_ = xtalId;
     }  //end else
   }    // end if (zs_)
  
   bool addedFrame = false;
  
   // if there is an error on xtal id ignore next error checks
   // otherwise, assume channel_id is valid and proceed with making and checking the data frame
   if (errorOnXtal)
     return SKIP_BLOCK_UNPACKING;
  
   pDetId_ = (EBDetId *)mapper_->getDetIdPointer(towerId_, stripId, xtalId);
   (*digis_)->push_back(*pDetId_);
   EBDataFrame df((*digis_)->back());
   addedFrame = true;
   bool wrongGain(false);
  
   //set samples in the data frame
   for (unsigned int i = 0; i < nTSamples_; i++) {  // loop on samples
     xData_++;
     unsigned int data = (*xData_) & TOWER_DIGI_MASK;
     unsigned int gain = data >> 12;
     xtalGains_[i] = gain;
     if (gain == 0) {
       wrongGain = true;
       // although gain==0 found, produce the dataFrame in order to have it, for saturation case
     }
     df.setSample(i, data);
   }  // loop on samples
  
   bool isSaturation(true);
   if (wrongGain) {
     // check whether the gain==0 has features of saturation or not
     // gain==0 occurs either in case of data corruption or of ADC saturation
     //                                  \->reject digi            \-> keep digi
  
     // determine where gainId==0 starts
     short firstGainZeroSampID(-1);
     short firstGainZeroSampADC(-1);
     for (unsigned int s = 0; s < nTSamples_; s++) {
       if (df.sample(s).gainId() == 0 && firstGainZeroSampID == -1) {
         firstGainZeroSampID = s;
         firstGainZeroSampADC = df.sample(s).adc();
         break;
       }
     }
  
     // check whether gain==0 and adc() stays constant for (at least) 5 consecutive samples
     unsigned int plateauEnd = std::min(nTSamples_, (unsigned int)(firstGainZeroSampID + 5));
     for (unsigned int s = firstGainZeroSampID; s < plateauEnd; s++) {
       if (df.sample(s).gainId() == 0 && df.sample(s).adc() == firstGainZeroSampADC) {
         ;
       } else {
         isSaturation = false;
         break;
       }  //it's not saturation
     }
     // get rid of channels which are stuck in gain0
     if (firstGainZeroSampID < 3) {
       isSaturation = false;
     }
  
     if (!DCCDataUnpacker::silentMode_) {
       if (unpacker_->getChannelValue(mapper_->getActiveDCC(), towerId_, stripId, xtalId) != 10) {
         edm::LogWarning("IncorrectGain") << "Gain zero" << (isSaturation ? " with features of saturation" : "")
                                          << " was found in Tower Block"
                                          << " (L1A " << event_->l1A() << " bx " << event_->bx() << " fed "
                                          << mapper_->getActiveDCC() << " tower " << towerId_ << " strip " << stripId
                                          << " xtal " << xtalId << ")";
       }
     }
  
     if (!isSaturation) {
       (*invalidGains_)->push_back(*pDetId_);
       (*digis_)->pop_back();
  
       //Point to begin of next xtal Block
       data_ += numbDWInXtalBlock_;
       //return here, so to skip all the rest
       //make special collection for gain0 data frames when due to saturation
       return BLOCK_UNPACKED;
       errorOnXtal = true;  //keep it here in case the return is to be dropped
     }                      //end isSaturation
     else {
       data_ += numbDWInXtalBlock_;
       return BLOCK_UNPACKED;
     }
  
   }  //end WrongGain
  
   // from here on, care about gain switches
  
   short numGain = 1;
   bool gainSwitchError = false;
  
   for (unsigned int i = 1; i < nTSamples_; i++) {
     if (xtalGains_[i - 1] > xtalGains_[i] && numGain < 5)
       gainSwitchError = true;
     if (xtalGains_[i - 1] == xtalGains_[i])
       numGain++;
     else
       numGain = 1;
   }
  
   if (gainSwitchError) {
     if (!DCCDataUnpacker::silentMode_) {
       edm::LogWarning("IncorrectGain") << "A wrong gain transition switch was found for Tower Block in strip "
                                        << stripId << " and xtal " << xtalId << " (L1A " << event_->l1A() << " bx "
                                        << event_->bx() << " fed " << mapper_->getActiveDCC() << " tower " << towerId_
                                        << ")";
     }
  
     (*invalidGainsSwitch_)->push_back(*pDetId_);
     errorOnXtal = true;
   }
  
   //Add frame to collection only if all data format and gain rules are respected
   if (errorOnXtal && addedFrame) {
     (*digis_)->pop_back();
   }
  
   //Point to begin of next xtal Block
   data_ += numbDWInXtalBlock_;
  
   return BLOCK_UNPACKED;
 }

References BLOCK_UNPACKED, DCCEventBlock::bx(), data, DCCDataBlockPrototype::data_, hgcalPerformanceValidation::df, DCCDataBlockPrototype::event_, fillEcalElectronicsError(), PedestalClient_cfi::gain, EcalElectronicsMapper::getActiveDCC(), DCCDataUnpacker::getChannelValue(), EcalElectronicsMapper::getDetIdPointer(), mps_fire::i, DCCFEBlock::invalidZSXtalIds_, DCCEventBlock::l1A(), DCCFEBlock::lastStripId_, DCCFEBlock::lastXtalId_, DCCDataBlockPrototype::mapper_, min(), DCCFEBlock::nTSamples_, NUMB_STRIP, NUMB_XTAL, DCCFEBlock::numbDWInXtalBlock_, pDetId_, alignCSCRings::s, DCCDataUnpacker::silentMode_, SKIP_BLOCK_UNPACKING, TOWER_DIGI_MASK, TOWER_STRIPID_MASK, TOWER_XTALID_B, TOWER_XTALID_MASK, DCCFEBlock::towerId_, DCCDataBlockPrototype::unpacker_, DCCFEBlock::xtalGains_, and DCCFEBlock::zs_.

◆ updateCollectors()

void DCCTowerBlock::updateCollectors ( )

overridevirtual

Reimplemented from DCCFEBlock.

Definition at line 12 of file DCCTowerBlock.cc.

                                      {
   DCCFEBlock::updateCollectors();
  
   // needs to be update for eb/ee
   digis_ = unpacker_->ebDigisCollection();
  
   invalidGains_ = unpacker_->invalidGainsCollection();
   invalidGainsSwitch_ = unpacker_->invalidGainsSwitchCollection();
   invalidChIds_ = unpacker_->invalidChIdsCollection();
 }