#include <PixelDataFormatter.h>

Public Types
using	BadChannels = std::map< cms_uint32_t, DetBadChannels >

using	Collection = edm::DetSetVector< PixelDigi >

using	DetBadChannels = std::vector< PixelFEDChannel >

using	DetDigis = std::vector< PixelDigi >

using	DetErrors = std::vector< SiPixelRawDataError >

using	Digis = std::map< cms_uint32_t, DetDigis >

using	Errors = std::map< cms_uint32_t, DetErrors >

using	FEDWordsMap = std::map< int, std::vector< Word32 >>

using	ModuleIDSet = std::set< unsigned int >

using	RawData = std::map< int, FEDRawData >

Public Member Functions
void	formatRawData (unsigned int lvl1_ID, RawData &fedRawData, const Digis &digis, const BadChannels &badChannels)

void	interpretRawData (bool &errorsInEvent, int fedId, const FEDRawData &data, Collection &digis, Errors &errors)

int	nDigis () const

int	nWords () const

void	passFrameReverter (const SiPixelFrameReverter *reverter)

	PixelDataFormatter (const SiPixelFedCablingTree *map, bool phase1_=false)

void	setErrorStatus (bool ErrorStatus)

void	setModulesToUnpack (const ModuleIDSet *moduleIds)

void	setQualityStatus (bool QualityStatus, const SiPixelQuality *QualityInfo)

void	unpackFEDErrors (Errors const &errors, std::vector< int > const &tkerrorlist, std::vector< int > const &usererrorlist, edm::DetSetVector< SiPixelRawDataError > &errorcollection, DetIdCollection &tkerror_detidcollection, DetIdCollection &usererror_detidcollection, edmNew::DetSetVector< PixelFEDChannel > &disabled_channelcollection, DetErrors &nodeterrors)

Private Member Functions
int	checkError (const Word32 &data) const

int	digi2word (cms_uint32_t detId, const PixelDigi &digi, FEDWordsMap &words) const

int	digi2wordPhase1Layer1 (cms_uint32_t detId, const PixelDigi &digi, FEDWordsMap &words) const

cms_uint32_t	errorDetId (const SiPixelFrameConverter *converter, int fedId, int errorType, const Word32 &word) const

std::string	print (const PixelDigi &digi) const

std::string	print (const Word64 &word) const

Private Attributes
int	allDetDigis_

const SiPixelQuality *	badPixelInfo_

std::unique_ptr< ErrorCheckerBase >	errorcheck_

int	hasDetDigis_

bool	includeErrors_

int	maxROCIndex_

const ModuleIDSet *	modulesToUnpack_

bool	phase1_

SiPixelFedCablingTree const *	theCablingTree_

int	theDigiCounter_

const SiPixelFrameReverter *	theFrameReverter_

int	theWordCounter_

bool	useQualityInfo_

Detailed Description

Transforms Pixel raw data of a given FED to orca digi and vice versa.

FED OUTPUT DATA FORMAT 6/02, d.k. (11/02 updated for 100*150 pixels)

The output is transmitted through a 64 bit S-link connection. The packet format is defined by the CMS RU group to be : 1st packet header, 64 bits, includes a 6 bit FED id. 2nd packet header, 64 bits. .......................... (detector data) packet trailer, 64 bits. of the 64 bit pixel data records consists of 2 32 bit words. Each 32 bit word includes data from 1 pixel, the bit fields are the following:

6 bit link ID (max 36) - this defines the input link within 1 FED. 5 bit ROC ID (max 24) - this defines the readout chip within one link. 5 bit DCOL ID (max 26) - this defines the double column index with 1 chip. 8 bit pixel ID (max 180) - this defines the pixel address within 1 DCOL. 8 bit ADC vales - this has the charge amplitude.

So, 1 pixel occupies 4 bytes. If the number of pixels is odd, one extra 32 bit word is added (value 0) to fill all 64 bits.

The PixelDataFormatter interpret/format ONLY detector data words (not FED headers or trailer, which are treated elsewhere).

Definition at line 61 of file PixelDataFormatter.h.

Member Typedef Documentation

using PixelDataFormatter::BadChannels = std::map<cms_uint32_t, DetBadChannels>

Definition at line 70 of file PixelDataFormatter.h.

