ATLAS Offline Software
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
ITkPixEncoder Class Reference

#include <ITkPixEncoder.h>

Inheritance diagram for ITkPixEncoder:
Collaboration diagram for ITkPixEncoder:

Public Types

typedef ITkPixLayout< uint16_t > HitMap
 

Public Member Functions

 ITkPixEncoder (const bool enableChipID=true, const unsigned nCol=400, const unsigned nRow=384, const unsigned nColInCCol=8, const unsigned nRowInQRow=2, const unsigned nEventsPerStream=16, const bool plainHitMap=false, const bool dropToT=false)
 
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_nEventsPerStream
 
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
 
bool m_enableChipID {}
 
bool m_plainHitMap {}
 
bool m_dropToT {}
 
size_t m_bitsPerWord
 
uint8_t m_chipID = 0b00
 
HitMap m_hitMap ATLAS_THREAD_SAFE
 
std::mutex m_mutex
 

Detailed Description

Definition at line 23 of file ITkPixEncoder.h.

Member Typedef Documentation

◆ HitMap

Definition at line 25 of file ITkPixEncoder.h.

Constructor & Destructor Documentation

◆ ITkPixEncoder()

ITkPixEncoder::ITkPixEncoder ( const bool  enableChipID = true,
const unsigned  nCol = 400,
const unsigned  nRow = 384,
const unsigned  nColInCCol = 8,
const unsigned  nRowInQRow = 2,
const unsigned  nEventsPerStream = 16,
const bool  plainHitMap = false,
const bool  dropToT = false 
)

Definition at line 19 of file ITkPixEncoder.cxx.

21  : m_nCol(nCol/nColInCCol), m_nRow(nRow/nRowInQRow),
22  m_nColInCCol(nColInCCol), m_nRowInQRow(nRowInQRow), m_nEventsPerStream(nEventsPerStream), m_enableChipID(enableChipID),
23  m_plainHitMap(plainHitMap), m_dropToT(dropToT){
24  if (m_enableChipID) m_bitsPerWord = 61;
25  else m_bitsPerWord = 63;
26 }

Member Function Documentation

◆ addBits64()

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

Definition at line 28 of file ITkPixEncoder.cxx.

28  {
29 
30  //only called from mutex-protected function
31 
32  //This adds 'length' lowest bits to the current block. If the current
33  //block gets filled, push it to the output and start a new block with
34  //the rest of the bits that didn't make it. Need to keep track of the
35  //remaining space in the current word. Also, we only have 63 bits for
36  //the added data, as the first bit is EoS.
37  //Case 1: there's enough space for the entire information to be added
38  if (length <= (m_bitsPerWord - m_currBit)){
39 
40  //The position at which the new bits should be inserted into the block
41  //is (length of the block - 1) - (currently last bit) - (length)
42  //We need to keep the first bit for EoS, hence the -1
43  m_currBlock |= (value << (m_bitsPerWord - m_currBit - length));
44  m_currBit += length;
45  return;
46  }
47 
48  //Case 2: there's not enough space, so we put what we can, push the block
49  //to the output, and the rest to a new block
50  else {
51 
52  //How much space do we have?
53  uint8_t remainingBits = m_bitsPerWord - m_currBit;
54 
55  //Add that many bits
56  m_currBlock |= ((value >> (length - remainingBits)));
57 
58  //Push the current block to the output and reset it and the current
59  //bit counter. The block needs to be split in 32-bit halves before the output
60  pushWords32();
61 
62  //What are we left with?
63  uint8_t leftoverBits = length - remainingBits;
64 
65  //Now we can add the remainder
66  //Make sure that the remainder we're adding is really only the bits we've not yet
67  //added, otherwise there can be a rogue "1" in the EoS bit, which was already added
68  //in the previous block
69  addBits64((value & (0xFFFFFFFFFFFFFFFF >> (64 - leftoverBits))), leftoverBits);
70 
71  }
72 }

◆ clear()

void ITkPixEncoder::clear ( ) const

Definition at line 231 of file ITkPixEncoder.cxx.

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

◆ encodeEvent()

void ITkPixEncoder::encodeEvent ( ) const
protected

Definition at line 169 of file ITkPixEncoder.cxx.

