#include <PixelDataFormatter.h>

Public Types
typedef edm::DetSetVector < PixelDigi >	Collection

typedef std::vector< PixelDigi >	DetDigis

typedef std::vector < SiPixelRawDataError >	DetErrors

typedef std::map< cms_uint32_t, DetDigis >	Digis

typedef std::map< cms_uint32_t, DetErrors >	Errors

typedef std::pair < DetDigis::const_iterator, DetDigis::const_iterator >	Range

typedef std::map< int, FEDRawData >	RawData

typedef cms_uint32_t	Word32

typedef cms_uint64_t	Word64

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

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 SiPixelFedCabling *map, bool phase1=false)

void	setErrorStatus (bool ErrorStatus)

void	setModulesToUnpack (const std::set< unsigned int > *moduleIds)

void	setQualityStatus (bool QualityStatus, const SiPixelQuality *QualityInfo)

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

int	digi2word (cms_uint32_t detId, const PixelDigi &digi, std::map< int, std::vector< Word32 > > &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

int	word2digi (const int fedId, const SiPixelFrameConverter *converter, const bool includeError, const bool useQuality, const Word32 &word, Digis &digis) const

Private Attributes
Word32	ADC_mask

int	ADC_shift

int	allDetDigis

const SiPixelQuality *	badPixelInfo

Word32	DCOL_mask

int	DCOL_shift

bool	debug

ErrorChecker	errorcheck

int	hasDetDigis

bool	includeErrors

Word32	LINK_mask

int	LINK_shift

int	maxROCIndex

const std::set< unsigned int > *	modulesToUnpack

Word32	PXID_mask

int	PXID_shift

Word32	ROC_mask

int	ROC_shift

SiPixelFedCabling 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 55 of file PixelDataFormatter.h.

Member Typedef Documentation

typedef edm::DetSetVector<PixelDigi> PixelDataFormatter::Collection

Definition at line 59 of file PixelDataFormatter.h.

typedef std::vector<PixelDigi> PixelDataFormatter::DetDigis

Definition at line 62 of file PixelDataFormatter.h.

typedef std::vector<SiPixelRawDataError> PixelDataFormatter::DetErrors

Definition at line 65 of file PixelDataFormatter.h.

typedef std::map<cms_uint32_t, DetDigis> PixelDataFormatter::Digis

Definition at line 63 of file PixelDataFormatter.h.

typedef std::map<cms_uint32_t, DetErrors> PixelDataFormatter::Errors

Definition at line 66 of file PixelDataFormatter.h.

typedef std::pair<DetDigis::const_iterator, DetDigis::const_iterator> PixelDataFormatter::Range

Definition at line 64 of file PixelDataFormatter.h.

typedef std::map<int, FEDRawData> PixelDataFormatter::RawData

Definition at line 61 of file PixelDataFormatter.h.

typedef cms_uint32_t PixelDataFormatter::Word32

Definition at line 68 of file PixelDataFormatter.h.

typedef cms_uint64_t PixelDataFormatter::Word64

Definition at line 69 of file PixelDataFormatter.h.

Constructor & Destructor Documentation

PixelDataFormatter::PixelDataFormatter	(	const SiPixelFedCabling *	map,
		bool	phase1 = `false`
	)

Definition at line 50 of file PixelDataFormatter.cc.

References ADC_mask, ADC_shift, allDetDigis, hitfit::char, DCOL_mask, DCOL_shift, hasDetDigis, includeErrors, LINK_mask, LINK_shift, maxROCIndex, PXID_mask, PXID_shift, ROC_mask, ROC_shift, and useQualityInfo.

   : theDigiCounter(0), theWordCounter(0), theCablingTree(map), badPixelInfo(0), modulesToUnpack(0)
 {
   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;
 
   ADC_shift  = 0;
   PXID_shift = ADC_shift + ADC_bits;
   DCOL_shift = PXID_shift + PXID_bits;
   ROC_shift  = DCOL_shift + DCOL_bits;
 
   if(phase1) {  // for phase 1
     LINK_shift = ROC_shift + ROC_bits1;
     LINK_mask = ~(~PixelDataFormatter::Word32(0) << LINK_bits1);
     ROC_mask  = ~(~PixelDataFormatter::Word32(0) << ROC_bits1);
     maxROCIndex=8;
   } else {  // for phase 0
     LINK_shift = ROC_shift + ROC_bits;
     LINK_mask = ~(~PixelDataFormatter::Word32(0) << LINK_bits);
     ROC_mask  = ~(~PixelDataFormatter::Word32(0) << ROC_bits);
     maxROCIndex=25;
   }
 
 
   DCOL_mask = ~(~PixelDataFormatter::Word32(0) << DCOL_bits);
   PXID_mask = ~(~PixelDataFormatter::Word32(0) << PXID_bits);
   ADC_mask  = ~(~PixelDataFormatter::Word32(0) << ADC_bits);
 
 }

Member Function Documentation

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

private

int PixelDataFormatter::digi2word	(	cms_uint32_t	detId,
		const PixelDigi &	digi,
		std::map< int, std::vector< Word32 > > &	words
	)		const

private

Definition at line 305 of file PixelDataFormatter.cc.

References PixelDigi::adc(), ADC_shift, PixelDigi::column(), sipixelobjects::ElectronicIndex::dcol, DCOL_shift, sipixelobjects::ElectronicIndex::link, LINK_shift, LogDebug, print(), sipixelobjects::ElectronicIndex::pxid, PXID_shift, sipixelobjects::ElectronicIndex::roc, ROC_shift, PixelDigi::row(), theFrameReverter, theWordCounter, and SiPixelFrameReverter::toCabling().

Referenced by formatRawData().

 {
   LogDebug("PixelDataFormatter")
 // <<" detId: " << detId 
   <<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 0;
 }

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

private

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

Definition at line 237 of file PixelDataFormatter.cc.

References allDetDigis, FEDRawData::data(), digi2word(), edm::hlt::Exception, hasDetDigis, i, LogDebug, LogTrace, print(), alignCSCRings::s, FEDTrailer::set(), FEDHeader::set(), ntuplemaker::status, and theDigiCounter.

 {
   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;
     hasDetDigis++;
     const DetDigis & detDigis = im->second;
     for (DetDigis::const_iterator it = detDigis.begin(); it != detDigis.end(); it++) {
       theDigiCounter++;
       const PixelDigi & digi = (*it);
       int status = digi2word( rawId, digi, words);
       if (status) {
          LogError("FormatDataException")
             <<" digi2word returns error #"<<status
             <<" Ndigis: "<<theDigiCounter << endl
             <<" detector: "<<rawId<< endl
             << print(digi) <<endl;
       } // if (status)
     } // for (DetDigis
   } // for (Digis
   LogTrace(" allDetDigis/hasDetDigis : ") << allDetDigis<<"/"<<hasDetDigis;
 
   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]) << 32 ) | words.find(fedId)->second[i+1];
       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 115 of file PixelDataFormatter.cc.

