CTP_RDO Class Reference

#include <CTP_RDO.h>

Collaboration diagram for CTP_RDO:

Public Member Functions
	CTP_RDO ()=default
	Default constructor needed for pool converters.
	CTP_RDO (unsigned int ctpVersionNumber, const uint32_t nBCs=1, uint32_t nExtraWords=0)
	Constructor takes the number of BCs of the readout window as argument.
	CTP_RDO (unsigned int ctpVersionNumber, std::vector< uint32_t > &&data, uint32_t nExtraWords=0)
	Normal constructor taking the data words of one or several BCs as argument.
	~CTP_RDO ()
	empty default destructor
const std::vector< uint32_t > &	getDataWords () const
void	setTimeSec (const uint32_t sec)
void	setTimeNanoSec (const uint32_t nano)
uint32_t	getTimeSec () const
uint32_t	getTimeNanoSec () const
uint32_t	getNumberOfBunches () const
uint32_t	getL1AcceptBunchPosition () const
uint32_t	getNumberOfAdditionalWords () const
uint32_t	getTimeSinceLastL1A () const
uint32_t	getTurnCounter () const
std::vector< uint32_t >	getTIPWords () const
std::vector< uint32_t >	getTBPWords () const
std::vector< uint32_t >	getTAPWords () const
std::vector< uint32_t >	getTAVWords () const
std::vector< uint32_t >	getEXTRAWords () const
const CTPdataformatVersion &	getCTPVersion () const
void	setCTPVersionNumber (unsigned int ctpVersion)
unsigned int	getCTPVersionNumber () const
void	setTIPWord (const unsigned int i, const uint32_t word)
void	setTBPWord (const unsigned int i, const uint32_t word)
void	setTAPWord (const unsigned int i, const uint32_t word)
void	setTAVWord (const unsigned int i, const uint32_t word)
void	selectBunch (const uint32_t iBC)
void	selectNextBunch ()
void	setNumberOfBunches (const uint32_t nBCs)
void	setL1AcceptBunchPosition (const uint8_t)
void	setTurnCounter (const uint32_t)
void	setNumberOfAdditionalWords (const uint32_t nExtraWords)
const std::string	dump () const
	dump raw object content to string
const std::string	print (const bool longFormat=false) const
	print object content in a human readable format to string

Static Public Attributes
static constexpr unsigned int	SIZEOF_WORDS = 32
	number of bits in one data word (32)

Private Types
enum	WordType {   TIP , TBP , TAP , TAV ,   EXTRA }
typedef enum WordType	WordType

Private Member Functions
void	setWord (const unsigned int i, const uint32_t word)
std::vector< uint32_t >	getWords (WordType type) const

Private Attributes
unsigned int	m_ctpVersionNumber {0}
	number of the CTP version to be used
CTPdataformatVersion	m_ctpDataFormat {0}
	CTP data format for a specified version.
std::vector< uint32_t >	m_dataWords
	raw data words
uint8_t	m_l1AcceptPosition {0}
	bunch position, from which the level1 accept was calculated
uint32_t	m_turnCounter {0}
	turn counter
uint32_t	m_numberOfBunches {0}
	number of bunches in raw data (transient)
uint32_t	m_activeBunch {0}
	active bunch, for book keepting (transient)
uint32_t	m_numberOfAdditionalWords {0}
	number of configurable extra words in the fragment

Detailed Description

Definition at line 20 of file CTP_RDO.h.

Member Typedef Documentation

WordType

typedef enum WordType CTP_RDO::WordType

private

Definition at line 23 of file CTP_RDO.h.

Member Enumeration Documentation

WordType

enum CTP_RDO::WordType

private

Enumerator
TIP
TBP
TAP
TAV
EXTRA

Definition at line 22 of file CTP_RDO.h.

{/*PIT, FPI,*/ TIP, TBP, TAP, TAV, EXTRA};

Constructor & Destructor Documentation

CTP_RDO() [1/3]

CTP_RDO::CTP_RDO ( )

default

Default constructor needed for pool converters.

CTP_RDO() [2/3]

CTP_RDO::CTP_RDO	(	unsigned int	ctpVersionNumber,
		const uint32_t	nBCs = 1,
		uint32_t	nExtraWords = 0 )

Constructor takes the number of BCs of the readout window as argument.