using PixelDataFormatter::Collection = edm::DetSetVector<PixelDigi>

Definition at line 65 of file PixelDataFormatter.h.

using PixelDataFormatter::DetBadChannels = std::vector<PixelFEDChannel>

Definition at line 69 of file PixelDataFormatter.h.

using PixelDataFormatter::DetDigis = std::vector<PixelDigi>

Definition at line 67 of file PixelDataFormatter.h.

using PixelDataFormatter::DetErrors = std::vector<SiPixelRawDataError>

Definition at line 63 of file PixelDataFormatter.h.

using PixelDataFormatter::Digis = std::map<cms_uint32_t, DetDigis>

Definition at line 68 of file PixelDataFormatter.h.

using PixelDataFormatter::Errors = std::map<cms_uint32_t, DetErrors>

Definition at line 64 of file PixelDataFormatter.h.

using PixelDataFormatter::FEDWordsMap = std::map<int, std::vector<Word32>>

Definition at line 71 of file PixelDataFormatter.h.

using PixelDataFormatter::ModuleIDSet = std::set<unsigned int>

Definition at line 72 of file PixelDataFormatter.h.

using PixelDataFormatter::RawData = std::map<int, FEDRawData>

Definition at line 66 of file PixelDataFormatter.h.

Constructor & Destructor Documentation

PixelDataFormatter::PixelDataFormatter	(	const SiPixelFedCablingTree *	map,
		bool	phase1_ = `false`
	)

Definition at line 28 of file PixelDataFormatter.cc.

References allDetDigis_, errorcheck_, hasDetDigis_, includeErrors_, maxROCIndex_, phase1_, and useQualityInfo_.

     : theDigiCounter_(0),
       theWordCounter_(0),
       theCablingTree_(map),
       badPixelInfo_(nullptr),
       modulesToUnpack_(nullptr),
       phase1_(phase) {
   int s32 = sizeof(Word32);
   int s64 = sizeof(Word64);
   int s8 = sizeof(char);
   if (s8 != 1 || s32 != 4 * s8 || s64 != 2 * s32) {
     LogError("UnexpectedSizes") << " unexpected sizes: "
                                 << "  size of char is: " << s8 << ", size of Word32 is: " << s32
                                 << ", size of Word64 is: " << s64 << ", send exception";
   }
   includeErrors_ = false;
   useQualityInfo_ = false;
   allDetDigis_ = 0;
   hasDetDigis_ = 0;
 
   if (phase1_) {
     maxROCIndex_ = 8;
     errorcheck_ = std::unique_ptr<ErrorCheckerBase>(new ErrorChecker());
   } else {
     maxROCIndex_ = 25;
     errorcheck_ = std::unique_ptr<ErrorCheckerBase>(new ErrorCheckerPhase0());
   }
 }

Member Function Documentation

int PixelDataFormatter::checkError ( const Word32 & data ) const

private

int PixelDataFormatter::digi2word	(	cms_uint32_t	detId,
		const PixelDigi &	digi,
		FEDWordsMap &	words
	)		const

private

Definition at line 316 of file PixelDataFormatter.cc.

References PixelDigi::adc(), sipixelconstants::ADC_shift, PixelDigi::column(), sipixelobjects::ElectronicIndex::dcol, sipixelconstants::DCOL_shift, l1tstage2_dqm_sourceclient-live_cfg::fedId, sipixelobjects::ElectronicIndex::link, sipixelconstants::LINK_shift, LogDebug, print(), sipixelobjects::ElectronicIndex::pxid, sipixelconstants::PXID_shift, sipixelobjects::ElectronicIndex::roc, sipixelconstants::ROC_shift, PixelDigi::row(), theFrameReverter_, theWordCounter_, and SiPixelFrameReverter::toCabling().

Referenced by formatRawData().

                                                                              {
   LogDebug("PixelDataFormatter") << print(digi);
 
   DetectorIndex detector = {detId, digi.row(), digi.column()};
   ElectronicIndex cabling;
   int fedId = theFrameReverter_->toCabling(cabling, detector);
   if (fedId < 0)
     return fedId;
 
   Word32 word = (cabling.link << LINK_shift) | (cabling.roc << ROC_shift) | (cabling.dcol << DCOL_shift) |
                 (cabling.pxid << PXID_shift) | (digi.adc() << ADC_shift);
   words[fedId].push_back(word);
   theWordCounter_++;
 
   return fedId;
 }

