#include <DCCMemBlock.h>

Inheritance diagram for DCCMemBlock:

Public Member Functions
	DCCMemBlock (DCCDataUnpacker u, EcalElectronicsMapper m, DCCEventBlock *e)

void	display (std::ostream &o) override

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

void	updateCollectors () override

	~DCCMemBlock () override

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

void	enableSyncChecks ()

virtual unsigned int	getLength ()

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

virtual void	updateEventPointers ()

virtual	~DCCDataBlockPrototype ()

Protected Member Functions
void	fillPnDiodeDigisCollection ()

void	unpackMemTowerData ()

Protected Attributes
unsigned int	bx_

unsigned int	expTowerID_

unsigned int	expXtalTSamples_

std::unique_ptr< EcalElectronicsIdCollection > *	invalidMemBlockSizes_

std::unique_ptr< EcalElectronicsIdCollection > *	invalidMemChIds_

std::unique_ptr< EcalElectronicsIdCollection > *	invalidMemGains_

std::unique_ptr< EcalElectronicsIdCollection > *	invalidMemTtIds_

unsigned int	kSamplesPerPn_

unsigned int	l1_

unsigned int	lastStripId_

unsigned int	lastTowerBeforeMem_

unsigned int	lastXtalId_

unsigned int	nTSamples_

unsigned int	numbDWInXtalBlock_

std::vector< short >	pn_

std::unique_ptr< EcalPnDiodeDigiCollection > *	pnDiodeDigis_

unsigned int	towerId_

unsigned int	unfilteredTowerBlockLength_

unsigned int	xtalBlockSize_

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 34 of file DCCMemBlock.h.

Constructor & Destructor Documentation

DCCMemBlock::DCCMemBlock	(	DCCDataUnpacker *	u,
		EcalElectronicsMapper *	m,
		DCCEventBlock *	e
	)

Definition at line 7 of file DCCMemBlock.cc.

References expXtalTSamples_, EcalElectronicsMapper::getUnfilteredTowerBlockLength(), mps_fire::i, kSamplesPerPn_, DCCDataBlockPrototype::mapper_, numbDWInXtalBlock_, EcalElectronicsMapper::numbXtalTSamples(), pn_, unfilteredTowerBlockLength_, and xtalBlockSize_.

     : DCCDataBlockPrototype(u, m, e) {
   unfilteredTowerBlockLength_ = mapper_->getUnfilteredTowerBlockLength();
   expXtalTSamples_ = mapper_->numbXtalTSamples();
 
   numbDWInXtalBlock_ = (expXtalTSamples_ - 2) / 4 + 1;
   xtalBlockSize_ = numbDWInXtalBlock_ * 8;
   kSamplesPerPn_ = expXtalTSamples_ * 5;
 
   unsigned int numbOfXtalBlocks = (unfilteredTowerBlockLength_ - 1) / numbDWInXtalBlock_;
   unsigned int numbOfPnBlocks = numbOfXtalBlocks / 5;  //change 5 by a variable
   unsigned int vectorSize = numbOfPnBlocks * 10 * expXtalTSamples_;
 
   //Build pnDiodevector
   for (unsigned int i = 0; i < vectorSize; i++) {
     pn_.push_back(-1);
   }
 }

DCCMemBlock::~DCCMemBlock ( )

inlineoverride

Definition at line 38 of file DCCMemBlock.h.

References data, display(), fillPnDiodeDigisCollection(), EcalTangentSkim_cfg::o, DCCDataBlockPrototype::unpack(), unpack(), unpackMemTowerData(), and updateCollectors().

38 {}

Member Function Documentation

void DCCMemBlock::display ( std::ostream & o )

overridevirtual

Reimplemented from DCCDataBlockPrototype.

Definition at line 315 of file DCCMemBlock.cc.

References DCCDataBlockPrototype::blockLength_, bx_, l1_, nTSamples_, and towerId_.

Referenced by ~DCCMemBlock().

                                        {
   o << "\n Unpacked Info for DCC MEM Block"
     << "\n DW1 ============================="
     << "\n Mem Tower Block Id " << towerId_ << "\n Numb Samp " << nTSamples_ << "\n Bx " << bx_ << "\n L1 " << l1_
     << "\n blockLength " << blockLength_;
 }

void DCCMemBlock::fillPnDiodeDigisCollection ( )

protected

Definition at line 260 of file DCCMemBlock.cc.

References EcalBarrel, EcalEndcap, EcalElectronicsMapper::getActiveSM(), kSamplesPerPn_, lastTowerBeforeMem_, DCCDataBlockPrototype::mapper_, NUMB_SM_EB_MIN_MIN, NUMB_SM_EB_PLU_MAX, NUMB_SM_EE_MIN_MAX, NUMB_SM_EE_MIN_MIN, NUMB_SM_EE_PLU_MAX, NUMB_SM_EE_PLU_MIN, pn_, EcalPnDiodeDigi::setSample(), EcalPnDiodeDigi::setSize(), DCCDataUnpacker::silentMode_, and towerId_.