References ecalMGPA::adc(), ADC_mask, ADC_shift, badPixelInfo, ErrorChecker::checkCRC(), ErrorChecker::checkHeader(), ErrorChecker::checkROC(), ErrorChecker::checkTrailer(), sipixelobjects::GlobalPixel::col, ErrorChecker::conversionError(), FEDRawData::data(), edm::DetSet< T >::data, DCOL_mask, DCOL_shift, errorcheck, edm::DetSetVector< T >::find_or_insert(), SiPixelQuality::IsRocBad(), likely, MainPageGenerator::link, LINK_mask, LINK_shift, LogDebug, LogTrace, maxROCIndex, modulesToUnpack, nWords(), print(), PXID_mask, PXID_shift, ROC_mask, ROC_shift, sipixelobjects::GlobalPixel::row, FEDRawData::size(), theCablingTree, theWordCounter, SiPixelFrameConverter::toRoc(), unlikely, useQualityInfo, 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;
   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;
     //assert(ww==0);
     if unlikely(ww==0) { theWordCounter--; continue;}
     int nlink = (ww >> LINK_shift) & LINK_mask; 
     int nroc  = (ww >> ROC_shift) & ROC_mask;
     
     if ( (nlink!=link) | (nroc!=roc) ) {  // new roc
       link = nlink; roc=nroc;
       skipROC = likely(roc<maxROCIndex) ? false : !errorcheck.checkROC(errorsInEvent, fedId, &converter, 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();
       
       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
     }
     if unlikely(skipROC) continue;
     
     
     int dcol = (ww >> DCOL_shift) & DCOL_mask;
     int pxid = (ww >> PXID_shift) & PXID_mask;
     int adc  = (ww >> ADC_shift) & ADC_mask;
     
     LocalPixel::DcolPxid local = { dcol, pxid };
     if unlikely(!local.valid()) {
       LogDebug("PixelDataFormatter::interpretRawData") 
     << "status #3";
       errorsInEvent = true;
       errorcheck.conversionError(fedId, &converter, 3, ww, errors);
       continue;
     }
     
     GlobalPixel global = rocp->toGlobal( LocalPixel(local) );
     (*detDigis).data.emplace_back(global.row, global.col, adc);
     
     LogTrace("") << (*detDigis).data.back();
   }
 
 }

int PixelDataFormatter::nDigis ( ) const

inline

Definition at line 78 of file PixelDataFormatter.h.

References theDigiCounter.

78 { return theDigiCounter; }

PixelDataFormatter::theDigiCounter

int theDigiCounter

Definition: PixelDataFormatter.h:86

int PixelDataFormatter::nWords ( ) const

inline

Definition at line 79 of file PixelDataFormatter.h.

References theWordCounter.

Referenced by interpretRawData().

