#include <ITkPixV2Encoder.h>

Inheritance diagram for ITkPixV2Encoder:

Collaboration diagram for ITkPixV2Encoder:

Public Types
typedef ITkPixLayout< uint16_t >	HitMap

Public Member Functions
void	endStream ()

void	addToStream (const HitMap &hitMap, bool last=false)

std::vector< uint32_t > &	getWords ()

void	addBits64 (const uint64_t value, const uint8_t length)

void	pushWords32 ()

void	encodeQCore (const unsigned nCCol, const unsigned nQRow)

void	encodeEvent ()

void	streamTag (const uint8_t nStream)

void	intTag (const uint16_t nEvt)

void	scanHitMap ()

bool	hitInQCore (const unsigned CCol, const unsigned QRow)

void	setHitMap (const HitMap &hitMap)

void	setEventsPerStream (const unsigned nEventsPerStream=16)

Protected Attributes
unsigned	m_nCol {400}

unsigned	m_nRow {384}

unsigned	m_nCCol {50}

unsigned	m_nQRow {192}

unsigned	m_nColInCCol {8}

unsigned	m_nRowInQRow {2}

std::vector< uint32_t >	m_words

unsigned	m_nEventsPerStream {}

unsigned	m_currCCol {}

unsigned	m_currQRow {}

unsigned	m_currEvent {}

uint8_t	m_currStream {}

uint64_t	m_currBlock {}

uint8_t	m_currBit {}

std::vector< std::vector< bool > >	m_hitQCores

std::vector< unsigned >	m_lastQRow

bool	m_plainHitMap {}

bool	m_dropToT {}

HitMap	m_hitMap

Detailed Description

Definition at line 16 of file ITkPixV2Encoder.h.

Member Typedef Documentation

◆ HitMap

typedef ITkPixLayout<uint16_t> ITkPixEncoder::HitMap

inherited

Definition at line 21 of file ITkPixEncoder.h.

Member Function Documentation

◆ addBits64()

void ITkPixEncoder::addBits64	(	const uint64_t	value,
		const uint8_t	length
	)

inherited

Definition at line 23 of file ITkPixEncoder.cxx.

                                                                        {
     //This adds 'length' lowest bits to the current block. If the current
     //block gets filled, push it to the output and start a new block with
     //the rest of the bits that didn't make it. Need to keep track of the
     //remaining space in the current word. Also, we only have 63 bits for
     //the added data, as the first bit is EoS.
     //Case 1: there's enough space for the entire information to be added
     if (length <= (63 - m_currBit)){
         
         //The position at which the new bits should be inserted into the block
         //is (length of the block - 1) - (currently last bit) - (length)
         //We need to keep the first bit for EoS, hence the -1
         m_currBlock |= (value << (63 - m_currBit - length));
         m_currBit += length;
         return;
     }
  
     //Case 2: there's not enough space, so we put what we can, push the block
     //to the output, and the rest to a new block
     else {
  
         //How much space do we have?
         uint8_t remainingBits = 63 - m_currBit;
  
         //Add that many bits
         m_currBlock |= ((value >> (length - remainingBits)));
  
         //Push the current block to the output and reset it and the current
         //bit counter. The block needs to be split in 32-bit halves before the output
         pushWords32();
  
         //What are we left with?
         uint8_t leftoverBits = length - remainingBits;
  
         //Now we can add the remainder
         //Make sure that the remainder we're adding is really only the bits we've not yet
         //added, otherwise there can be a rogue "1" in the EoS bit, which was already added
         //in the previous block
         addBits64((value & (0xFFFFFFFFFFFFFFFF >> (64 - leftoverBits))), leftoverBits);
         
     }
 }

◆ addToStream()

void ITkPixV2Encoder::addToStream	(	const HitMap &	hitMap,
		bool	last = `false`
	)