Referenced by unpack(), and ~DCCMemBlock().

                                              {
   //todo change pnId max
   for (int pnId = 1; pnId <= 5; pnId++) {
     bool errorOnPn(false);
     unsigned int realPnId = pnId;
 
     if (towerId_ == 70) {
       realPnId += 5;
     }
 
     // Note : we are assuming always 5 VFE channels enabled
     // This means we all have 5 pns per tower
 
     // solution before sending creation of PnDigi's in mapper as done with crystals
     //     mapper_->getActiveSM()  : this is the 'dccid'
     //     number ranging internally in ECAL from 1 to 54, according convention specified here:
     //     http://indico.cern.ch/getFile.py/access?contribId=0&resId=0&materialId=slides&confId=11621
 
     //     mapper_->getActiveDCC() : this is the FED_id (601 - 654 for ECAL at CMS)
 
     const int activeSM = mapper_->getActiveSM();
     int subdet(0);
     if (NUMB_SM_EB_MIN_MIN <= activeSM && activeSM <= NUMB_SM_EB_PLU_MAX) {
       subdet = EcalBarrel;
     } else if ((NUMB_SM_EE_MIN_MIN <= activeSM && activeSM <= NUMB_SM_EE_MIN_MAX) ||
                (NUMB_SM_EE_PLU_MIN <= activeSM && activeSM <= NUMB_SM_EE_PLU_MAX)) {
       subdet = EcalEndcap;
     } else {
       if (!DCCDataUnpacker::silentMode_) {
         edm::LogWarning("IncorrectMapping") << "\n mapper points to non existing dccid: " << activeSM;
       }
     }
 
     EcalPnDiodeDetId PnId(subdet, activeSM, realPnId);
 
     EcalPnDiodeDigi thePnDigi(PnId);
     thePnDigi.setSize(kSamplesPerPn_);
 
     for (unsigned int ts = 0; ts < kSamplesPerPn_; ts++) {
       short pnDiodeData = pn_[(towerId_ - lastTowerBeforeMem_) * 250 + (pnId - 1) * kSamplesPerPn_ + ts];
       if (pnDiodeData == -1) {
         errorOnPn = true;
         break;
       }
 
       EcalFEMSample thePnSample(pnDiodeData);
       thePnDigi.setSample(ts, thePnSample);
     }
 
     if (!errorOnPn) {
       (*pnDiodeDigis_)->push_back(thePnDigi);
     }
   }
 }

int DCCMemBlock::unpack	(	const uint64_t **	data,
		unsigned int *	dwToEnd,
		unsigned int	expectedTowerID
	)

Definition at line 34 of file DCCMemBlock.cc.