Definition at line 19 of file CTP_RDO.cxx.

   : m_ctpVersionNumber(ctpVersionNumber),
     m_ctpDataFormat(ctpVersionNumber),
     m_numberOfBunches(nBCs), 
     m_numberOfAdditionalWords(nExtraWords)
{
    
   // create correct length, zero filled data member
   m_dataWords.resize(m_ctpDataFormat.getNumberTimeWords()+(nBCs*m_ctpDataFormat.getDAQwordsPerBunch() )+nExtraWords);
}

CTP_RDO() [3/3]

CTP_RDO::CTP_RDO	(	unsigned int	ctpVersionNumber,
		std::vector< uint32_t > &&	data,
		uint32_t	nExtraWords = 0 )

Normal constructor taking the data words of one or several BCs as argument.

Definition at line 30 of file CTP_RDO.cxx.

  : m_ctpVersionNumber(ctpVersionNumber),
    m_ctpDataFormat(ctpVersionNumber),
    m_dataWords(std::move(data))    
{
    
   m_numberOfAdditionalWords=nExtraWords;
   if(!m_dataWords.size()) {
      m_numberOfBunches = 0u;
   } else {
      uint32_t dataWords = static_cast<uint32_t>(m_dataWords.size()) - m_ctpDataFormat.getNumberTimeWords() - nExtraWords;
      m_numberOfBunches = dataWords / m_ctpDataFormat.getDAQwordsPerBunch();
   }
}

~CTP_RDO()

CTP_RDO::~CTP_RDO

(

)

empty default destructor

Definition at line 45 of file CTP_RDO.cxx.

{}

Member Function Documentation

dump()

const std::string CTP_RDO::dump

(

)

const

dump raw object content to string

Definition at line 293 of file CTP_RDO.cxx.

{
   std::ostringstream s;
 
   s << getL1AcceptBunchPosition() << " " << LVL1CTP::convertToHex(this->getDataWords());
 
   return s.str();
}

getCTPVersion()

const CTPdataformatVersion & CTP_RDO::getCTPVersion

(

)

const

Definition at line 48 of file CTP_RDO.cxx.

                             { 
   if(m_ctpVersionNumber==0) {
      MsgStream log(Athena::getMessageSvc(), "CTP_RDO");
      log << MSG::WARNING << "CTPVersion has not been set, no information about data format available, please fix your code" << endmsg;
   }
   return m_ctpDataFormat;
}

getCTPVersionNumber()

unsigned int CTP_RDO::getCTPVersionNumber ( ) const

inline

Definition at line 64 of file CTP_RDO.h.

{ return m_ctpVersionNumber; }

getDataWords()

const std::vector< uint32_t > & CTP_RDO::getDataWords ( ) const

inline

Definition at line 39 of file CTP_RDO.h.

                                                    {
    return m_dataWords;
  }

getEXTRAWords()

std::vector< uint32_t > CTP_RDO::getEXTRAWords

(

)

const

Definition at line 221 of file CTP_RDO.cxx.

{
  return getWords(EXTRA);
}

getL1AcceptBunchPosition()

uint32_t CTP_RDO::getL1AcceptBunchPosition

(

)

const

Definition at line 94 of file CTP_RDO.cxx.

{
   return m_l1AcceptPosition;
}

getNumberOfAdditionalWords()

uint32_t CTP_RDO::getNumberOfAdditionalWords

(

)

const

Definition at line 113 of file CTP_RDO.cxx.

{
   return m_numberOfAdditionalWords;
}

getNumberOfBunches()

uint32_t CTP_RDO::getNumberOfBunches

(

)

const

Definition at line 89 of file CTP_RDO.cxx.

{
   return m_numberOfBunches;
}

getTAPWords()

std::vector< uint32_t > CTP_RDO::getTAPWords

(

)

const

Definition at line 211 of file CTP_RDO.cxx.

{
   return getWords(TAP);
}

getTAVWords()

std::vector< uint32_t > CTP_RDO::getTAVWords

(

)

const

Definition at line 216 of file CTP_RDO.cxx.

{
   return getWords(TAV);
}

getTBPWords()

std::vector< uint32_t > CTP_RDO::getTBPWords

(

)

const

Definition at line 206 of file CTP_RDO.cxx.

{
   return getWords(TBP);
}

getTimeNanoSec()

uint32_t CTP_RDO::getTimeNanoSec

(

)

const

Definition at line 83 of file CTP_RDO.cxx.

{
   if(m_dataWords.size() <= getCTPVersion().getTimeNanosecondsPos()) return 0;  
   return (m_dataWords.at(getCTPVersion().getTimeNanosecondsPos() ) >> getCTPVersion().getTimeNanosecondsOffset() ) * getCTPVersion().getTimeNanosecondsTicks();
}

