#include <ITkPixV2Encoder.h>

Inheritance diagram for ITkPixV2Encoder:

Collaboration diagram for ITkPixV2Encoder:

Public Types
typedef ITkPixLayout< uint16_t >	HitMap

Public Member Functions
void	endStream () const
void	addToStream (const HitMap &hitMap, bool last=false) const
std::vector< uint32_t > &	getWords ()
void	addBits64 (const uint64_t value, const uint8_t length) const
void	setHitMap (const HitMap &hitMap) const
void	setEventsPerStream (const unsigned nEventsPerStream=16)
void	setChipID (const uint8_t &chipID)
void	clear () const

Protected Member Functions
void	pushWords32 () const
void	encodeQCore (const unsigned nCCol, const unsigned nQRow) const
void	encodeEvent () const
void	streamTag (const uint8_t nStream) const
void	intTag (const uint16_t nEvt) const
void	scanHitMap () const
bool	hitInQCore (const unsigned CCol, const unsigned QRow) const

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	ATLAS_THREAD_SAFE
unsigned m_currCCol	ATLAS_THREAD_SAFE {}
unsigned m_currCCol m_currQRow	ATLAS_THREAD_SAFE {}
unsigned m_currCCol m_currQRow m_currEvent	ATLAS_THREAD_SAFE {}
uint8_t m_currStream	ATLAS_THREAD_SAFE {}
uint64_t m_currBlock	ATLAS_THREAD_SAFE {}
uint8_t m_currBit	ATLAS_THREAD_SAFE {}
std::vector< std::vector< bool > > m_hitQCores	ATLAS_THREAD_SAFE
std::vector< unsigned > m_lastQRow	ATLAS_THREAD_SAFE
HitMap m_hitMap	ATLAS_THREAD_SAFE
unsigned	m_nEventsPerStream
bool	m_enableChipID {}
bool	m_plainHitMap {}
bool	m_dropToT {}
size_t	m_bitsPerWord
uint8_t	m_chipID = 0b00
std::mutex	m_mutex

Detailed Description

Definition at line 22 of file ITkPixV2Encoder.h.

Member Typedef Documentation

◆ HitMap

typedef ITkPixLayout<uint16_t> ITkPixEncoder::HitMap

inherited

Definition at line 25 of file ITkPixEncoder.h.

Member Function Documentation

◆ addBits64()

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

inherited

Definition at line 29 of file ITkPixEncoder.cxx.

                                                                              {
 
    //only called from mutex-protected function
 
    //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 <= (m_bitsPerWord - 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 << (m_bitsPerWord - 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 = m_bitsPerWord - 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 ) const

Definition at line 21 of file ITkPixV2Encoder.cxx.

                                                                       {
 
    //All operation on the class mutables (except m_words()) is done here
    //in a serialized sequence ensuring thread safety. The individual functions
    //called here are not accessible from the outside.
 
    //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
    std::lock_guard<std::mutex> lock(m_mutex);
 
    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;
    }
 
}

◆ clear()

void ITkPixEncoder::clear ( ) const

inherited

Definition at line 231 of file ITkPixEncoder.cxx.

                                {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_words.clear();
}

◆ encodeEvent()

void ITkPixEncoder::encodeEvent ( ) const

protectedinherited

Definition at line 170 of file ITkPixEncoder.cxx.

                                     {
 
    //only called from mutex-protected function
 
    //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);    
 
        unsigned previousQRow = std::numeric_limits<unsigned>::max();
        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 (previousQRow != std::numeric_limits<unsigned>::max() && QRow == 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 ) const

protectedinherited

Definition at line 92 of file ITkPixEncoder.cxx.

                                                                                {
 
    //only called from mutex-protected function
 
    //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 ( ) const

Definition at line 15 of file ITkPixV2Encoder.cxx.

                                     {
    //only called from mutex-protected function
    m_currBlock |= (0x1ULL << 63);
    pushWords32();
}

◆ getWords()

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

inlineinherited

Definition at line 32 of file ITkPixEncoder.h.

32{return m_words;}

◆ hitInQCore()

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

protectedinherited

Definition at line 132 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 ) const

protectedinherited

Definition at line 217 of file ITkPixEncoder.cxx.

                                                    {
 
    //only called from mutex-protected function
 
    //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 ( ) const

protectedinherited

Definition at line 75 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
    
    //only called from mutex-protected function
    if (m_enableChipID){
        m_currBlock |= ((0x0ULL | m_chipID) << 61);
    }
    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 ( ) const

protectedinherited

Definition at line 147 of file ITkPixEncoder.cxx.

                                     {
 
    //only called from mutex-protected function
 
    //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;
        }
    }
 
}

