PhaseII::PixelRawDataContainer Class Reference

The container for pixel RDOs The base class is the InDetRawDataContainer with a coordinate dimension of 2. More...

#include <PhaseIIPixelRawDataContainer.h>

Inheritance diagram for PhaseII::PixelRawDataContainer:

Collaboration diagram for PhaseII::PixelRawDataContainer:

Public Member Functions
const std::vector< std::uint64_t > &	errors () const
std::vector< std::uint64_t > &	errors ()
bool	isValid (unsigned int index) const
	return true if the index refers to an element in the container
const std::array< std::int16_t, NDim > &	coordinates (unsigned int index) const
	return the coordinates i.e. column, row or strip of a certain RDO (read only).
const std::uint32_t &	dataWord (unsigned int index) const
	return the packed data word of of a certain RDO (read only).
bool	isSane () const
std::size_t	size () const
	total number of RDOs which are in this container.
bool	empty () const
	test whether the container is empty i.e. does not contain any RDOs
std::size_t	capacity () const
	the maximum number RDOs this container can hold without reallocation.
void	reserve (std::size_t new_capacity)
	reserve space for a certain number of RDOs.
void	emplace_back (std::array< std::int16_t, NDim > &&coordinates, std::uint32_t data_word)
	Add a new RDO to the end of this container.
void	erase_back (unsigned int begin_index)
	erase the elements at the end of the container
void	move (InDetRawDataContainer &dest, unsigned int start_index)
	Move the coordinates and the data word of a certain number of elements at the end to a new container.

Static Public Member Functions
static int	getToT (std::uint32_t dataWord)
static int	getBCID (std::uint32_t dataWord)
static int	getLVL1A (std::uint32_t dataWord)
static int	getLVL1ID (std::uint32_t dataWord)
static std::uint32_t	makeWord (int tot, int bcid, int lvl1a, int lvl1d)
static constexpr int	unpack (std::uint32_t mask, unsigned int shift, unsigned int word)
	extract a value from a bit packed word.
static constexpr std::uint32_t	pack (std::uint32_t mask, unsigned int shift, int input)
	Create a bit-packed word from an input value.

Static Protected Attributes
static constexpr std::uint32_t	MASK_TOT = 0xFF
static constexpr unsigned int	SHIFT_TOT = 0
static constexpr std::uint32_t	MASK_BCID = 0xFF
static constexpr unsigned int	SHIFT_BCID = 8
static constexpr std::uint32_t	MASK_LVL1D = 0xFF
static constexpr unsigned int	SHIFT_LVL1D = 16
static constexpr std::uint32_t	MASK_LVL1A = 0xF
static constexpr unsigned int	SHIFT_LVL1A = 24

Private Attributes
std::vector< std::uint64_t >	m_errors
std::vector< std::array< std::int16_t, NDim > >	m_coordinates
std::vector< std::uint32_t >	m_word

Detailed Description

The container for pixel RDOs The base class is the InDetRawDataContainer with a coordinate dimension of 2.

Definition at line 18 of file PhaseIIPixelRawDataContainer.h.

Member Function Documentation

capacity()

std::size_t PhaseII::InDetRawDataContainer< NDim >::capacity ( ) const

inlineinherited

the maximum number RDOs this container can hold without reallocation.

Definition at line 269 of file PhaseIIInDetRawDataContainer.h.

{ assert(m_coordinates.capacity() == m_word.capacity()); return m_coordinates.capacity(); }

coordinates()

const std::array< std::int16_t, NDim > & PhaseII::InDetRawDataContainer< NDim >::coordinates ( unsigned int index ) const

inlineinherited

return the coordinates i.e. column, row or strip of a certain RDO (read only).

Definition at line 252 of file PhaseIIInDetRawDataContainer.h.

{ assert(isValid(index)); return m_coordinates[index]; }

dataWord()

const std::uint32_t & PhaseII::InDetRawDataContainer< NDim >::dataWord ( unsigned int index ) const

inlineinherited

return the packed data word of of a certain RDO (read only).

Definition at line 256 of file PhaseIIInDetRawDataContainer.h.

{ assert(isValid(index)); return m_word[index]; }

emplace_back()

void PhaseII::InDetRawDataContainer< NDim >::emplace_back ( std::array< std::int16_t, NDim > && coordinates, std::uint32_t data_word )

inlineinherited

Add a new RDO to the end of this container.

Parameters

coordinates	the coordinates of the RDO e.g. pixel row, column or strop.
data_word	a bit packed data word which may contain e.g. the ToT.

Definition at line 281 of file PhaseIIInDetRawDataContainer.h.

                                                                                        {
         // @TODO should bail out if container is filled concurrently and the
         //       size is equal to the capacity, but the container does not know.
         m_coordinates.emplace_back(std::move(coordinates));
         m_word.emplace_back(data_word);
         assert(isSane());
      }