169  {
170 
171  //only called from mutex-protected function
172 
173  //This produces the bits for one event.
174  //First, scan the map and produce helpers
175  scanHitMap();
176 
177  for (unsigned CCol = 0; CCol < m_nCCol; CCol++){
178  //if there are no hits in this CCol, continue
179  if (m_lastQRow[CCol] == 0) continue;
180  //add the 6-bit (CCol + 1) address
181  addBits64(CCol + 1, 6);
182 
183  int previousQRow = -666;
184  for (unsigned QRow = 0; QRow < m_nQRow; QRow++){
185  //if there's no hit in this row, continue
186  if (!m_hitQCores[CCol][QRow]) continue;
187 
188  //add the isLast bit
189  QRow + 1 == m_lastQRow[CCol] ? addBits64(0x1, 1) : addBits64(0x0, 1);
190 
191  //add the isNeighbor bit. If false, add the QRow address as well.
192  if (QRow == (uint)previousQRow + 1){
193  addBits64(0x1, 1);
194  }
195  else {
196  addBits64(0x0, 1);
197  addBits64(QRow, 8);
198  };
199 
200  //add the map and ToT
201  encodeQCore(CCol, QRow);
202 
203  //update the previous QRow
204  previousQRow = QRow;
205  }
206  }
207 }

◆ encodeQCore()

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

Definition at line 91 of file ITkPixEncoder.cxx.

91  {
92 
93  //only called from mutex-protected function
94 
95  //produce hit map and ToTs
96  //First, get the top-left pixel in the QCore
97  unsigned col = nCCol * m_nColInCCol;
98  unsigned row = nQRow * m_nRowInQRow;
99 
100  //now loop, store ToTs, and build index of the
101  //compressed hit map in the LUT
102  uint16_t lutIndex = 0x0000;
103  std::vector<uint16_t> tots;
104  tots.reserve(16);
105  int pix = 0;
106  for (unsigned pixRow = row; pixRow < row + m_nRowInQRow; pixRow++){
107  for (unsigned pixCol = col; pixCol < col + m_nColInCCol; pixCol++){
108  if (m_hitMap(pixCol, pixRow)){
109  lutIndex |= 0x1 << pix;
110  tots.push_back(m_hitMap(pixCol, pixRow) - 1);
111  }
112  pix++;
113  }
114  }
115 
116  //now add the binary-tree encoded & compressed map
117  //from the LUT to the stream. If, instead, the plain
118  //hit map is requested, add the index (which is the
119  //plain hit map in fact)
121 
122  //if dropToT is requested, we can return here
123  if (m_dropToT) return;
124 
125  //and add the four-bit ToT information for each hit
126  for (auto& tot : tots){
127  addBits64(tot, 4);
128  }
129 }

◆ getWords()

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

Definition at line 32 of file ITkPixEncoder.h.

32 {return m_words;}

◆ hitInQCore()

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

Definition at line 131 of file ITkPixEncoder.cxx.

131  {
132  //Was there a hit in this QCore?
133 
134  unsigned col = CCol * m_nColInCCol;
135  unsigned row = QRow * m_nRowInQRow;
136 
137  for (unsigned pixRow = row; pixRow < row + m_nRowInQRow; pixRow++){
138  for (unsigned pixCol = col; pixCol < col + m_nColInCCol; pixCol++){
139  if (m_hitMap(pixCol, pixRow)) return true;
140  }
141  }
142 
143  return false;
144 }

◆ intTag()

void ITkPixEncoder::intTag ( const uint16_t  nEvt) const
protected

Definition at line 217 of file ITkPixEncoder.cxx.

217  {
218 
219  //only called from mutex-protected function
220 
221  //this adds 11 bits of interal tagging between events.
222  //does the tag always need to start with 111?
223  uint16_t tag = nEvt | (0b111 << 8);
224  addBits64(tag, 11);
225 }

◆ pushWords32()

void ITkPixEncoder::pushWords32 ( ) const
protected

Definition at line 74 of file ITkPixEncoder.cxx.

74  {
75  //whenever the current block is ready for output,
76  //split it into two 32-bit words and push them to
77  //the output container. Reset the current bloc/bit
78 
79  //only called from mutex-protected function
80  if (m_enableChipID){
81  m_currBlock |= ((0x0ULL | m_chipID) << 61);
82  }
83  uint32_t word1 = m_currBlock >> 32;
84  uint32_t word2 = m_currBlock & 0xFFFFFFFF;
85  m_words.push_back(word1);
86  m_words.push_back(word2);
87  m_currBlock = 0x0ULL;
88  m_currBit = 0;
89 }