◆ setChipID()

void ITkPixEncoder::setChipID ( const uint8_t & chipID )

inherited

Definition at line 227 of file ITkPixEncoder.cxx.

                                                  {
    m_chipID = chipID;
}

◆ setEventsPerStream()

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

inlineinherited

Definition at line 38 of file ITkPixEncoder.h.

38{m_nEventsPerStream = nEventsPerStream;}

◆ setHitMap()

void ITkPixEncoder::setHitMap ( const HitMap & hitMap ) const

inlineinherited

Definition at line 36 of file ITkPixEncoder.h.

36{m_hitMap = hitMap;}

◆ streamTag()

void ITkPixEncoder::streamTag ( const uint8_t nStream ) const

protectedinherited

Definition at line 209 of file ITkPixEncoder.cxx.

                                                         {
 
    //only called from mutex-protected function
 
    //this adds the 8-bit 'global' stream tag
    addBits64(nStream, 8);
}

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/10]

HitMap m_hitMap ITkPixEncoder::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 82 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [2/10]

std::vector<unsigned> m_lastQRow ITkPixEncoder::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 74 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [3/10]

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

mutableprotectedinherited

Definition at line 73 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [4/10]

uint8_t m_currBit ITkPixEncoder::ATLAS_THREAD_SAFE {}

mutableprotectedinherited

Definition at line 72 of file ITkPixEncoder.h.

72{};

◆ ATLAS_THREAD_SAFE [5/10]

uint64_t m_currBlock ITkPixEncoder::ATLAS_THREAD_SAFE {}

mutableprotectedinherited

Definition at line 71 of file ITkPixEncoder.h.

71{};

◆ ATLAS_THREAD_SAFE [6/10]

uint8_t m_currStream ITkPixEncoder::ATLAS_THREAD_SAFE {}

mutableprotectedinherited

Definition at line 68 of file ITkPixEncoder.h.

68{};

◆ ATLAS_THREAD_SAFE [7/10]

unsigned m_currCCol ITkPixEncoder::ATLAS_THREAD_SAFE {}

mutableprotectedinherited

Definition at line 67 of file ITkPixEncoder.h.

67{}, m_currQRow ATLAS_THREAD_SAFE {}, m_currEvent ATLAS_THREAD_SAFE {};//

ITkPixEncoder::ATLAS_THREAD_SAFE

std::vector< uint32_t > m_words ATLAS_THREAD_SAFE

Definition ITkPixEncoder.h:65

◆ ATLAS_THREAD_SAFE [8/10]

unsigned m_currCCol m_currQRow ITkPixEncoder::ATLAS_THREAD_SAFE {}

protectedinherited

Definition at line 67 of file ITkPixEncoder.h.

67{}, m_currQRow ATLAS_THREAD_SAFE {}, m_currEvent ATLAS_THREAD_SAFE {};//

◆ ATLAS_THREAD_SAFE [9/10]

unsigned m_currCCol m_currQRow m_currEvent ITkPixEncoder::ATLAS_THREAD_SAFE {}

protectedinherited

Definition at line 67 of file ITkPixEncoder.h.

67{}, m_currQRow ATLAS_THREAD_SAFE {}, m_currEvent ATLAS_THREAD_SAFE {};//

◆ ATLAS_THREAD_SAFE [10/10]

std::vector<uint32_t> m_words ITkPixEncoder::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 65 of file ITkPixEncoder.h.

◆ m_bitsPerWord

size_t ITkPixEncoder::m_bitsPerWord

protectedinherited

Definition at line 78 of file ITkPixEncoder.h.

◆ m_chipID

uint8_t ITkPixEncoder::m_chipID = 0b00

protectedinherited

Definition at line 79 of file ITkPixEncoder.h.

◆ m_dropToT

bool ITkPixEncoder::m_dropToT {}

