CTPResultUtils Namespace Reference

Utility functions for xAOD::CTPResult objects that rely on tdaq-common. More...

Functions
void	initialize (xAOD::CTPResult &ctpRes, const uint32_t ctpVersionNumber, std::vector< uint32_t > &data, const uint32_t nExtraWords=0)
	Initialize the object using xAOD::Header, xAOD::Trailer, and the payload data.
const std::string	print (const xAOD::CTPResult &ctpRes)
	Print object content in human readable format in a string.

Detailed Description

Utility functions for xAOD::CTPResult objects that rely on tdaq-common.

Declared here as tdaq-common is used in TrigT1Interfaces and not xAODTrigger. Prevents using XAOD_ANALYSIS macro in xAOD class.

Function Documentation

initialize()

void CTPResultUtils::initialize	(	xAOD::CTPResult &	ctpRes,
		const uint32_t	ctpVersionNumber,
		std::vector< uint32_t > &	data,
		const uint32_t	nExtraWords = 0 )

Initialize the object using xAOD::Header, xAOD::Trailer, and the payload data.

Optionally, extra words can be included.

Parameters

ctpRes	Reference to the CTPResult object to initialize.
ctpVersionNumber	Version number of the CTPdataformat.
data	Vector of words representing the payload data (excluding timestamp words).
nExtraWords	Number of additional words (default is 0).

Definition at line 23 of file CTPResultUtils.cxx.

                                                                                                                                 {
 
    // CTP version number
    CTPdataformatVersion ctpDataFormat(ctpVersionNumber);
    ctpRes.setCtpVersionNumber(ctpVersionNumber);
 
    // Check for the case we have an empty data vector and return early
    if (!data.size()) {
      ctpRes.setNumberOfBunches(0u);
      ctpRes.setTimeSec(0u);
      ctpRes.setTimeNanoSec(0u);
      ctpRes.setTIPWords({});
      ctpRes.setTBPWords({});
      ctpRes.setTAPWords({});
      ctpRes.setTAVWords({});
      ctpRes.setAdditionalWords({});
      return;
    }
 
    // Set the number of bunches
    uint32_t numberOfWords = static_cast<uint32_t>(data.size()) - ctpDataFormat.getNumberTimeWords() - nExtraWords;
    ctpRes.setNumberOfBunches(numberOfWords / ctpDataFormat.getDAQwordsPerBunch());
 
    // Set the timestamps
    ctpRes.setTimeSec(data[ctpDataFormat.getTimeSecondsPos()]);
    ctpRes.setTimeNanoSec(data[ctpDataFormat.getTimeNanosecondsPos()]);
 
    // Create vectors of vectors for the trigger words for all bunches
    std::vector<std::vector<uint32_t>> tip(ctpRes.numberOfBunches());
    std::vector<std::vector<uint32_t>> tbp(ctpRes.numberOfBunches());
    std::vector<std::vector<uint32_t>> tap(ctpRes.numberOfBunches());
    std::vector<std::vector<uint32_t>> tav(ctpRes.numberOfBunches());
 
    // Fill vectors
    for( uint32_t bunch=0u; bunch != ctpRes.numberOfBunches(); ++bunch){
 
      // TIP words
      for(unsigned int tipIdx = 0; tipIdx < ctpDataFormat.getTIPwords(); ++tipIdx) {
        unsigned int index = ctpDataFormat.getTIPpos() + tipIdx + (bunch * ctpDataFormat.getDAQwordsPerBunch());
        if( index < data.size() ) {
          tip[bunch].push_back(data[index]);
        }
      }
 
      // TBP words
      for(unsigned int tbpIdx = 0; tbpIdx < ctpDataFormat.getTBPwords(); ++tbpIdx) {
        unsigned int index = ctpDataFormat.getTBPpos() + tbpIdx + (bunch * ctpDataFormat.getDAQwordsPerBunch());
        if( index < data.size() ) {
          tbp[bunch].push_back(data[index]);
        }
      }
 
      // TAP words
      for(unsigned int tapIdx = 0; tapIdx < ctpDataFormat.getTAPwords(); ++tapIdx) {
        unsigned int index = ctpDataFormat.getTAPpos() + tapIdx + (bunch * ctpDataFormat.getDAQwordsPerBunch());
        if( index < data.size() ) {
          tap[bunch].push_back(data[index]);
        }
      }
 
      // TAV words
      for(unsigned int tavIdx = 0; tavIdx < ctpDataFormat.getTAVwords(); ++tavIdx) {
        unsigned int index = ctpDataFormat.getTAVpos() + tavIdx + (bunch * ctpDataFormat.getDAQwordsPerBunch());
        if( index < data.size() ) {
          tav[bunch].push_back(data[index]);
        }
      }
    }
    ctpRes.setTIPWords(tip);
    ctpRes.setTBPWords(tbp);
    ctpRes.setTAPWords(tap);
    ctpRes.setTAVWords(tav);
 
    // Additional words
    std::vector<uint32_t> vec;
    vec.assign(data.begin() + (data.size()-nExtraWords), data.end());
    ctpRes.setAdditionalWords(vec);
  }

print()

const std::string CTPResultUtils::print

(

const xAOD::CTPResult &

ctpRes

)