int PixelDataFormatter::digi2wordPhase1Layer1	(	cms_uint32_t	detId,
		const PixelDigi &	digi,
		FEDWordsMap &	words
	)		const

private

Definition at line 334 of file PixelDataFormatter.cc.

References PixelDigi::adc(), sipixelconstants::ADC_shift, cuy::col, sipixelconstants::phase1layer1::COL_shift, PixelDigi::column(), sipixelobjects::ElectronicIndex::dcol, l1tstage2_dqm_sourceclient-live_cfg::fedId, sipixelobjects::ElectronicIndex::link, sipixelconstants::LINK_shift, LogDebug, phase1PixelTopology::numRowsInRoc, print(), sipixelobjects::ElectronicIndex::pxid, sipixelobjects::ElectronicIndex::roc, sipixelconstants::ROC_shift, PixelDigi::row(), sipixelconstants::phase1layer1::ROW_shift, theFrameReverter_, theWordCounter_, and SiPixelFrameReverter::toCabling().

Referenced by formatRawData().

                                                                                          {
   LogDebug("PixelDataFormatter") << print(digi);
 
   DetectorIndex detector = {detId, digi.row(), digi.column()};
   ElectronicIndex cabling;
   int fedId = theFrameReverter_->toCabling(cabling, detector);
   if (fedId < 0)
     return fedId;
 
   int col = ((cabling.dcol) * 2) + ((cabling.pxid) % 2);
   int row = LocalPixel::numRowsInRoc - ((cabling.pxid) / 2);
 
   Word32 word = (cabling.link << LINK_shift) | (cabling.roc << ROC_shift) | (col << COL_shift) | (row << ROW_shift) |
                 (digi.adc() << ADC_shift);
   words[fedId].push_back(word);
   theWordCounter_++;
 
   return fedId;
 }

cms_uint32_t PixelDataFormatter::errorDetId	(	const SiPixelFrameConverter *	converter,
		int	fedId,
		int	errorType,
		const Word32 &	word
	)		const

private

Referenced by unpackFEDErrors().

void PixelDataFormatter::formatRawData	(	unsigned int	lvl1_ID,
		RawData &	fedRawData,
		const Digis &	digis,
		const BadChannels &	badChannels
	)

Definition at line 213 of file PixelDataFormatter.cc.