protectedinherited

Definition at line 77 of file ITkPixEncoder.h.

77{}, m_plainHitMap{}, m_dropToT{};

◆ m_enableChipID

bool ITkPixEncoder::m_enableChipID {}

protectedinherited

Definition at line 77 of file ITkPixEncoder.h.

77{}, m_plainHitMap{}, m_dropToT{};

◆ m_mutex

std::mutex ITkPixEncoder::m_mutex

mutableprotectedinherited

Definition at line 84 of file ITkPixEncoder.h.

◆ m_nCCol

unsigned ITkPixEncoder::m_nCCol {50}

protectedinherited

Definition at line 62 of file ITkPixEncoder.h.

62{400}, m_nRow{384}, m_nCCol{50}, m_nQRow{192}, m_nColInCCol{8}, m_nRowInQRow{2};

ITkPixEncoder::m_nRow

unsigned m_nRow

Definition ITkPixEncoder.h:62

◆ m_nCol

unsigned ITkPixEncoder::m_nCol {400}

protectedinherited

Definition at line 62 of file ITkPixEncoder.h.

62{400}, m_nRow{384}, m_nCCol{50}, m_nQRow{192}, m_nColInCCol{8}, m_nRowInQRow{2};

◆ m_nColInCCol

unsigned ITkPixEncoder::m_nColInCCol {8}

protectedinherited

Definition at line 62 of file ITkPixEncoder.h.

62{400}, m_nRow{384}, m_nCCol{50}, m_nQRow{192}, m_nColInCCol{8}, m_nRowInQRow{2};

◆ m_nEventsPerStream

unsigned ITkPixEncoder::m_nEventsPerStream

protectedinherited

Definition at line 66 of file ITkPixEncoder.h.

◆ m_nQRow

unsigned ITkPixEncoder::m_nQRow {192}

protectedinherited

Definition at line 62 of file ITkPixEncoder.h.

62{400}, m_nRow{384}, m_nCCol{50}, m_nQRow{192}, m_nColInCCol{8}, m_nRowInQRow{2};

◆ m_nRow

unsigned ITkPixEncoder::m_nRow {384}

protectedinherited

Definition at line 62 of file ITkPixEncoder.h.

62{400}, m_nRow{384}, m_nCCol{50}, m_nQRow{192}, m_nColInCCol{8}, m_nRowInQRow{2};

◆ m_nRowInQRow

unsigned ITkPixEncoder::m_nRowInQRow {2}

protectedinherited

Definition at line 62 of file ITkPixEncoder.h.

62{400}, m_nRow{384}, m_nCCol{50}, m_nQRow{192}, m_nColInCCol{8}, m_nRowInQRow{2};

◆ m_plainHitMap

bool ITkPixEncoder::m_plainHitMap {}

protectedinherited

Definition at line 77 of file ITkPixEncoder.h.

77{}, m_plainHitMap{}, m_dropToT{};

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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ HitMap

Member Function Documentation

◆ addBits64()

◆ addToStream()

◆ clear()

◆ encodeEvent()

◆ encodeQCore()

◆ endStream()

◆ getWords()

◆ hitInQCore()

◆ intTag()

◆ pushWords32()

◆ scanHitMap()

◆ setChipID()

◆ setEventsPerStream()

◆ setHitMap()

◆ streamTag()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/10]

◆ ATLAS_THREAD_SAFE [2/10]

◆ ATLAS_THREAD_SAFE [3/10]

◆ ATLAS_THREAD_SAFE [4/10]

◆ ATLAS_THREAD_SAFE [5/10]

◆ ATLAS_THREAD_SAFE [6/10]

◆ ATLAS_THREAD_SAFE [7/10]

◆ ATLAS_THREAD_SAFE [8/10]

◆ ATLAS_THREAD_SAFE [9/10]

◆ ATLAS_THREAD_SAFE [10/10]

◆ m_bitsPerWord

◆ m_chipID

◆ m_dropToT

◆ m_enableChipID

◆ m_mutex

◆ m_nCCol

◆ m_nCol

◆ m_nColInCCol

◆ m_nEventsPerStream

◆ m_nQRow

◆ m_nRow

◆ m_nRowInQRow

◆ m_plainHitMap