◆ scanHitMap()

void ITkPixEncoder::scanHitMap ( ) const
protected

Definition at line 146 of file ITkPixEncoder.cxx.

146  {
147 
148  //only called from mutex-protected function
149 
150  //Fill in a helper map of hit QCores and a vector of last qrow in each ccol
151  m_hitQCores = std::vector<std::vector<bool>>(m_nCCol, std::vector<bool>(m_nQRow, false));
152  m_lastQRow = std::vector<unsigned> (m_nCCol, 0);
153 
154  for (unsigned CCol = 0; CCol < m_nCCol; CCol++){
155  for (unsigned QRow = 0; QRow < m_nQRow; QRow++){
156  //if there's a hit in the qcore, flag the helper map
157  m_hitQCores[CCol][QRow] = hitInQCore(CCol, QRow);
158 
159  //and keep track of the last qrow in each CCol, so that we can
160  //easily set the isLast bit. Numbering starts at 1, in order to
161  //keep the m_lastQRow[CCol] == 0 case denoting "no hit" in the CCol
162  //to save some looping/ifs later on
163  if (m_hitQCores[CCol][QRow]) m_lastQRow[CCol] = QRow + 1;
164  }
165  }
166 
167 }

◆ setChipID()

void ITkPixEncoder::setChipID ( const uint8_t &  chipID)

Definition at line 227 of file ITkPixEncoder.cxx.

227  {
228  m_chipID = chipID;
229 }

◆ setEventsPerStream()

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

Definition at line 38 of file ITkPixEncoder.h.

38 {m_nEventsPerStream = nEventsPerStream;}

◆ setHitMap()

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

Definition at line 36 of file ITkPixEncoder.h.

36 {m_hitMap = hitMap;}

◆ streamTag()

void ITkPixEncoder::streamTag ( const uint8_t  nStream) const
protected

Definition at line 209 of file ITkPixEncoder.cxx.

209  {
210 
211  //only called from mutex-protected function
212 
213  //this adds the 8-bit 'global' stream tag
214  addBits64(nStream, 8);
215 }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/10]

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

Definition at line 65 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [2/10]

unsigned m_currCCol ITkPixEncoder::ATLAS_THREAD_SAFE {}
mutableprotected

Definition at line 67 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [3/10]

unsigned m_currCCol m_currQRow ITkPixEncoder::ATLAS_THREAD_SAFE {}
protected

Definition at line 67 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [4/10]

unsigned m_currCCol m_currQRow m_currEvent ITkPixEncoder::ATLAS_THREAD_SAFE {}
protected

Definition at line 67 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [5/10]

uint8_t m_currStream ITkPixEncoder::ATLAS_THREAD_SAFE {}
mutableprotected

Definition at line 68 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [6/10]

uint64_t m_currBlock ITkPixEncoder::ATLAS_THREAD_SAFE {}
mutableprotected

Definition at line 71 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [7/10]

uint8_t m_currBit ITkPixEncoder::ATLAS_THREAD_SAFE {}
mutableprotected

Definition at line 72 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [8/10]

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

Definition at line 73 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [9/10]

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

Definition at line 74 of file ITkPixEncoder.h.

◆ ATLAS_THREAD_SAFE [10/10]

HitMap m_hitMap ITkPixEncoder::ATLAS_THREAD_SAFE
mutableprotected

Definition at line 82 of file ITkPixEncoder.h.

◆ m_bitsPerWord

size_t ITkPixEncoder::m_bitsPerWord
protected

Definition at line 78 of file ITkPixEncoder.h.

◆ m_chipID

uint8_t ITkPixEncoder::m_chipID = 0b00
protected

Definition at line 79 of file ITkPixEncoder.h.

◆ m_dropToT

bool ITkPixEncoder::m_dropToT {}
protected

Definition at line 77 of file ITkPixEncoder.h.

◆ m_enableChipID

bool ITkPixEncoder::m_enableChipID {}
protected

Definition at line 77 of file ITkPixEncoder.h.

◆ m_mutex

std::mutex ITkPixEncoder::m_mutex
mutableprotected

Definition at line 84 of file ITkPixEncoder.h.

◆ m_nCCol

unsigned ITkPixEncoder::m_nCCol {50}
protected

Definition at line 62 of file ITkPixEncoder.h.

◆ m_nCol