References allDetDigis_, Reference_intrackfit_cff::barrel, FEDRawData::data(), digi2word(), digi2wordPhase1Layer1(), Exception, l1tstage2_dqm_sourceclient-live_cfg::fedId, sipixelconstants::functions::getLink(), hasDetDigis_, mps_fire::i, PixelModuleName::isBarrel(), phase1PixelTopology::layer, sipixelconstants::LINK_shift, LogDebug, LogTrace, phase1_, print(), sipixelconstants::ROC_shift, alignCSCRings::s, FEDHeader::set(), FEDTrailer::set(), theDigiCounter_, and theWordCounter_.

                                                                        {
   std::map<int, vector<Word32> > words;
 
   // translate digis into 32-bit raw words and store in map indexed by Fed
   for (Digis::const_iterator im = digis.begin(); im != digis.end(); im++) {
     allDetDigis_++;
     cms_uint32_t rawId = im->first;
     int layer = 0;
     bool barrel = PixelModuleName::isBarrel(rawId);
     if (barrel)
       layer = PixelROC::bpixLayerPhase1(rawId);
 
     BadChannels::const_iterator detBadChannels = badChannels.find(rawId);
 
     hasDetDigis_++;
     const DetDigis& detDigis = im->second;
     for (DetDigis::const_iterator it = detDigis.begin(); it != detDigis.end(); it++) {
       theDigiCounter_++;
       const PixelDigi& digi = (*it);
       int fedId = 0;
 
       if (layer == 1 && phase1_)
         fedId = digi2wordPhase1Layer1(rawId, digi, words);
       else
         fedId = digi2word(rawId, digi, words);
 
       if (fedId < 0) {
         LogError("FormatDataException") << " digi2word returns error #" << fedId << " Ndigis: " << theDigiCounter_
                                         << endl
                                         << " detector: " << rawId << endl
                                         << print(digi) << endl;
       } else if (detBadChannels != badChannels.end()) {
         auto badChannel =
             std::find_if(detBadChannels->second.begin(), detBadChannels->second.end(), [&](const PixelFEDChannel& ch) {
               return (int(ch.fed) == fedId && ch.link == getLink(words[fedId].back()));
             });
         if (badChannel != detBadChannels->second.end()) {
           LogError("FormatDataException") << " while marked bad, found digi for FED " << fedId << " Link "
                                           << getLink(words[fedId].back()) << " on module " << rawId << endl
                                           << print(digi) << endl;
         }
       }  // if (fedId)
     }    // for (DetDigis
   }      // for (Digis
   LogTrace(" allDetDigis_/hasDetDigis_ : ") << allDetDigis_ << "/" << hasDetDigis_;
 
   // fill FED error 25 words
   for (const auto& detBadChannels : badChannels) {
     for (const auto& badChannel : detBadChannels.second) {
       unsigned int FEDError25 = 25;
       Word32 word = (badChannel.link << LINK_shift) | (FEDError25 << ROC_shift);
       words[badChannel.fed].push_back(word);
       theWordCounter_++;
     }
   }
 
   typedef std::map<int, vector<Word32> >::const_iterator RI;
   for (RI feddata = words.begin(); feddata != words.end(); feddata++) {
     int fedId = feddata->first;
     // since raw words are written in the form of 64-bit packets
     // add extra 32-bit word to make number of words even if necessary
     if (words.find(fedId)->second.size() % 2 != 0)
       words[fedId].push_back(Word32(0));
 
     // size in Bytes; create output structure
     int dataSize = words.find(fedId)->second.size() * sizeof(Word32);
     int nHeaders = 1;
     int nTrailers = 1;
     dataSize += (nHeaders + nTrailers) * sizeof(Word64);
     FEDRawData* rawData = new FEDRawData(dataSize);
 
     // get begining of data;
     Word64* word = reinterpret_cast<Word64*>(rawData->data());
 
     // write one header
     FEDHeader::set(reinterpret_cast<unsigned char*>(word), 0, lvl1_ID, 0, fedId);
     word++;
 
     // write data
     unsigned int nWord32InFed = words.find(fedId)->second.size();
     for (unsigned int i = 0; i < nWord32InFed; i += 2) {
       *word = (Word64(words.find(fedId)->second[i + 1]) << 32) | words.find(fedId)->second[i];
       LogDebug("PixelDataFormatter") << print(*word);
       word++;
     }
 
     // write one trailer
     FEDTrailer::set(reinterpret_cast<unsigned char*>(word), dataSize / sizeof(Word64), 0, 0, 0);
     word++;
 
     // check memory
     if (word != reinterpret_cast<Word64*>(rawData->data() + dataSize)) {
       string s = "** PROBLEM in PixelDataFormatter !!!";
       throw cms::Exception(s);
     }  // if (word !=
     fedRawData[fedId] = *rawData;
     delete rawData;
   }  // for (RI feddata
 }

void PixelDataFormatter::interpretRawData	(	bool &	errorsInEvent,
		int	fedId,
		const FEDRawData &	data,
		Collection &	digis,
		Errors &	errors
	)

Definition at line 71 of file PixelDataFormatter.cc.