empty()

bool PhaseII::InDetRawDataContainer< NDim >::empty ( ) const

inlineinherited

test whether the container is empty i.e. does not contain any RDOs

Definition at line 267 of file PhaseIIInDetRawDataContainer.h.

{ assert(isSane()); return m_coordinates.empty(); }

erase_back()

void PhaseII::InDetRawDataContainer< NDim >::erase_back ( unsigned int begin_index )

inlineinherited

erase the elements at the end of the container

Parameters

begin_index

the index of the first element that is erased. Will erase all elements from begin_index till the end of the container. begin_index is expected to be smaller or equal to the container size. The result may be undefined if begin_index is larger than the container size.

Definition at line 294 of file PhaseIIInDetRawDataContainer.h.

                                                 {
         assert( begin_index <= m_coordinates.size());
         m_coordinates.erase( m_coordinates.begin()+begin_index, m_coordinates.end());
         m_word.erase( m_word.begin()+begin_index, m_word.end());
         assert(isSane());
      }

errors() [1/2]

std::vector< std::uint64_t > & PhaseII::PixelRawDataContainer::errors ( )

inline

Definition at line 57 of file PhaseIIPixelRawDataContainer.h.

{ return m_errors; }

errors() [2/2]

const std::vector< std::uint64_t > & PhaseII::PixelRawDataContainer::errors ( ) const

inline

Definition at line 55 of file PhaseIIPixelRawDataContainer.h.

{ return m_errors; }

getBCID()

int PhaseII::PixelRawDataContainer::getBCID ( std::uint32_t dataWord )

inlinestatic

Definition at line 42 of file PhaseIIPixelRawDataContainer.h.

{ return unpack(MASK_BCID,  SHIFT_BCID,  dataWord); }

getLVL1A()

int PhaseII::PixelRawDataContainer::getLVL1A ( std::uint32_t dataWord )

inlinestatic

Definition at line 43 of file PhaseIIPixelRawDataContainer.h.

{ return unpack(MASK_LVL1A, SHIFT_LVL1A, dataWord); }

getLVL1ID()

int PhaseII::PixelRawDataContainer::getLVL1ID ( std::uint32_t dataWord )

inlinestatic

Definition at line 44 of file PhaseIIPixelRawDataContainer.h.

{ return unpack(MASK_LVL1D, SHIFT_LVL1D, dataWord); }

getToT()

int PhaseII::PixelRawDataContainer::getToT ( std::uint32_t dataWord )

inlinestatic

Definition at line 41 of file PhaseIIPixelRawDataContainer.h.

{ return unpack(MASK_TOT,   SHIFT_TOT,   dataWord); }

isSane()

bool PhaseII::InDetRawDataContainer< NDim >::isSane ( ) const

inlineinherited

Definition at line 262 of file PhaseIIInDetRawDataContainer.h.

{ return m_coordinates.size() == m_word.size(); }

isValid()

bool PhaseII::InDetRawDataContainer< NDim >::isValid ( unsigned int index ) const

inlineinherited

return true if the index refers to an element in the container

Definition at line 249 of file PhaseIIInDetRawDataContainer.h.

{ assert( m_coordinates.size() == m_word.size()); return index < m_coordinates.size(); }

makeWord()

std::uint32_t PhaseII::PixelRawDataContainer::makeWord ( int tot, int bcid, int lvl1a, int lvl1d )

inlinestatic

Definition at line 47 of file PhaseIIPixelRawDataContainer.h.

                                                                            {
         return   pack(MASK_TOT,   SHIFT_TOT,   tot)
                | pack(MASK_BCID,  SHIFT_BCID,  bcid)
                | pack(MASK_LVL1A, SHIFT_LVL1A, lvl1a)
                | pack(MASK_LVL1D, SHIFT_LVL1D, lvl1d);
      }

move()

void PhaseII::InDetRawDataContainer< NDim >::move ( InDetRawDataContainer< 2 > & dest, unsigned int start_index )

inlineinherited

Move the coordinates and the data word of a certain number of elements at the end to a new container.

Parameters

dest	the container to which the elements will be moved.
start_index	the index of the first element that will be moved. Will copy the elements from start_index until then end to the container dest, and erase the copied elements from this container.

Definition at line 330 of file PhaseIIInDetRawDataContainer.h.

                                                                       {
         unsigned int copy_n_elements=size()-start_index;
         dest.m_coordinates.resize(copy_n_elements);
         dest.m_word.resize(copy_n_elements);
         std::memcpy(dest.m_coordinates.data(),m_coordinates.data()+start_index,copy_n_elements*sizeof(typename decltype(m_coordinates)::value_type));
         std::memcpy(dest.m_word.data(), m_word.data()+start_index, copy_n_elements*sizeof(typename decltype(m_word)::value_type) );
         this->erase_back(start_index);
      }