Referenced by DCCEEEventBlock::unpack(), DCCEBEventBlock::unpack(), and ~DCCMemBlock().

                                                                                                   {
   error_ = false;
   datap_ = data;
   data_ = *data;
   dwToEnd_ = dwToEnd;
 
   if ((*dwToEnd_) < 1) {
     if (!DCCDataUnpacker::silentMode_) {
       edm::LogWarning("IncorrectEvent") << "\nUnable to unpack MEM block for event " << event_->l1A() << " in fed "
                                         << mapper_->getActiveDCC() << "\nThe end of event was reached !";
     }
     return STOP_EVENT_UNPACKING;
   }
 
   lastStripId_ = 0;
   lastXtalId_ = 0;
   expTowerID_ = expectedTowerID;
 
   //Point to begin of block
   data_++;
 
   towerId_ = (*data_) & TOWER_ID_MASK;
   nTSamples_ = (*data_ >> TOWER_NSAMP_B) & TOWER_NSAMP_MASK;
   bx_ = (*data_ >> TOWER_BX_B) & TOWER_BX_MASK;
   l1_ = (*data_ >> TOWER_L1_B) & TOWER_L1_MASK;
   blockLength_ = (*data_ >> TOWER_LENGTH_B) & TOWER_LENGTH_MASK;
 
   event_->setFESyncNumbers(l1_, bx_, short(expectedTowerID - 1));
 
   //debugging
   //display(cout);
 
   // Block Length Check (1)
   if (unfilteredTowerBlockLength_ != blockLength_) {
     // chosing channel 1 as representative of a dummy...
     EcalElectronicsId id(mapper_->getActiveSM(), expTowerID_, 1, 1);
     (*invalidMemBlockSizes_)->push_back(id);
     if (!DCCDataUnpacker::silentMode_) {
       edm::LogWarning("IncorrectEvent") << "\nFor event " << event_->l1A() << ", fed " << mapper_->getActiveDCC()
                                         << " and tower block " << towerId_ << "\nExpected mem block size is "
                                         << (unfilteredTowerBlockLength_ * 8) << " bytes while " << (blockLength_ * 8)
                                         << " was found";
     }
     return STOP_EVENT_UNPACKING;
   }
 
   // Block Length Check (2)
   if ((*dwToEnd_) < blockLength_) {
     if (!DCCDataUnpacker::silentMode_) {
       edm::LogWarning("IncorrectEvent") << "\nUnable to unpack MEM block for event " << event_->l1A() << " in fed "
                                         << mapper_->getActiveDCC() << "\n Only " << ((*dwToEnd_) * 8)
                                         << " bytes are available while " << (blockLength_ * 8) << " are needed!";
       // chosing channel 1 as representative of a dummy...
     }
     EcalElectronicsId id(mapper_->getActiveSM(), expTowerID_, 1, 1);
     (*invalidMemBlockSizes_)->push_back(id);
     return STOP_EVENT_UNPACKING;
   }
 
   // Synchronization Check
   if (sync_) {
     const unsigned int dccBx = (event_->bx()) & TOWER_BX_MASK;
     const unsigned int dccL1 = (event_->l1A()) & TOWER_L1_MASK;
     const unsigned int fov = (event_->fov()) & H_FOV_MASK;
 
     if (!isSynced(dccBx, bx_, dccL1, l1_, FE_MEM, fov)) {
       if (!DCCDataUnpacker::silentMode_) {
         edm::LogWarning("IncorrectEvent")
             << "Synchronization error for Mem block"
             << " (L1A " << event_->l1A() << " bx " << event_->bx() << " fed " << mapper_->getActiveDCC() << ")\n"
             << "  dccBx = " << dccBx << " bx_ = " << bx_ << " dccL1 = " << dccL1 << " l1_ = " << l1_ << "\n"
             << "  => Stop event unpacking";
       }
       //Note : add to error collection ?
       // need of a new collection
       return STOP_EVENT_UNPACKING;
     }
   }
 
   // Number Of Samples Check
   if (nTSamples_ != expXtalTSamples_) {
     if (!DCCDataUnpacker::silentMode_) {
       edm::LogWarning("IncorrectEvent") << "\nUnable to unpack MEM block for event " << event_->l1A() << " in fed "
                                         << mapper_->getActiveDCC() << "\nNumber of time samples " << nTSamples_
                                         << " is not the same as expected (" << expXtalTSamples_ << ")";
     }
     //Note : add to error collection ?
     return STOP_EVENT_UNPACKING;
   }
 
   //Channel Id Check
   if (expTowerID_ != towerId_) {
     // chosing channel 1 as representative as a dummy...
     EcalElectronicsId id(mapper_->getActiveSM(), expTowerID_, 1, 1);
     (*invalidMemTtIds_)->push_back(id);
     if (!DCCDataUnpacker::silentMode_) {
       edm::LogWarning("IncorrectBlock") << "For event " << event_->l1A() << " and fed " << mapper_->getActiveDCC()
                                         << " and sm: " << mapper_->getActiveSM() << "\nExpected mem tower block is "
                                         << expTowerID_ << " while " << towerId_ << " was found ";
     }
 
     towerId_ = expTowerID_;
 
     // todo : go to the next mem
     error_ = true;
 
     updateEventPointers();
     return SKIP_BLOCK_UNPACKING;
   }
 
   //point to xtal data
   data_++;
 
   unpackMemTowerData();
 
   if (!error_) {
     fillPnDiodeDigisCollection();
   }
 
   updateEventPointers();
 
   return BLOCK_UNPACKED;
 }

void DCCMemBlock::unpackMemTowerData ( )

protected

Definition at line 158 of file DCCMemBlock.cc.

References DCCDataBlockPrototype::data_, DCCDataBlockPrototype::error_, DCCDataBlockPrototype::event_, PedestalClient_cfi::gain, EcalElectronicsMapper::getActiveDCC(), EcalElectronicsMapper::getActiveSM(), mps_fire::i, cuy::ib, triggerObjects_cff::id, DCCEventBlock::l1A(), lastTowerBeforeMem_, DCCDataBlockPrototype::mapper_, nTSamples_, numbDWInXtalBlock_, pn_, simplePhotonAnalyzer_cfi::sample, DCCDataUnpacker::silentMode_, groupFilesInBlocks::temp, TOWER_DIGI_MASK, TOWER_STRIPID_MASK, TOWER_XTALID_B, TOWER_XTALID_MASK, and towerId_.