References gpuClustering::adc, badPixelInfo_, Reference_intrackfit_cff::barrel, sipixelobjects::GlobalPixel::col, cuy::col, FEDRawData::data(), edm::DetSet< T >::data, errorcheck_, edm::DetSetVector< T >::find_or_insert(), sipixelconstants::functions::getADC(), sipixelconstants::functions::getCol(), sipixelconstants::functions::getDCol(), sipixelconstants::functions::getLink(), sipixelconstants::functions::getPxId(), sipixelconstants::functions::getROC(), sipixelconstants::functions::getRow(), PixelModuleName::isBarrel(), SiPixelQuality::IsRocBad(), phase1PixelTopology::layer, LIKELY, MainPageGenerator::link, LogDebug, LogTrace, maxROCIndex_, modulesToUnpack_, nWords(), phase1_, print(), PixelMapPlotter::roc, sipixelobjects::GlobalPixel::row, FEDRawData::size(), theCablingTree_, theWordCounter_, SiPixelFrameConverter::toRoc(), UNLIKELY, useQualityInfo_, sipixelobjects::LocalPixel::RocRowCol::valid(), and sipixelobjects::LocalPixel::DcolPxid::valid().

                                                                                                   {
   using namespace sipixelobjects;
 
   int nWords = rawData.size() / sizeof(Word64);
   if (nWords == 0)
     return;
 
   SiPixelFrameConverter converter(theCablingTree_, fedId);
 
   // check CRC bit
   const Word64* trailer = reinterpret_cast<const Word64*>(rawData.data()) + (nWords - 1);
   if (!errorcheck_->checkCRC(errorsInEvent, fedId, trailer, errors))
     return;
 
   // check headers
   const Word64* header = reinterpret_cast<const Word64*>(rawData.data());
   header--;
   bool moreHeaders = true;
   while (moreHeaders) {
     header++;
     LogTrace("") << "HEADER:  " << print(*header);
     bool headerStatus = errorcheck_->checkHeader(errorsInEvent, fedId, header, errors);
     moreHeaders = headerStatus;
   }
 
   // check trailers
   bool moreTrailers = true;
   trailer++;
   while (moreTrailers) {
     trailer--;
     LogTrace("") << "TRAILER: " << print(*trailer);
     bool trailerStatus = errorcheck_->checkTrailer(errorsInEvent, fedId, nWords, trailer, errors);
     moreTrailers = trailerStatus;
   }
 
   // data words
   theWordCounter_ += 2 * (nWords - 2);
   LogTrace("") << "data words: " << (trailer - header - 1);
 
   int link = -1;
   int roc = -1;
   int layer = 0;
   PixelROC const* rocp = nullptr;
   bool skipROC = false;
   edm::DetSet<PixelDigi>* detDigis = nullptr;
 
   const Word32* bw = (const Word32*)(header + 1);
   const Word32* ew = (const Word32*)(trailer);
   if (*(ew - 1) == 0) {
     ew--;
     theWordCounter_--;
   }
   for (auto word = bw; word < ew; ++word) {
     LogTrace("") << "DATA: " << print(*word);
 
     auto ww = *word;
     if UNLIKELY (ww == 0) {
       theWordCounter_--;
       continue;
     }
     int nlink = getLink(ww);
     int nroc = getROC(ww);
 
     if ((nlink != link) | (nroc != roc)) {  // new roc
       link = nlink;
       roc = nroc;
       skipROC = LIKELY(roc < maxROCIndex_)
                     ? false
                     : !errorcheck_->checkROC(errorsInEvent, fedId, &converter, theCablingTree_, ww, errors);
       if (skipROC)
         continue;
       rocp = converter.toRoc(link, roc);
       if UNLIKELY (!rocp) {
         errorsInEvent = true;
         errorcheck_->conversionError(fedId, &converter, 2, ww, errors);
         skipROC = true;
         continue;
       }
       auto rawId = rocp->rawId();
       bool barrel = PixelModuleName::isBarrel(rawId);
       if (barrel)
         layer = PixelROC::bpixLayerPhase1(rawId);
       else
         layer = 0;
 
       if (useQualityInfo_ & (nullptr != badPixelInfo_)) {
         short rocInDet = (short)rocp->idInDetUnit();
         skipROC = badPixelInfo_->IsRocBad(rawId, rocInDet);
         if (skipROC)
           continue;
       }
       skipROC = modulesToUnpack_ && (modulesToUnpack_->find(rawId) == modulesToUnpack_->end());
       if (skipROC)
         continue;
 
       detDigis = &digis.find_or_insert(rawId);
       if ((*detDigis).empty())
         (*detDigis).data.reserve(32);  // avoid the first relocations
     }
 
     // skip is roc to be skipped ot invalid
     if UNLIKELY (skipROC || !rocp)
       continue;
 
     int adc = getADC(ww);
     std::unique_ptr<LocalPixel> local;
 
     if (phase1_ && layer == 1) {  // special case for layer 1ROC
       // for l1 roc use the roc column and row index instead of dcol and pixel index.
       int col = getCol(ww);
       int row = getRow(ww);
 
       LocalPixel::RocRowCol localCR = {row, col};  // build pixel
       if UNLIKELY (!localCR.valid()) {
         LogDebug("PixelDataFormatter::interpretRawData") << "status #3";
         errorsInEvent = true;
         errorcheck_->conversionError(fedId, &converter, 3, ww, errors);
         continue;
       }
       local = std::make_unique<LocalPixel>(localCR);  // local pixel coordinate
 
     } else {  // phase0 and phase1 except bpix layer 1
       int dcol = getDCol(ww);
       int pxid = getPxId(ww);
       LocalPixel::DcolPxid localDP = {dcol, pxid};
 
       if UNLIKELY (!localDP.valid()) {
         LogDebug("PixelDataFormatter::interpretRawData") << "status #3";
         errorsInEvent = true;
         errorcheck_->conversionError(fedId, &converter, 3, ww, errors);
         continue;
       }
       local = std::make_unique<LocalPixel>(localDP);  // local pixel coordinate
     }
 
     GlobalPixel global = rocp->toGlobal(*local);  // global pixel coordinate (in module)
     (*detDigis).data.emplace_back(global.row, global.col, adc);
     LogTrace("") << (*detDigis).data.back();
   }
 }

