PhaseII::StripRawDataContainer Class Reference

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

#include <PhaseIIStripRawDataContainer.h>

Inheritance diagram for PhaseII::StripRawDataContainer:

Collaboration diagram for PhaseII::StripRawDataContainer:

Public Types
enum	ERawDataType { SCT1 = 1 , SCT3 =3 , UNKNOWN =0 }
	The data format of the RAW data. More...

Public Member Functions
ERawDataType	dataType () const
	Return the type of the original RAW data the RDO container is based on.
void	setDataType (ERawDataType type)
	Set the RAW data type of this container.
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	getGroupSize (std::uint32_t dataWord)
	Extract the number of consecutive strip hits starting from the coordinates of the corresponding RDO from the data word.
static int	getTimeBin (std::uint32_t dataWord)
	Extract the time bin from the data word.
static int	getErrors (std::uint32_t dataWord)
	Extract error information from the data word.
static bool	OnTime (std::uint32_t dataWord)
static bool	FirstHitError (std::uint32_t dataWord)
static bool	SecondHitError (std::uint32_t dataWord)
static std::uint32_t	makeWord (unsigned int group_size, unsigned int time_bin, unsigned int errors)
	Create a bit-packed data word.
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.

Protected Attributes
ERawDataType	m_dataType =UNKNOWN

Static Protected Attributes
static constexpr std::uint32_t	MASK_GROUPSIZE = 0x7FF
static constexpr unsigned int	SHIFT_GROUPSIZE = 0
static constexpr std::uint32_t	MASK_TIMEBIN = 0x7
static constexpr unsigned int	SHIFT_TIMEBIN = 22
static constexpr std::uint32_t	MASK_ERRORS = 0x7
static constexpr unsigned int	SHIFT_ERRORS = 25
static constexpr std::uint32_t	MASK_ONTIME = 0x1
static constexpr unsigned int	SHIFT_ONTIME = 23
static constexpr std::uint32_t	MASK_FIRSTHITERROR = 0x1
static constexpr unsigned int	SHIFT_FIRSTHITERROR = 29
static constexpr std::uint32_t	MASK_SECONDHITERROR = 0x1
static constexpr unsigned int	SHIFT_SECONDHITERROR = 30

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

Detailed Description

The container for strip RDOs The base class is the InDetRawDataContainer with a coordinate dimension of 1.

Definition at line 18 of file PhaseIIStripRawDataContainer.h.

Member Enumeration Documentation

ERawDataType

enum PhaseII::StripRawDataContainer::ERawDataType

The data format of the RAW data.

Enumerator
SCT1
SCT3
UNKNOWN

Definition at line 57 of file PhaseIIStripRawDataContainer.h.

{ SCT1 = 1, SCT3 =3, UNKNOWN=0};

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]; }

dataType()

ERawDataType PhaseII::StripRawDataContainer::dataType ( ) const

inline

Return the type of the original RAW data the RDO container is based on.

Definition at line 59 of file PhaseIIStripRawDataContainer.h.

{ return m_dataType; }

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());
      }

FirstHitError()

bool PhaseII::StripRawDataContainer::FirstHitError ( std::uint32_t dataWord )

inlinestatic

Definition at line 45 of file PhaseIIStripRawDataContainer.h.

{ return unpack(MASK_FIRSTHITERROR,  SHIFT_FIRSTHITERROR,  dataWord); };

getErrors()

int PhaseII::StripRawDataContainer::getErrors ( std::uint32_t dataWord )

inlinestatic

Extract error information from the data word.

Definition at line 41 of file PhaseIIStripRawDataContainer.h.

{ return unpack(MASK_ERRORS,         SHIFT_ERRORS,         dataWord); }

getGroupSize()

int PhaseII::StripRawDataContainer::getGroupSize ( std::uint32_t dataWord )

inlinestatic

Extract the number of consecutive strip hits starting from the coordinates of the corresponding RDO from the data word.

Definition at line 37 of file PhaseIIStripRawDataContainer.h.

{ return unpack(MASK_GROUPSIZE,      SHIFT_GROUPSIZE,      dataWord); }

getTimeBin()

int PhaseII::StripRawDataContainer::getTimeBin ( std::uint32_t dataWord )

inlinestatic

Extract the time bin from the data word.

Definition at line 39 of file PhaseIIStripRawDataContainer.h.