getTimeSec()

uint32_t CTP_RDO::getTimeSec

(

)

const

Definition at line 77 of file CTP_RDO.cxx.

{
   if(m_dataWords.size() <= getCTPVersion().getTimeSecondsPos()) return 0;  
   return m_dataWords.at(getCTPVersion().getTimeSecondsPos() );
}

getTimeSinceLastL1A()

uint32_t CTP_RDO::getTimeSinceLastL1A

(

)

const

Definition at line 99 of file CTP_RDO.cxx.

{
  if(getEXTRAWords().size())
    return getEXTRAWords().at(0);
  return -999;
}

getTIPWords()

std::vector< uint32_t > CTP_RDO::getTIPWords

(

)

const

Definition at line 201 of file CTP_RDO.cxx.

{
    return getWords(TIP);
}

getTurnCounter()

uint32_t CTP_RDO::getTurnCounter

(

)

const

Definition at line 106 of file CTP_RDO.cxx.

{
  return m_turnCounter;
}

getWords()

std::vector< uint32_t > CTP_RDO::getWords ( WordType type ) const

private

Definition at line 238 of file CTP_RDO.cxx.

{
   unsigned int nWords = 0;
   unsigned int offset = 0;
   std::vector<uint32_t> vec;
   vec.clear();
 
   switch (type) {
   //case PIT:
//      nWords = getCTPVersion().getPITwords();
//      offset = getCTPVersion().getPITpos();
//      break;
//   case FPI:
//      nWords = getCTPVersion().getFPIwords();
//      offset = getCTPVersion().getFPIpos();
//      break;
   case TIP:
      nWords = getCTPVersion().getTIPwords();
      offset = getCTPVersion().getTIPpos();
      break;
   case TBP:
      nWords = getCTPVersion().getTBPwords();
      offset = getCTPVersion().getTBPpos();
      break;
   case TAP:
      nWords = getCTPVersion().getTAPwords();
      offset = getCTPVersion().getTAPpos();
      break;
   case TAV:
      nWords = getCTPVersion().getTAVwords();
      offset = getCTPVersion().getTAVpos();
      break;
   case EXTRA:
     vec.assign(m_dataWords.begin() + (m_dataWords.size()-m_numberOfAdditionalWords), m_dataWords.end());
     return vec;
     break;
 
   default:
      // error
      break;
   }
 
   for(unsigned int bunch = 0 ; bunch < m_numberOfBunches ; ++bunch) {
      for(unsigned int tbp = 0; tbp < nWords; ++tbp) {
          // take offset of TBPwords into account
          unsigned int index = offset + tbp;
          // go to the correct bunch
          index += (bunch * getCTPVersion().getDAQwordsPerBunch());
          if( index < m_dataWords.size() ) vec.push_back(m_dataWords[index]);
      }
   }
   // this is now a list of consecutive data words for all bunches
   return vec;
}

print()

const std::string CTP_RDO::print

(

const bool

longFormat = false

)

const

print object content in a human readable format to string

Definition at line 302 of file CTP_RDO.cxx.