Definition at line 18 of file ITkPixV2Encoder.cxx.

                                                                 {
     //This is a high-level interface function that can take care of
     //adding an event into the current stream, this can be called
     //easily from the outside, and automatically tags/ends streams
     //and events based on internal vars only
     
     //If this is the first event, start a new stream. Otherwise, add an
     //internal tag
     if (m_currEvent == 0){
         streamTag(m_currStream);
         m_currStream++;
     }
     else {
         intTag(m_currEvent);
     }
     
     //Then add the actual encoded event information
     setHitMap(hitMap);
     encodeEvent();
     m_currEvent++;
  
     //If this is the last event in the stream or if we explicitly
     //want to end the stream (i. e. total number of generated events
     //is not a multiple of nEventsPerStream), end the stream
     if (m_currEvent == m_nEventsPerStream || last){
         endStream();
         m_currEvent = 0;
     }
  
 }

◆ encodeEvent()

void ITkPixEncoder::encodeEvent ( )

inherited

Definition at line 151 of file ITkPixEncoder.cxx.

                                {
     //This produces the bits for one event.
     //First, scan the map and produce helpers
     scanHitMap();
  
     for (unsigned CCol = 0; CCol < m_nCCol; CCol++){
         //if there are no hits in this CCol, continue
         if (m_lastQRow[CCol] == 0) continue;
         //add the 6-bit (CCol + 1) address
         addBits64(CCol + 1, 6);    
  
         int previousQRow = -666;
         for (unsigned QRow = 0; QRow < m_nQRow; QRow++){
             //if there's no hit in this row, continue
             if (!m_hitQCores[CCol][QRow]) continue;            
             
             //add the isLast bit
             QRow + 1 == m_lastQRow[CCol] ? addBits64(0x1, 1) : addBits64(0x0, 1);
  
             //add the isNeighbor bit. If false, add the QRow address as well.
             if (QRow == (uint)previousQRow + 1){
                 addBits64(0x1, 1);
             }
             else {
                 addBits64(0x0, 1);
                 addBits64(QRow, 8);
             };
  
             //add the map and ToT
             encodeQCore(CCol, QRow);
  
             //update the previous QRow
             previousQRow = QRow;
         }
     }    
 }

◆ encodeQCore()

void ITkPixEncoder::encodeQCore	(	const unsigned	nCCol,
		const unsigned	nQRow
	)

inherited

Definition at line 78 of file ITkPixEncoder.cxx.

                                                                          {
     //produce hit map and ToTs
     //First, get the top-left pixel in the QCore
     unsigned col = nCCol * m_nColInCCol;
     unsigned row = nQRow * m_nRowInQRow;
  
     //now loop, store ToTs, and build index of the
     //compressed hit map in the LUT
     uint16_t lutIndex = 0x0000;
     std::vector<uint16_t> tots;
     tots.reserve(16);
     int pix = 0;
     for (unsigned pixRow = row; pixRow < row + m_nRowInQRow; pixRow++){
         for (unsigned pixCol = col; pixCol < col + m_nColInCCol; pixCol++){
             if (m_hitMap(pixCol, pixRow)){
                 lutIndex |= 0x1 << pix;
                 tots.push_back(m_hitMap(pixCol, pixRow) - 1);
             }
             pix++;
         }
     }
  
     //now add the binary-tree encoded & compressed map
     //from the LUT to the stream. If, instead, the plain
     //hit map is requested, add the index (which is the
     //plain hit map in fact)
     
     m_plainHitMap ? addBits64(lutIndex, 16) : addBits64(ITkPixEncoding::ITkPixV2QCoreEncodingLUT_Tree[lutIndex], ITkPixEncoding::ITkPixV2QCoreEncodingLUT_Length[lutIndex]);
  
     //if dropToT is requested, we can return here
     if (m_dropToT) return;
  
     //and add the four-bit ToT information for each hit
     for (auto& tot : tots){
         addBits64(tot, 4);
     }
 }

◆ endStream()

void ITkPixV2Encoder::endStream ( )