unsigned ITkPixEncoder::m_nCol {400}
protected

Definition at line 62 of file ITkPixEncoder.h.

◆ m_nColInCCol

unsigned ITkPixEncoder::m_nColInCCol {8}
protected

Definition at line 62 of file ITkPixEncoder.h.

◆ m_nEventsPerStream

unsigned ITkPixEncoder::m_nEventsPerStream
protected

Definition at line 66 of file ITkPixEncoder.h.

◆ m_nQRow

unsigned ITkPixEncoder::m_nQRow {192}
protected

Definition at line 62 of file ITkPixEncoder.h.

◆ m_nRow

unsigned ITkPixEncoder::m_nRow {384}
protected

Definition at line 62 of file ITkPixEncoder.h.

◆ m_nRowInQRow

unsigned ITkPixEncoder::m_nRowInQRow {2}
protected

Definition at line 62 of file ITkPixEncoder.h.

◆ m_plainHitMap

bool ITkPixEncoder::m_plainHitMap {}
protected

Definition at line 77 of file ITkPixEncoder.h.


The documentation for this class was generated from the following files:
ITkPixEncoding::ITkPixV2QCoreEncodingLUT_Length
constexpr std::array< uint32_t, LookUpTableSize > ITkPixV2QCoreEncodingLUT_Length
Definition: ITkPixQCoreEncodingLUT.h:116
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:215
ITkPixEncoder::m_enableChipID
bool m_enableChipID
Definition: ITkPixEncoder.h:77
ITkPixEncoder::m_nRow
unsigned m_nRow
Definition: ITkPixEncoder.h:62
xAOD::word1
word1
Definition: eFexEMRoI_v1.cxx:87
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
ITkPixEncoder::m_nCol
unsigned m_nCol
Definition: ITkPixEncoder.h:62
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
ITkPixEncoder::hitInQCore
bool hitInQCore(const unsigned CCol, const unsigned QRow) const
Definition: ITkPixEncoder.cxx:131
keylayer_zslicemap.row
row
Definition: keylayer_zslicemap.py:155
athena.value
value
Definition: athena.py:124
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
ITkPixEncoding
Definition: ITkPixQCoreEncodingLUT.h:14
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
ITkPixEncoder::m_dropToT
bool m_dropToT
Definition: ITkPixEncoder.h:77
ITkPixEncoder::m_nRowInQRow
unsigned m_nRowInQRow
Definition: ITkPixEncoder.h:62
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
ITkPixEncoder::m_nEventsPerStream
unsigned m_nEventsPerStream
Definition: ITkPixEncoder.h:66
ITkPixEncoder::m_nColInCCol
unsigned m_nColInCCol
Definition: ITkPixEncoder.h:62
ITkPixEncoder::pushWords32
void pushWords32() const
Definition: ITkPixEncoder.cxx:74
ITkPixEncoder::m_plainHitMap
bool m_plainHitMap
Definition: ITkPixEncoder.h:77
ITkPixEncoder::m_nCCol
unsigned m_nCCol
Definition: ITkPixEncoder.h:62
ITkPixEncoder::m_mutex
std::mutex m_mutex
Definition: ITkPixEncoder.h:84
PixelCalibrationConfig.tot
tot
Definition: PixelCalibrationConfig.py:28
ITkPixEncoder::encodeQCore
void encodeQCore(const unsigned nCCol, const unsigned nQRow) const
Definition: ITkPixEncoder.cxx:91
ITkPixEncoder::m_bitsPerWord
size_t m_bitsPerWord
Definition: ITkPixEncoder.h:78
ITkPixEncoder::addBits64
void addBits64(const uint64_t value, const uint8_t length) const
Definition: ITkPixEncoder.cxx:28
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
ITkPixEncoder::m_nQRow
unsigned m_nQRow
Definition: ITkPixEncoder.h:62
pix
Definition: PixelMapping.cxx:16
ITkPixEncoder::scanHitMap
void scanHitMap() const
Definition: ITkPixEncoder.cxx:146
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
ITkPixEncoder::m_chipID
uint8_t m_chipID
Definition: ITkPixEncoder.h:79
ITkPixEncoding::ITkPixV2QCoreEncodingLUT_Tree
constexpr std::array< uint32_t, LookUpTableSize > ITkPixV2QCoreEncodingLUT_Tree
Definition: ITkPixQCoreEncodingLUT.h:115