{
   std::ostringstream s;
 
   // lvl1 accept position
   s << "\n L1APos:" << std::setw(3) << getL1AcceptBunchPosition();
   if (longFormat) s << std::endl;
   s << "\n Turn counter:" << std::setw(3) << getTurnCounter();
   if (longFormat) s << std::endl;
 
   // time is only stored once for the whole fragment
   for (size_t i(0); (i < getCTPVersion().getNumberTimeWords() ) && (i < m_dataWords.size()); ++i) {
      if (i == 0 || longFormat) s << "\n Time";
      if (longFormat) s << std::setw(1) << i;
      s << " " << std::setw(8) << m_dataWords[i];
      if (longFormat) s << std::endl;
   }
 
   // return if data content is too short
   if (m_dataWords.size() < 2) return s.str();
 
 
   // loop over the rest of the data fragment
   for (unsigned int k(0); k < (m_dataWords.size()-2)/getCTPVersion().getDAQwordsPerBunch(); ++k) {
 
      // print single fragment
 
      // TIP
      for (size_t i(0), p(k*getCTPVersion().getDAQwordsPerBunch() + getCTPVersion().getTIPpos());
       (i < getCTPVersion().getTIPwords()) && (p < m_dataWords.size()); 
       ++i, ++p) {
     if (i == 0 || longFormat) s << "\n TIP";
     if (longFormat) s << std::setw(1) << i;
     s << LVL1CTP::convertToHex(m_dataWords[p]);
     if (longFormat) s << std::endl;
      }
       
 
      // TBP
      for (size_t i(0), p(k*getCTPVersion().getDAQwordsPerBunch() + getCTPVersion().getTBPpos());
       (i < getCTPVersion().getTBPwords()) && (p < m_dataWords.size()); 
       ++i, ++p) {
     if (i == 0 || longFormat) s << "\n TBP";
     if (longFormat) s << std::setw(1) << i;
     s << LVL1CTP::convertToHex(m_dataWords[p]);
     if (longFormat) s << std::endl;
      }
 
      // TAP
      for (size_t i(0), p(k*getCTPVersion().getDAQwordsPerBunch() + getCTPVersion().getTAPpos());
       (i < getCTPVersion().getTAPwords()) && (p < m_dataWords.size()); 
       ++i, ++p) {
     if (i == 0 || longFormat) s << "\n TAP";
     if (longFormat) s << std::setw(1) << i;
     s << LVL1CTP::convertToHex(m_dataWords[p]);
     if (longFormat) s << std::endl;
      }
 
      // TAV
      for (size_t i(0), p(k*getCTPVersion().getDAQwordsPerBunch() + getCTPVersion().getTAVpos() );
       (i < getCTPVersion().getTAVwords()) && (p < m_dataWords.size()); 
       ++i, ++p) {
     if (i == 0 || longFormat) s << "\n TAV";
     if (longFormat) s << std::setw(1) << i;
     s << LVL1CTP::convertToHex(m_dataWords[p]);
     if (longFormat) s << std::endl;
      }
 
   }
 
   //EXTRA WORDS
   for (size_t i(m_dataWords.size()-m_numberOfAdditionalWords); i < m_dataWords.size(); ++i) {
     if (i == m_dataWords.size()-m_numberOfAdditionalWords || longFormat ) s << "\n EXTRA";
     if (longFormat) s << std::setw(1) << i;
     s << LVL1CTP::convertToHex(m_dataWords[i]);
     if (longFormat) s << std::endl;
   }
   
   return s.str();
}

selectBunch()

void CTP_RDO::selectBunch

(

const uint32_t

iBC

)

Definition at line 118 of file CTP_RDO.cxx.

{
   if (iBC < m_numberOfBunches) {
      m_activeBunch = iBC;
   } else {
      m_activeBunch = 0u;
   }
}

selectNextBunch()

void CTP_RDO::selectNextBunch

(

)

Definition at line 127 of file CTP_RDO.cxx.

{
   ++m_activeBunch;
   m_activeBunch %= m_numberOfBunches;
}

setCTPVersionNumber()

void CTP_RDO::setCTPVersionNumber

(

unsigned int

ctpVersion

)

Definition at line 58 of file CTP_RDO.cxx.

                                                      {
   m_ctpVersionNumber = ctpVersion;
}

setL1AcceptBunchPosition()

void CTP_RDO::setL1AcceptBunchPosition

(

const uint8_t

pos

)

Definition at line 141 of file CTP_RDO.cxx.

{
   if (pos < m_numberOfBunches) {
      m_l1AcceptPosition = pos;
   }
}

setNumberOfAdditionalWords()

void CTP_RDO::setNumberOfAdditionalWords

(

const uint32_t

nExtraWords

)

Definition at line 153 of file CTP_RDO.cxx.

{
  if(nExtraWords > m_numberOfAdditionalWords) {
    m_dataWords.resize(m_dataWords.size()+nExtraWords-m_numberOfAdditionalWords);//Add the difference
  }
  m_numberOfAdditionalWords = nExtraWords;
}

setNumberOfBunches()

void CTP_RDO::setNumberOfBunches

(

const uint32_t

nBCs

)

Definition at line 133 of file CTP_RDO.cxx.

{
   if (nBCs > m_numberOfBunches) {
      m_numberOfBunches = nBCs;
      m_dataWords.resize(getCTPVersion().getNumberTimeWords()+(nBCs*getCTPVersion().getDAQwordsPerBunch() )+m_numberOfAdditionalWords);
   }
}

setTAPWord()

void CTP_RDO::setTAPWord	(	const unsigned int	i,
		const uint32_t	word )

Definition at line 181 of file CTP_RDO.cxx.