int PixelDataFormatter::nDigis ( ) const

inline

Definition at line 81 of file PixelDataFormatter.h.

References theDigiCounter_.

81 { return theDigiCounter_; }

PixelDataFormatter::theDigiCounter_

int theDigiCounter_

Definition: PixelDataFormatter.h:98

int PixelDataFormatter::nWords ( ) const

inline

Definition at line 82 of file PixelDataFormatter.h.

References theWordCounter_.

Referenced by interpretRawData().

82 { return theWordCounter_; }

PixelDataFormatter::theWordCounter_

int theWordCounter_

Definition: PixelDataFormatter.h:99

void PixelDataFormatter::passFrameReverter ( const SiPixelFrameReverter * reverter )

Definition at line 69 of file PixelDataFormatter.cc.

References theFrameReverter_.

69 { theFrameReverter_ = reverter; }

PixelDataFormatter::theFrameReverter_

const SiPixelFrameReverter * theFrameReverter_

Definition: PixelDataFormatter.h:102

std::string PixelDataFormatter::print ( const PixelDigi & digi ) const

private

Definition at line 356 of file PixelDataFormatter.cc.

References PixelDigi::adc(), PixelDigi::column(), PixelDigi::row(), and str.

Referenced by digi2word(), digi2wordPhase1Layer1(), formatRawData(), and interpretRawData().

                                                                {
   ostringstream str;
   str << " DIGI: row: " << digi.row() << ", col: " << digi.column() << ", adc: " << digi.adc();
   return str.str();
 }

std::string PixelDataFormatter::print ( const Word64 & word ) const

private

Definition at line 362 of file PixelDataFormatter.cc.

References str.

                                                             {
   ostringstream str;
   str << "word64:  " << reinterpret_cast<const bitset<64>&>(word);
   return str.str();
 }

void PixelDataFormatter::setErrorStatus ( bool ErrorStatus )

Definition at line 57 of file PixelDataFormatter.cc.

References errorcheck_, and includeErrors_.

Referenced by SiPixelRawToDigi::produce().

                                                         {
   includeErrors_ = ErrorStatus;
   errorcheck_->setErrorStatus(includeErrors_);
 }

void PixelDataFormatter::setModulesToUnpack ( const ModuleIDSet * moduleIds )

Definition at line 67 of file PixelDataFormatter.cc.

References modulesToUnpack_.

67 { modulesToUnpack_ = moduleIds; }

PixelDataFormatter::modulesToUnpack_

const ModuleIDSet * modulesToUnpack_

Definition: PixelDataFormatter.h:104

void PixelDataFormatter::setQualityStatus	(	bool	QualityStatus,
		const SiPixelQuality *	QualityInfo
	)

Definition at line 62 of file PixelDataFormatter.cc.

References badPixelInfo_, and useQualityInfo_.

                                                                                                {
   useQualityInfo_ = QualityStatus;
   badPixelInfo_ = QualityInfo;
 }

void PixelDataFormatter::unpackFEDErrors	(	PixelDataFormatter::Errors const &	errors,
		std::vector< int > const &	tkerrorlist,
		std::vector< int > const &	usererrorlist,
		edm::DetSetVector< SiPixelRawDataError > &	errorcollection,
		DetIdCollection &	tkerror_detidcollection,
		DetIdCollection &	usererror_detidcollection,
		edmNew::DetSetVector< PixelFEDChannel > &	disabled_channelcollection,
		DetErrors &	nodeterrors
	)