{ return unpack(MASK_TIMEBIN,        SHIFT_TIMEBIN,        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::StripRawDataContainer::makeWord ( unsigned int group_size, unsigned int time_bin, unsigned int errors )

inlinestatic

Create a bit-packed data word.

Definition at line 49 of file PhaseIIStripRawDataContainer.h.

                                                                                                        {
         return   pack(MASK_GROUPSIZE, SHIFT_GROUPSIZE, group_size)
                | pack(MASK_TIMEBIN,   SHIFT_TIMEBIN,   time_bin)
                | pack(MASK_ERRORS,    SHIFT_ERRORS,    errors);
      }

move()

void PhaseII::InDetRawDataContainer< NDim >::move ( InDetRawDataContainer< 1 > & 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);
      }

OnTime()

bool PhaseII::StripRawDataContainer::OnTime ( std::uint32_t dataWord )

inlinestatic

Definition at line 44 of file PhaseIIStripRawDataContainer.h.

{ return unpack(MASK_ONTIME,         SHIFT_ONTIME,         dataWord); };

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());
      }

SecondHitError()

bool PhaseII::StripRawDataContainer::SecondHitError ( std::uint32_t dataWord )

inlinestatic

Definition at line 46 of file PhaseIIStripRawDataContainer.h.

{ return unpack(MASK_SECONDHITERROR, SHIFT_SECONDHITERROR, dataWord); };

setDataType()

void PhaseII::StripRawDataContainer::setDataType ( ERawDataType type )

inline

Set the RAW data type of this container.

Definition at line 61 of file PhaseIIStripRawDataContainer.h.

{ assert(m_dataType == UNKNOWN);  m_dataType=type; }

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_dataType

ERawDataType PhaseII::StripRawDataContainer::m_dataType =UNKNOWN

protected

Definition at line 63 of file PhaseIIStripRawDataContainer.h.

m_word

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

privateinherited

Definition at line 340 of file PhaseIIInDetRawDataContainer.h.

MASK_ERRORS

std::uint32_t PhaseII::StripRawDataContainer::MASK_ERRORS = 0x7

staticconstexprprotected

Definition at line 26 of file PhaseIIStripRawDataContainer.h.

MASK_FIRSTHITERROR

std::uint32_t PhaseII::StripRawDataContainer::MASK_FIRSTHITERROR = 0x1

staticconstexprprotected

Definition at line 31 of file PhaseIIStripRawDataContainer.h.

MASK_GROUPSIZE

std::uint32_t PhaseII::StripRawDataContainer::MASK_GROUPSIZE = 0x7FF

staticconstexprprotected

Definition at line 22 of file PhaseIIStripRawDataContainer.h.

MASK_ONTIME

std::uint32_t PhaseII::StripRawDataContainer::MASK_ONTIME = 0x1

staticconstexprprotected

Definition at line 29 of file PhaseIIStripRawDataContainer.h.

MASK_SECONDHITERROR

std::uint32_t PhaseII::StripRawDataContainer::MASK_SECONDHITERROR = 0x1

staticconstexprprotected

Definition at line 33 of file PhaseIIStripRawDataContainer.h.

MASK_TIMEBIN

std::uint32_t PhaseII::StripRawDataContainer::MASK_TIMEBIN = 0x7

staticconstexprprotected

Definition at line 24 of file PhaseIIStripRawDataContainer.h.

SHIFT_ERRORS

unsigned int PhaseII::StripRawDataContainer::SHIFT_ERRORS = 25

staticconstexprprotected

Definition at line 27 of file PhaseIIStripRawDataContainer.h.

SHIFT_FIRSTHITERROR

unsigned int PhaseII::StripRawDataContainer::SHIFT_FIRSTHITERROR = 29

staticconstexprprotected

Definition at line 32 of file PhaseIIStripRawDataContainer.h.

SHIFT_GROUPSIZE

unsigned int PhaseII::StripRawDataContainer::SHIFT_GROUPSIZE = 0

staticconstexprprotected

Definition at line 23 of file PhaseIIStripRawDataContainer.h.

SHIFT_ONTIME

unsigned int PhaseII::StripRawDataContainer::SHIFT_ONTIME = 23

staticconstexprprotected

Definition at line 30 of file PhaseIIStripRawDataContainer.h.

SHIFT_SECONDHITERROR

unsigned int PhaseII::StripRawDataContainer::SHIFT_SECONDHITERROR = 30

staticconstexprprotected

Definition at line 34 of file PhaseIIStripRawDataContainer.h.

SHIFT_TIMEBIN

unsigned int PhaseII::StripRawDataContainer::SHIFT_TIMEBIN = 22

staticconstexprprotected

Definition at line 25 of file PhaseIIStripRawDataContainer.h.

---

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

• PhaseIIStripRawDataContainer.h