{
   setWord(i + (m_activeBunch*getCTPVersion().getDAQwordsPerBunch() )  + getCTPVersion().getTAPpos(), word);
}

setTAVWord()

void CTP_RDO::setTAVWord	(	const unsigned int	i,
		const uint32_t	word )

Definition at line 186 of file CTP_RDO.cxx.

{
   setWord(i + (m_activeBunch*getCTPVersion().getDAQwordsPerBunch())  + getCTPVersion().getTAVpos(), word);
}

setTBPWord()

void CTP_RDO::setTBPWord	(	const unsigned int	i,
		const uint32_t	word )

Definition at line 176 of file CTP_RDO.cxx.

{
   setWord(i + (m_activeBunch*getCTPVersion().getDAQwordsPerBunch() )  + getCTPVersion().getTBPpos(), word);
}

setTimeNanoSec()

void CTP_RDO::setTimeNanoSec

(

const uint32_t

nano

)

Definition at line 69 of file CTP_RDO.cxx.

{
   if(getCTPVersion().getTimeNanosecondsPos() < m_dataWords.size()) {
      m_dataWords[getCTPVersion().getTimeNanosecondsPos()] = 
     (nano/getCTPVersion().getTimeNanosecondsTicks()) << getCTPVersion().getTimeNanosecondsOffset();
   }
}

setTimeSec()

void CTP_RDO::setTimeSec

(

const uint32_t

sec

)

Definition at line 62 of file CTP_RDO.cxx.

{
   if(getCTPVersion().getTimeSecondsPos() < m_dataWords.size()) {
      m_dataWords[getCTPVersion().getTimeSecondsPos()] = sec;
   }
}

setTIPWord()

void CTP_RDO::setTIPWord	(	const unsigned int	i,
		const uint32_t	word )

Definition at line 171 of file CTP_RDO.cxx.

{
    setWord(i + (m_activeBunch*getCTPVersion().getDAQwordsPerBunch())  + getCTPVersion().getTIPpos(), word);
}

setTurnCounter()

void CTP_RDO::setTurnCounter

(

const uint32_t

tc

)

Definition at line 148 of file CTP_RDO.cxx.

{
  m_turnCounter=tc;
}

setWord()

void CTP_RDO::setWord ( const unsigned int i, const uint32_t word )

private

Definition at line 226 of file CTP_RDO.cxx.

{
   if (i < m_dataWords.size()) {
      m_dataWords[i] = word;
   } else {
      MsgStream log(Athena::getMessageSvc(), "CTP_RDO");
      log << MSG::WARNING << "ignoring word " << word << " for position " << i << endmsg;
   }
 
   return;
}

Member Data Documentation

m_activeBunch

uint32_t CTP_RDO::m_activeBunch {0}

private

active bunch, for book keepting (transient)

Definition at line 102 of file CTP_RDO.h.

{0};                 

m_ctpDataFormat

CTPdataformatVersion CTP_RDO::m_ctpDataFormat {0}

private

CTP data format for a specified version.

Definition at line 97 of file CTP_RDO.h.

{0} ;  

m_ctpVersionNumber

unsigned int CTP_RDO::m_ctpVersionNumber {0}

private

number of the CTP version to be used

Definition at line 96 of file CTP_RDO.h.

{0};        

m_dataWords

std::vector<uint32_t> CTP_RDO::m_dataWords

private

raw data words

Definition at line 98 of file CTP_RDO.h.

m_l1AcceptPosition

uint8_t CTP_RDO::m_l1AcceptPosition {0}

private

bunch position, from which the level1 accept was calculated

Definition at line 99 of file CTP_RDO.h.

{0};            

m_numberOfAdditionalWords

uint32_t CTP_RDO::m_numberOfAdditionalWords {0}

private

number of configurable extra words in the fragment

Definition at line 103 of file CTP_RDO.h.

{0};     

m_numberOfBunches

uint32_t CTP_RDO::m_numberOfBunches {0}

private

number of bunches in raw data (transient)

Definition at line 101 of file CTP_RDO.h.

{0};             

m_turnCounter

uint32_t CTP_RDO::m_turnCounter {0}

private

turn counter

Definition at line 100 of file CTP_RDO.h.

{0};                 

SIZEOF_WORDS

unsigned int CTP_RDO::SIZEOF_WORDS = 32

staticconstexpr

number of bits in one data word (32)

Definition at line 90 of file CTP_RDO.h.

---

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

• CTP_RDO.h
• CTP_RDO.cxx