Referenced by unpack(), and ~DCCMemBlock().

                                      {
   //todo: move EcalPnDiodeDetId to electronics mapper
 
   lastTowerBeforeMem_ = 0;
   // differentiating the barrel and the endcap case
   if (9 < mapper_->getActiveSM() || mapper_->getActiveSM() < 46) {
     lastTowerBeforeMem_ = 69;
   } else {
     lastTowerBeforeMem_ = 69;
   }
 
   for (unsigned int expStripId = 1; expStripId <= 5; expStripId++) {
     for (unsigned int expXtalId = 1; expXtalId <= 5; expXtalId++) {
       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;
 
       bool errorOnDecoding(false);
 
       if (expStripId != stripId || expXtalId != xtalId) {
         // chosing channel and strip as EcalElectronicsId
         EcalElectronicsId id(mapper_->getActiveSM(), towerId_, expStripId, expXtalId);
         (*invalidMemChIds_)->push_back(id);
 
         if (!DCCDataUnpacker::silentMode_) {
           edm::LogWarning("IncorrectBlock")
               << "For event " << event_->l1A() << ", fed " << mapper_->getActiveDCC() << " and tower mem block "
               << towerId_ << "\nThe expected strip is " << expStripId << " and " << stripId << " was found"
               << "\nThe expected xtal  is " << expXtalId << " and " << xtalId << " was found";
         }
 
         stripId = expStripId;
         xtalId = expXtalId;
 
         errorOnDecoding = true;
 
         //Note : move to the next ...
       }
 
       unsigned int ipn, index;
 
       if ((stripId - 1) % 2 == 0) {
         ipn = (towerId_ - lastTowerBeforeMem_) * 5 + xtalId - 1;
       } else {
         ipn = (towerId_ - lastTowerBeforeMem_) * 5 + 5 - xtalId;
       }
 
       //Cooking samples
       for (unsigned int i = 0; i < nTSamples_; i++) {
         xData_++;
 
         index = ipn * 50 + (stripId - 1) * nTSamples_ + i;
 
         //edm::LogDebug("EcalRawToDigiMemChId")<<"\n Strip id "<<std::dec<<stripId<<" Xtal id "<<xtalId
         //  <<" tsamp = "<<i<<" 16b = 0x "<<std::hex<<(*xData_)<<dec;
 
         unsigned int temp = (*xData_) & TOWER_DIGI_MASK;
 
         short sample(0);
 
         if ((stripId - 1) % 2) {
           // If strip number is even, 14 bits are reversed in order
           for (int ib = 0; ib < 14; ib++) {
             sample <<= 1;
             sample |= (temp & 1);
             temp >>= 1;
           }
 
         } else {
           sample = temp;
         }
 
         sample ^= 0x800;
         unsigned int gain = sample >> 12;
 
         if (gain >= 2) {
           EcalElectronicsId id(mapper_->getActiveSM(), towerId_, stripId, xtalId);
           (*invalidMemGains_)->push_back(id);
 
           if (!DCCDataUnpacker::silentMode_) {
             edm::LogWarning("IncorrectGain")
                 << "For event " << event_->l1A() << ", fed " << mapper_->getActiveDCC() << " , mem tower block "
                 << towerId_ << "\nIn strip " << stripId << " xtal " << xtalId << " the gain is " << gain
                 << " in sample " << (i + 1);
           }
 
           errorOnDecoding = true;
         }
 
         if (!errorOnDecoding && !error_) {
           pn_[index] = sample;
         }  //Note : move to the next versus flag...
 
       }  // loop over samples ended
 
       data_ += numbDWInXtalBlock_;
     }  //loop over xtals
   }    // loop over strips
 }

void DCCMemBlock::updateCollectors ( )

overridevirtual

Reimplemented from DCCDataBlockPrototype.

Definition at line 26 of file DCCMemBlock.cc.

References invalidMemBlockSizes_, DCCDataUnpacker::invalidMemBlockSizesCollection(), invalidMemChIds_, DCCDataUnpacker::invalidMemChIdsCollection(), invalidMemGains_, DCCDataUnpacker::invalidMemGainsCollection(), invalidMemTtIds_, DCCDataUnpacker::invalidMemTtIdsCollection(), pnDiodeDigis_, DCCDataUnpacker::pnDiodeDigisCollection(), and DCCDataBlockPrototype::unpacker_.

Referenced by DCCEventBlock::updateCollectors(), and ~DCCMemBlock().

                                    {
   invalidMemChIds_ = unpacker_->invalidMemChIdsCollection();
   invalidMemBlockSizes_ = unpacker_->invalidMemBlockSizesCollection();
   invalidMemTtIds_ = unpacker_->invalidMemTtIdsCollection();
   invalidMemGains_ = unpacker_->invalidMemGainsCollection();
   pnDiodeDigis_ = unpacker_->pnDiodeDigisCollection();
 }