Print object content in human readable format in a string.

Parameters

ctpRes

Reference to the CTPResult object to initialize.

Returns

Human readable output as a string.

Definition at line 103 of file CTPResultUtils.cxx.

                                                     {
 
    std::ostringstream s;
 
    s << "\n*BEGIN* xAOD::CTPResult" << std::endl;
 
    // Check number of bunches
    if(ctpRes.numberOfBunches() == 0) {
      s << "xAOD::CTPResult empty" << std::endl;
      s << "*END* xAOD::CTPResult" << std::endl;
      return s.str();
    }
 
    // Print whether the object has the expected format and has good status
    std::vector<std::string> ctpResultIssues = ctpRes.checkForIssues();
    if (ctpResultIssues.empty()) {
      s << "xAOD::CTPResult status: Good! " << std::endl;
    } else {
      s << "xAOD::CTPResult status: Bad! " << std::endl;
      for (const auto& issue : ctpResultIssues) {
        s << "xAOD::CTPResult status: " << issue << std::endl;
      }
    }
 
    s << "CTP version number: " <<  ctpRes.ctpVersionNumber() << std::endl;
    s << "Number of bunches: " <<  ctpRes.numberOfBunches() << std::endl;
    s << "L1A position: " << ctpRes.l1AcceptBunchPosition() << std::endl;
 
    // Print header info
    s << "Header information:  " << std::endl;
    s << "    Header marker           :  " << std::hex << ctpRes.headerMarker() << std::dec << std::endl;
    s << "    Header size             :  " << ctpRes.headerSize() << std::endl;
    s << "    Header format version   :  " << ctpRes.headerFormatVersion() << std::endl;
    s << "    Source ID               :  0x" << std::hex << ctpRes.sourceID() << std::dec << std::endl;
    s << "    Run number              :  " << ctpRes.runNumber() << std::endl;
    s << "    Ext. LVL1 ID            :  " << ctpRes.L1ID() << std::endl;
    s << "    BCID                    :  " << ctpRes.BCID() << std::endl;
    s << "    Trigger type            :  " << ctpRes.triggerType() << std::endl;
    s << "    Det. event type         :  " << ctpRes.eventType() << std::endl;
 
    // Print payload info
    s << "Payload information:  " << std::endl;
    s << "    Time " << ctpRes.timeSec() << "s "
        << std::setw(10) << std::setiosflags(std::ios_base::right) << std::setfill(' ')
        << ctpRes.timeNanoSec() << std::resetiosflags(std::ios_base::right)
        << "ns" << std::endl;
 
    // Print per-bunch information
    for(unsigned int i = 0; i<ctpRes.numberOfBunches(); ++i) {
 
      auto bunch = ctpRes.getBC(i);
      s << "    BC dump for bunch " << i << std::endl;
 
      // TIP words
      for(unsigned int j = 0; j<ctpRes.tipWords()[i].size(); ++j) {
        s << "        TIP word number " << j << ": 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << ctpRes.tipWords()[i][j] << std::dec << std::endl;
      }
      if (ctpRes.tipWords()[i].size() == 0) {
        s << "        No TIP words!" << std::endl;
      }
 
      // TBP words
      for(unsigned int j = 0; j<ctpRes.tbpWords()[i].size(); ++j) {
        s << "        TBP word number " << j << ": 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << ctpRes.tbpWords()[i][j] << std::dec << std::endl;
      }
      if (ctpRes.tbpWords()[i].size() == 0) {
        s << "        No TBP words!" << std::endl;
      }
 
      // TAP words
      for(unsigned int j = 0; j<ctpRes.tapWords()[i].size(); ++j) {
        s << "        TAP word number " << j << ": 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << ctpRes.tapWords()[i][j] << std::dec << std::endl;
      }
      if (ctpRes.tapWords()[i].size() == 0) {
        s << "        No TAP words!" << std::endl;
      }
 
      // TAV words
      for(unsigned int j = 0; j<ctpRes.tavWords()[i].size(); ++j) {
        s << "        TAV word number " << j << ": 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << ctpRes.tavWords()[i][j] << std::dec << std::endl;
      }
      if (ctpRes.tavWords()[i].size() == 0) {
        s << "        No TAV words!" << std::endl;
      }
    }
 
    // Additional words
    for(unsigned int i = 0; i<ctpRes.additionalWords().size(); ++i) {
      s << "    Additional word number " << i << ": 0x" << std::hex << std::setw( 8 ) << std::setfill( '0' ) << ctpRes.additionalWords()[i] << std::dec << std::endl;
    }
    if (ctpRes.additionalWords().size() == 0) {
      s << "    No additional words!" << std::endl;
    }
 
    // Print trailer info
    s << "Trailer information:  " << std::endl;
    s << "    Error status                :  " << ctpRes.errorStatus() << std::endl;
    s << "    Status info                 :  " << ctpRes.infoStatus() << std::endl;
    s << "    Number of status words      :  " << ctpRes.numStatusWords() << std::endl;
    s << "    Number of data words        :  " << ctpRes.numDataWords() << std::endl;
    s << "    Status information position :  " << ctpRes.statusPosition() << std::endl;
    s << "*END* xAOD::CTPResult" << std::endl;
 
    return s.str();
  }