79 { return theWordCounter; }

PixelDataFormatter::theWordCounter

int theWordCounter

Definition: PixelDataFormatter.h:87

void PixelDataFormatter::passFrameReverter ( const SiPixelFrameReverter * reverter )

Definition at line 110 of file PixelDataFormatter.cc.

References theFrameReverter.

Referenced by SiPixelDigiToRaw::produce().

 {
   theFrameReverter = reverter;
 }

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

private

Definition at line 381 of file PixelDataFormatter.cc.

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

Referenced by digi2word(), 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 388 of file PixelDataFormatter.cc.

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

void PixelDataFormatter::setErrorStatus ( bool ErrorStatus )

Definition at line 93 of file PixelDataFormatter.cc.

References errorcheck, includeErrors, and ErrorChecker::setErrorStatus().

Referenced by SiPixelRawToDigi::produce().

 {
   includeErrors = ErrorStatus;
   errorcheck.setErrorStatus(includeErrors);
 }

void PixelDataFormatter::setModulesToUnpack ( const std::set< unsigned int > * moduleIds )

Definition at line 105 of file PixelDataFormatter.cc.

References modulesToUnpack.

 {
   modulesToUnpack = moduleIds;
 }

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

Definition at line 99 of file PixelDataFormatter.cc.

References badPixelInfo, and useQualityInfo.

 {
   useQualityInfo = QualityStatus;
   badPixelInfo = QualityInfo;
 }

int PixelDataFormatter::word2digi	(	const int	fedId,
		const SiPixelFrameConverter *	converter,
		const bool	includeError,
		const bool	useQuality,
		const Word32 &	word,
		Digis &	digis
	)		const

private

Definition at line 331 of file PixelDataFormatter.cc.

References ecalMGPA::adc(), ADC_mask, ADC_shift, badPixelInfo, sipixelobjects::DetectorIndex::col, sipixelobjects::ElectronicIndex::dcol, DCOL_mask, DCOL_shift, debug, SiPixelFedCabling::findItem(), sipixelobjects::PixelROC::idInDetUnit(), SiPixelQuality::IsRocBad(), sipixelobjects::ElectronicIndex::link, LINK_mask, LINK_shift, LogTrace, modulesToUnpack, cmsHarvester::path, sipixelobjects::ElectronicIndex::pxid, PXID_mask, PXID_shift, sipixelobjects::DetectorIndex::rawId, sipixelobjects::ElectronicIndex::roc, ROC_mask, ROC_shift, sipixelobjects::LocalPixel::rocCol(), sipixelobjects::LocalPixel::rocRow(), sipixelobjects::DetectorIndex::row, ntuplemaker::status, theCablingTree, theDigiCounter, and SiPixelFrameConverter::toDetector().

 {
   // do not interpret false digis
   if (word == 0 ) return 0;
 
   ElectronicIndex cabling;
   cabling.dcol = (word >> DCOL_shift) & DCOL_mask;
   cabling.pxid = (word >> PXID_shift) & PXID_mask;
   cabling.link = (word >> LINK_shift) & LINK_mask;
   cabling.roc  = (word >> ROC_shift) & ROC_mask;
   int adc      = (word >> ADC_shift) & ADC_mask;
 
   if (debug) {
     LocalPixel::DcolPxid pixel = {cabling.dcol,cabling.pxid};
     LocalPixel local(pixel);
     LogTrace("")<<" link: "<<cabling.link<<", roc: "<<cabling.roc
                 <<" rocRow: "<<local.rocRow()<<", rocCol:"<<local.rocCol()
                 <<" (dcol: "<<cabling.dcol<<", pxid:"<<cabling.pxid<<"), adc:"<<adc;
   }
 
   if (!converter) return 0;
 
   DetectorIndex detIdx;
   int status = converter->toDetector(cabling, detIdx);
   if (status) return status;
 
   // exclude ROC(raw) based on bad ROC list bad in SiPixelQuality
   // enable: process.siPixelDigis.UseQualityInfo = True
   // 20-10-2010 A.Y.
   if (useQuality&&badPixelInfo) {
     CablingPathToDetUnit path = {static_cast<unsigned int>(fedId),
                                  static_cast<unsigned int>(cabling.link),
                                  static_cast<unsigned int>(cabling.roc)};
     const PixelROC * roc = theCablingTree->findItem(path);
     short rocInDet = (short) roc->idInDetUnit();
     bool badROC = badPixelInfo->IsRocBad(detIdx.rawId, rocInDet);
     if (badROC) return 0;
   }
 
   if (modulesToUnpack && modulesToUnpack->find(detIdx.rawId) == modulesToUnpack->end()) return 0;
 
   digis[detIdx.rawId].emplace_back(detIdx.row, detIdx.col, adc);
 
   theDigiCounter++;
 
   if (debug)  LogTrace("") << digis[detIdx.rawId].back();
   return 0;
 }