Definition at line 13 of file ITkPixV2Encoder.cxx.

                                {
     m_currBlock |= (0x1ULL << 63);
     pushWords32();
 }

◆ getWords()

std::vector<uint32_t>& ITkPixEncoder::getWords ( )

inlineinherited

Definition at line 28 of file ITkPixEncoder.h.

28 {return m_words;}

◆ hitInQCore()

bool ITkPixEncoder::hitInQCore	(	const unsigned	CCol,
		const unsigned	QRow
	)

inherited

Definition at line 116 of file ITkPixEncoder.cxx.

                                                                       {
     //Was there a hit in this QCore?
  
     unsigned col = CCol * m_nColInCCol;
     unsigned row = QRow * m_nRowInQRow;
  
     for (unsigned pixRow = row; pixRow < row + m_nRowInQRow; pixRow++){
         for (unsigned pixCol = col; pixCol < col + m_nColInCCol; pixCol++){
             if (m_hitMap(pixCol, pixRow)) return true;
         }
     }
  
     return false;
 }

◆ intTag()

void ITkPixEncoder::intTag ( const uint16_t nEvt )

inherited

Definition at line 193 of file ITkPixEncoder.cxx.

                                              {
     //this adds 11 bits of interal tagging between events.
     //does the tag always need to start with 111?
     uint16_t tag = nEvt | (0b111 << 8);
     addBits64(tag, 11);
 }

◆ pushWords32()

void ITkPixEncoder::pushWords32 ( )

inherited

Definition at line 66 of file ITkPixEncoder.cxx.

                                {
     //whenever the current block is ready for output,
     //split it into two 32-bit words and push them to
     //the output container. Reset the current bloc/bit
     uint32_t word1 = m_currBlock >> 32;
     uint32_t word2 = m_currBlock & 0xFFFFFFFF;
     m_words.push_back(word1);
     m_words.push_back(word2);
     m_currBlock = 0x0ULL;
     m_currBit   = 0;
 }

◆ scanHitMap()

void ITkPixEncoder::scanHitMap ( )

inherited

Definition at line 131 of file ITkPixEncoder.cxx.

                               {
     //Fill in a helper map of hit QCores and a vector of last qrow in each ccol
     m_hitQCores = std::vector<std::vector<bool>>(m_nCCol, std::vector<bool>(m_nQRow, false));
     m_lastQRow  = std::vector<unsigned> (m_nCCol, 0);
  
     for (unsigned CCol = 0; CCol < m_nCCol; CCol++){
         for (unsigned QRow = 0; QRow < m_nQRow; QRow++){
             //if there's a hit in the qcore, flag the helper map
             m_hitQCores[CCol][QRow] = hitInQCore(CCol, QRow);
             
             //and keep track of the last qrow in each CCol, so that we can
             //easily set the isLast bit. Numbering starts at 1, in order to
             //keep the m_lastQRow[CCol] == 0 case denoting "no hit" in the CCol
             //to save some looping/ifs later on
             if (m_hitQCores[CCol][QRow]) m_lastQRow[CCol] = QRow + 1;
         }
     }
  
 }

◆ setEventsPerStream()

void ITkPixEncoder::setEventsPerStream ( const unsigned nEventsPerStream = 16 )

inlineinherited

Definition at line 48 of file ITkPixEncoder.h.

48 {m_nEventsPerStream = nEventsPerStream;}

◆ setHitMap()

void ITkPixEncoder::setHitMap ( const HitMap & hitMap )

inlineinherited

Definition at line 46 of file ITkPixEncoder.h.

46 {m_hitMap = hitMap;}

◆ streamTag()

void ITkPixEncoder::streamTag ( const uint8_t nStream )

inherited

Definition at line 188 of file ITkPixEncoder.cxx.

                                                   {
     //this adds the 8-bit 'global' stream tag
     addBits64(nStream, 8);
 }

Member Data Documentation

◆ m_currBit