pack()

constexpr std::uint32_t PhaseII::InDetRawDataContainer< NDim >::pack ( std::uint32_t mask, unsigned int shift, int input )

inlinestaticconstexprinherited

Create a bit-packed word from an input value.

Parameters

mask	the mask to blend out bits of the input value which are not part of the actual value.
shift	the bit number of the first bit in the bit packed data word.
input	the input value.

Returns

a bit packed data word which only represents the input value. This value can be or-ed with other bit-packed values to form a complete data word. If the input value exceeds the maximum value fitting into the provided mask, then the result will be undefined.

Definition at line 319 of file PhaseIIInDetRawDataContainer.h.

                                                                                         {
         // test that packing is loss-less
         assert( static_cast<int>(static_cast<std::uint32_t>(input) & mask) ==input );
         return static_cast<std::uint32_t>( (input & mask) << shift );
      }

reserve()

void PhaseII::InDetRawDataContainer< NDim >::reserve ( std::size_t new_capacity )

inlineinherited

reserve space for a certain number of RDOs.

Definition at line 272 of file PhaseIIInDetRawDataContainer.h.

                                           {
         m_coordinates.reserve(new_capacity);
         m_word.reserve(new_capacity);
         assert(isSane() && m_coordinates.capacity() == m_word.capacity());
      }

size()

std::size_t PhaseII::InDetRawDataContainer< NDim >::size ( ) const

inlineinherited

total number of RDOs which are in this container.

Definition at line 265 of file PhaseIIInDetRawDataContainer.h.

{ assert(isSane()); return m_coordinates.size(); }

unpack()

constexpr int PhaseII::InDetRawDataContainer< NDim >::unpack ( std::uint32_t mask, unsigned int shift, unsigned int word )

inlinestaticconstexprinherited

extract a value from a bit packed word.

Parameters

mask	the mask to blend out bits not part of a certain value after shifting the data word.
shift	the first bit of the value
word	the bit packed data word

Returns

the unpacked value Will shift the data word and then apply the mask to blend out bits not part of the value.

Definition at line 307 of file PhaseIIInDetRawDataContainer.h.

                                                                                           {
         return static_cast<int>( (word >> shift ) & mask );
      }

Member Data Documentation

m_coordinates

std::vector<std::array<std::int16_t,NDim> > PhaseII::InDetRawDataContainer< NDim >::m_coordinates

privateinherited

Definition at line 339 of file PhaseIIInDetRawDataContainer.h.

m_errors

std::vector<std::uint64_t> PhaseII::PixelRawDataContainer::m_errors

private

Definition at line 37 of file PhaseIIPixelRawDataContainer.h.

m_word

std::vector<std::uint32_t> PhaseII::InDetRawDataContainer< NDim >::m_word

privateinherited

Definition at line 340 of file PhaseIIInDetRawDataContainer.h.

MASK_BCID

std::uint32_t PhaseII::PixelRawDataContainer::MASK_BCID = 0xFF

staticconstexprprotected

Definition at line 24 of file PhaseIIPixelRawDataContainer.h.

MASK_LVL1A

std::uint32_t PhaseII::PixelRawDataContainer::MASK_LVL1A = 0xF

staticconstexprprotected

Definition at line 28 of file PhaseIIPixelRawDataContainer.h.

MASK_LVL1D

std::uint32_t PhaseII::PixelRawDataContainer::MASK_LVL1D = 0xFF

staticconstexprprotected

Definition at line 26 of file PhaseIIPixelRawDataContainer.h.

MASK_TOT

std::uint32_t PhaseII::PixelRawDataContainer::MASK_TOT = 0xFF

staticconstexprprotected

Definition at line 22 of file PhaseIIPixelRawDataContainer.h.

SHIFT_BCID

unsigned int PhaseII::PixelRawDataContainer::SHIFT_BCID = 8

staticconstexprprotected

Definition at line 25 of file PhaseIIPixelRawDataContainer.h.

SHIFT_LVL1A

unsigned int PhaseII::PixelRawDataContainer::SHIFT_LVL1A = 24

staticconstexprprotected

Definition at line 29 of file PhaseIIPixelRawDataContainer.h.

SHIFT_LVL1D

unsigned int PhaseII::PixelRawDataContainer::SHIFT_LVL1D = 16

staticconstexprprotected

Definition at line 27 of file PhaseIIPixelRawDataContainer.h.

SHIFT_TOT

unsigned int PhaseII::PixelRawDataContainer::SHIFT_TOT = 0

staticconstexprprotected

Definition at line 23 of file PhaseIIPixelRawDataContainer.h.

---

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

• PhaseIIPixelRawDataContainer.h