Definition at line 368 of file PixelDataFormatter.cc.

References edm::DetSet< T >::data, sipixelconstants::dummyDetId, errorDetId(), SiPixelFedCablingTree::fed(), l1tstage2_dqm_sourceclient-live_cfg::fedId, spr::find(), edm::DetSetVector< T >::find_or_insert(), sipixelconstants::functions::getLink(), sipixelobjects::PixelFEDCabling::id(), sipixelobjects::PixelROC::idInDetUnit(), edmNew::DetSetVector< T >::insert(), sipixelobjects::PixelFEDCabling::link(), MainPageGenerator::link, phase1_, edm::EDCollection< T >::push_back(), PixelMapPlotter::roc, PixelFEDChannel::roc_first, PixelFEDChannel::roc_last, and theCablingTree_.

                                                                  {
   const uint32_t dummyDetId = 0xffffffff;
   for (const auto& [errorDetId, rawErrorsVec] : errors) {
     if (errorDetId == dummyDetId) {  // errors given dummy detId must be sorted by Fed
       nodeterrors.insert(nodeterrors.end(), rawErrorsVec.begin(), rawErrorsVec.end());
     } else {
       edm::DetSet<SiPixelRawDataError>& errorDetSet = errorcollection.find_or_insert(errorDetId);
       errorDetSet.data.insert(errorDetSet.data.end(), rawErrorsVec.begin(), rawErrorsVec.end());
       // Fill detid of the detectors where there is error AND the error number is listed
       // in the configurable error list in the job option cfi.
       // Code needs to be here, because there can be a set of errors for each
       // entry in the for loop over PixelDataFormatter::Errors
 
       std::vector<PixelFEDChannel> disabledChannelsDetSet;
 
       for (auto const& aPixelError : errorDetSet) {
         // For the time being, we extend the error handling functionality with ErrorType 25
         // In the future, we should sort out how the usage of tkerrorlist can be generalized
         if (phase1_ && aPixelError.getType() == 25) {
           int fedId = aPixelError.getFedId();
           const sipixelobjects::PixelFEDCabling* fed = theCablingTree_->fed(fedId);
           if (fed) {
             cms_uint32_t linkId = getLink(aPixelError.getWord32());
             const sipixelobjects::PixelFEDLink* link = fed->link(linkId);
             if (link) {
               // The "offline" 0..15 numbering is fixed by definition, also, the FrameConversion depends on it
               // in contrast, the ROC-in-channel numbering is determined by hardware --> better to use the "offline" scheme
               PixelFEDChannel ch = {fed->id(), linkId, 25, 0};
               for (unsigned int iRoc = 1; iRoc <= link->numberOfROCs(); iRoc++) {
                 const sipixelobjects::PixelROC* roc = link->roc(iRoc);
                 if (roc->idInDetUnit() < ch.roc_first)
                   ch.roc_first = roc->idInDetUnit();
                 if (roc->idInDetUnit() > ch.roc_last)
                   ch.roc_last = roc->idInDetUnit();
               }
               disabledChannelsDetSet.push_back(ch);
             }
           }
         } else {
           // fill list of detIds to be turned off by tracking
           if (!tkerrorlist.empty()) {
             auto it_find = std::find(tkerrorlist.begin(), tkerrorlist.end(), aPixelError.getType());
             if (it_find != tkerrorlist.end()) {
               tkerror_detidcollection.push_back(errorDetId);
             }
           }
         }
 
         // fill list of detIds with errors to be studied
         if (!usererrorlist.empty()) {
           auto it_find = std::find(usererrorlist.begin(), usererrorlist.end(), aPixelError.getType());
           if (it_find != usererrorlist.end()) {
             usererror_detidcollection.push_back(errorDetId);
           }
         }
 
       }  // loop on DetSet of errors
 
       if (!disabledChannelsDetSet.empty()) {
         disabled_channelcollection.insert(errorDetId, disabledChannelsDetSet.data(), disabledChannelsDetSet.size());
       }
 
     }  // if error assigned to a real DetId
   }    // loop on errors in event for this FED
 }