uint8_t ITkPixEncoder::m_currBit {}

protectedinherited

Definition at line 61 of file ITkPixEncoder.h.

◆ m_currBlock

uint64_t ITkPixEncoder::m_currBlock {}

protectedinherited

Definition at line 60 of file ITkPixEncoder.h.

◆ m_currCCol

unsigned ITkPixEncoder::m_currCCol {}

protectedinherited

Definition at line 56 of file ITkPixEncoder.h.

◆ m_currEvent

unsigned ITkPixEncoder::m_currEvent {}

protectedinherited

Definition at line 56 of file ITkPixEncoder.h.

◆ m_currQRow

unsigned ITkPixEncoder::m_currQRow {}

protectedinherited

Definition at line 56 of file ITkPixEncoder.h.

◆ m_currStream

uint8_t ITkPixEncoder::m_currStream {}

protectedinherited

Definition at line 57 of file ITkPixEncoder.h.

◆ m_dropToT

bool ITkPixEncoder::m_dropToT {}

protectedinherited

Definition at line 66 of file ITkPixEncoder.h.

◆ m_hitMap

HitMap ITkPixEncoder::m_hitMap

protectedinherited

Definition at line 69 of file ITkPixEncoder.h.

◆ m_hitQCores

std::vector<std::vector<bool> > ITkPixEncoder::m_hitQCores

protectedinherited

Definition at line 62 of file ITkPixEncoder.h.

◆ m_lastQRow

std::vector<unsigned> ITkPixEncoder::m_lastQRow

protectedinherited

Definition at line 63 of file ITkPixEncoder.h.

◆ m_nCCol

unsigned ITkPixEncoder::m_nCCol {50}

protectedinherited

Definition at line 52 of file ITkPixEncoder.h.

◆ m_nCol

unsigned ITkPixEncoder::m_nCol {400}

protectedinherited

Definition at line 52 of file ITkPixEncoder.h.

◆ m_nColInCCol

unsigned ITkPixEncoder::m_nColInCCol {8}

protectedinherited

Definition at line 52 of file ITkPixEncoder.h.

◆ m_nEventsPerStream

unsigned ITkPixEncoder::m_nEventsPerStream {}

protectedinherited

Definition at line 56 of file ITkPixEncoder.h.

◆ m_nQRow

unsigned ITkPixEncoder::m_nQRow {192}

protectedinherited

Definition at line 52 of file ITkPixEncoder.h.

◆ m_nRow

unsigned ITkPixEncoder::m_nRow {384}

protectedinherited

Definition at line 52 of file ITkPixEncoder.h.

◆ m_nRowInQRow

unsigned ITkPixEncoder::m_nRowInQRow {2}

protectedinherited

Definition at line 52 of file ITkPixEncoder.h.

◆ m_plainHitMap

bool ITkPixEncoder::m_plainHitMap {}

protectedinherited

Definition at line 66 of file ITkPixEncoder.h.

◆ m_words

std::vector<uint32_t> ITkPixEncoder::m_words

protectedinherited

Definition at line 55 of file ITkPixEncoder.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ HitMap

Member Function Documentation

◆ addBits64()

◆ addToStream()

◆ encodeEvent()

◆ encodeQCore()

◆ endStream()

◆ getWords()

◆ hitInQCore()

◆ intTag()

◆ pushWords32()

◆ scanHitMap()

◆ setEventsPerStream()

◆ setHitMap()

◆ streamTag()

Member Data Documentation

◆ m_currBit

◆ m_currBlock

◆ m_currCCol

◆ m_currEvent

◆ m_currQRow

◆ m_currStream

◆ m_dropToT

◆ m_hitMap

◆ m_hitQCores

◆ m_lastQRow

◆ m_nCCol

◆ m_nCol

◆ m_nColInCCol

◆ m_nEventsPerStream

◆ m_nQRow

◆ m_nRow

◆ m_nRowInQRow

◆ m_plainHitMap

◆ m_words