Muon::nsw::NSWTriggerSTGL1AElink Class Reference

#include <NSWTriggerSTGL1AElink.h>

Inheritance diagram for Muon::nsw::NSWTriggerSTGL1AElink:

Collaboration diagram for Muon::nsw::NSWTriggerSTGL1AElink:

Classes
struct	DataHeader
	Helper struct to hold information of the header for each data chunk. More...

Public Member Functions
	NSWTriggerSTGL1AElink (const std::uint32_t *bs, std::uint32_t remaining)
virtual	~NSWTriggerSTGL1AElink ()=default
std::uint32_t	head_fragID () const
std::uint32_t	head_sectID () const
std::uint32_t	head_EC () const
std::uint32_t	head_flags () const
std::uint32_t	head_BCID () const
std::uint32_t	head_orbit () const
std::uint32_t	head_spare () const
std::uint32_t	L1ID () const
std::uint32_t	l1a_versionID () const
std::uint32_t	l1a_local_req_BCID () const
std::uint32_t	l1a_local_rel_BCID () const
std::uint32_t	l1a_open_BCID () const
std::uint32_t	l1a_req_BCID () const
std::uint32_t	l1a_close_BCID () const
std::uint32_t	l1a_timeout () const
std::uint32_t	head_overflowCount () const
std::uint32_t	l1a_open_BCID_offset () const
std::uint32_t	l1a_req_BCID_offset () const
std::uint32_t	l1a_close_BCID_offset () const
std::uint32_t	l1a_timeout_config () const
std::uint32_t	l1a_busy_thr () const
std::uint32_t	l1a_engine_snapshot () const
std::uint32_t	l1a_link_const () const
std::uint32_t	l1a_padding () const
std::uint32_t	head_wdw_matching_engines_usage () const
const std::vector< std::uint32_t > &	stream_head_nbits () const
const std::vector< std::uint32_t > &	stream_head_nwords () const
const std::vector< std::uint32_t > &	stream_head_fifo_size () const
const std::vector< std::uint32_t > &	stream_head_streamID () const
const std::vector< std::vector< std::vector< std::uint32_t > > > &	stream_data () const
std::uint32_t	trailer_CRC () const
const std::vector< STGTPPadPacket > &	pad_packets () const
const std::vector< STGTPSegmentPacket > &	segment_packet () const
const std::vector< STGTPMMPacket > &	mm_packet () const
const std::vector< STGTPStripPacket > &	strip_packet () const
unsigned int	nwords () const
unsigned int	nwordsFlx () const
unsigned int	status () const
bool	suspect () const
uint32_t	elinkWord () const
const std::shared_ptr< Muon::nsw::NSWResourceId > &	elinkId () const

Protected Attributes
unsigned int	m_wordCount {}
unsigned int	m_wordCountFlx {}
unsigned int	m_packet_status {}
bool	m_packet_sus {}
uint32_t	m_elinkWord {}
std::shared_ptr< Muon::nsw::NSWResourceId >	m_elinkId

Private Member Functions
int	parse_version_workaround (std::size_t &readPointer)
	parse version workaround More...
void	decode_header (std::size_t &readPointer, int &version)
	Decode the header. More...
void	decode_header_v3 (std::size_t &readPointer, int &version)
void	decode_data (std::size_t &readPointer, int version)
	Decode the pad and segment data. More...
void	decode_data_v3 (std::size_t &readPointer, int version)
DataHeader	decode_data_header (std::size_t &readPointer, int version)
	Decode the header of each data segment. More...
DataHeader	decode_data_header_v3 (std::size_t &readPointer, int version)
std::vector< std::vector< std::uint32_t > >	decode_data_payload (std::size_t &readPointer, const DataHeader &header, int version) const
	Decode the payload of each data segment. More...
std::vector< std::vector< std::uint32_t > >	decode_data_payload_v3 (std::size_t &readPointer, const DataHeader &header, int version) const
void	analyze_data (int version)
	Analyze data chunks and create decoded objects. More...
void	analyze_data_v3 (int version)
void	decode_trailer (std::size_t &readPointer)
	Decode the trailer. More...
std::uint64_t	decode (std::size_t &readPointer, std::size_t size) const
	Decode a value. More...
std::uint64_t	decode_v3 (std::size_t &readPointer, std::size_t size) const

Static Private Member Functions
static std::uint64_t	correct_size_for_padding (std::uint64_t initial)

Private Attributes
std::span< const std::uint32_t >	m_data
std::uint32_t	m_head_fragID {}
std::uint32_t	m_head_sectID {}
std::uint32_t	m_head_EC {}
std::uint32_t	m_head_flags {}
std::uint32_t	m_head_BCID {}
std::uint32_t	m_head_orbit {}
std::uint32_t	m_head_spare {}
std::uint32_t	m_L1ID {}
std::uint32_t	m_l1a_versionID {}
std::uint32_t	m_l1a_local_req_BCID {}
std::uint32_t	m_l1a_local_rel_BCID {}
std::uint32_t	m_l1a_open_BCID {}
std::uint32_t	m_l1a_req_BCID {}
std::uint32_t	m_l1a_close_BCID {}
std::uint32_t	m_l1a_timeout {}
std::uint32_t	m_l1a_open_BCID_offset {}
std::uint32_t	m_l1a_req_BCID_offset {}
std::uint32_t	m_l1a_close_BCID_offset {}
std::uint32_t	m_l1a_timeout_config {}
std::uint32_t	m_l1a_busy_thr {}
std::uint32_t	m_l1a_engine_snapshot {}
std::uint32_t	m_l1a_link_const {}
std::uint32_t	m_l1a_padding {}
std::uint32_t	m_l1a_wdw_matching_engines_usage {}
std::vector< std::uint32_t >	m_stream_head_nbits
std::vector< std::uint32_t >	m_stream_head_nwords
std::vector< std::uint32_t >	m_stream_head_fifo_size
std::vector< std::uint32_t >	m_stream_head_streamID
std::vector< std::vector< std::vector< std::uint32_t > > >	m_stream_data
std::uint32_t	m_trailer_CRC {}
std::vector< STGTPPadPacket >	m_pad_packets
std::vector< STGTPSegmentPacket >	m_segment_packets
std::vector< STGTPMMPacket >	m_mm_packets
std::vector< STGTPStripPacket >	m_strip_packets
int	m_packet_version

Static Private Attributes
static constexpr auto	WORD_SIZE = sizeof(decltype(m_data)::element_type) * 8
static constexpr auto	WORD_SIZE_DOUBLE = static_cast<double>(WORD_SIZE)

Detailed Description

Definition at line 14 of file NSWTriggerSTGL1AElink.h.

Constructor & Destructor Documentation

NSWTriggerSTGL1AElink()

Muon::nsw::NSWTriggerSTGL1AElink::NSWTriggerSTGL1AElink	(	const std::uint32_t *	bs,
		std::uint32_t	remaining
	)

Definition at line 16 of file NSWTriggerSTGL1AElink.cxx.

    : NSWTriggerElink(bs, remaining), m_data{bs, remaining} {
  // TODO: once format finalized, checking a minimum size
 
  // 2 felix header 32b words already decoded;
  constexpr static auto START_DATA = std::size_t{2 * 32};
  auto readPointer = std::size_t{START_DATA};
 
  m_packet_version = parse_version_workaround(readPointer);
  decode_header(readPointer, m_packet_version);
  decode_data(readPointer, m_packet_version);
  decode_trailer(readPointer);
}

~NSWTriggerSTGL1AElink()

virtual Muon::nsw::NSWTriggerSTGL1AElink::~NSWTriggerSTGL1AElink ( )

virtualdefault

Member Function Documentation

analyze_data()

void Muon::nsw::NSWTriggerSTGL1AElink::analyze_data ( int  version )

private

Analyze data chunks and create decoded objects.

Definition at line 364 of file NSWTriggerSTGL1AElink.cxx.

                                                           {
  if (version >= 3){
     return analyze_data_v3(version);
  }
 
  size_t word_size = WORD_SIZE_DOUBLE;
  auto counterChunk = std::size_t{0};
  for (const auto& dataChunk : m_stream_data) {
    for (const auto& dataWord : dataChunk) {
      const auto expectedSize =
          static_cast<std::size_t>(std::ceil(m_stream_head_nbits.at(counterChunk) / word_size));
      if (std::size(dataWord) != expectedSize) {
        throw std::length_error(Muon::nsw::format("Stream data size {} does not match expected number of messages {}",
                                            std::size(dataWord), expectedSize));
      }
      switch (m_stream_head_streamID.at(counterChunk)) {
        case STGTPPad::pad_stream_header:
          m_pad_packets.emplace_back(dataWord,version);
          break;
        case STGTPSegments::merge_stream_header:
          m_segment_packets.emplace_back(dataWord,version);
          break;
        case STGTPStrips::strip_stream_header:
          m_strip_packets.emplace_back(dataWord,version);
          break;
        default:
          throw std::runtime_error(Muon::nsw::format("Invalid stream type {}", m_stream_head_streamID.at(counterChunk)));
      }
    }
    ++counterChunk;
  }
}

analyze_data_v3()

void Muon::nsw::NSWTriggerSTGL1AElink::analyze_data_v3 ( int  version )

private

Definition at line 330 of file NSWTriggerSTGL1AElink.cxx.

                                                              { 
 
  size_t word_size = WORD_SIZE_DOUBLE;
  auto counterChunk = std::size_t{0};
  for (const auto& dataChunk : m_stream_data) {
    for (const auto& dataWord : dataChunk) {
      const auto expectedSize =
          static_cast<std::size_t>(std::ceil(m_stream_head_nbits.at(counterChunk) / word_size));
      if (std::size(dataWord) != expectedSize) {
        throw std::length_error(Muon::nsw::format("Stream data size {} does not match expected number of messages {}",
                                            std::size(dataWord), expectedSize));
      }
      switch (m_stream_head_streamID.at(counterChunk)) {
        case STGTPPad::pad_stream_header:
          m_pad_packets.emplace_back(dataWord,version);
          break;
        case STGTPSegments::merge_stream_header:
          m_segment_packets.emplace_back(dataWord,version);
          break;
        case STGTPMMData::mm_stream_header:
          m_mm_packets.emplace_back(dataWord,version);
          break;
        case STGTPStrips::strip_stream_header:
          m_strip_packets.emplace_back(dataWord,version);
          break;
        default:
          throw std::runtime_error(Muon::nsw::format("Invalid stream type {}", m_stream_head_streamID.at(counterChunk)));
      }
    }
    ++counterChunk;
  }
 
}

correct_size_for_padding()

std::uint64_t Muon::nsw::NSWTriggerSTGL1AElink::correct_size_for_padding ( std::uint64_t  initial )

staticprivate

Definition at line 397 of file NSWTriggerSTGL1AElink.cxx.

                                                                                            {
  static constexpr auto PADDING = 16;
  if (initial % PADDING) {
    return ((initial + PADDING - 1) / PADDING) * PADDING;
  } else {
    return initial;
  }
}

decode()

std::uint64_t Muon::nsw::NSWTriggerSTGL1AElink::decode ( std::size_t &  readPointer, std::size_t  size  ) const

private

Decode a value.

Parameters

readPointer	Current read pointer position (updated by function)
size	Size of the value to be decoded

Returns

std::uint64_t Decoded value

Definition at line 326 of file NSWTriggerSTGL1AElink.cxx.

                                                                                                   {
  return Muon::nsw::decode_and_advance<std::uint64_t, std::uint32_t>(m_data, readPointer, size);
}

decode_data()

void Muon::nsw::NSWTriggerSTGL1AElink::decode_data ( std::size_t &  readPointer, int  version  )

private

Decode the pad and segment data.

Parameters

readPointer

Current read pointer position (updated by function)

Definition at line 146 of file NSWTriggerSTGL1AElink.cxx.

                                                                                  {
  if (version == 3)
  {
     return decode_data_v3(readPointer, version);
  }
  auto PADDING_BITS_END = std::size_t{16};
 
  const auto endOfData = m_wordCountFlx * WORD_SIZE - Muon::nsw::STGTPL1A::size_trailer_CRC - PADDING_BITS_END;
  while (readPointer < endOfData) {
    static constexpr auto SIZE_DATA_HEADER = STGTPL1A::size_stream_head_nbits + STGTPL1A::size_stream_head_nwords +
                                             STGTPL1A::size_stream_head_fifo_size + STGTPL1A::size_stream_head_streamID;
    if (readPointer + SIZE_DATA_HEADER > endOfData) {
      throw std::length_error(
                  Muon::nsw::format("Read pointer ({}) would excede memory dedicated to data chunks ({}) while parsing the header (size: {})",
                        readPointer, endOfData, SIZE_DATA_HEADER));
    }
    const auto header_data = decode_data_header(readPointer, version);
 
    if (header_data.total_expected_size > m_wordCountFlx    - ceil(readPointer / WORD_SIZE ) + 1) {
      throw std::length_error(Muon::nsw::format("STG TP stream size {} larger than expected packet size {}",
                                          header_data.total_expected_size,
                                          m_wordCountFlx  - ceil(readPointer / WORD_SIZE ) + 1));
    }
    if (header_data.nwords * header_data.data_size + readPointer > endOfData) {
      throw std::length_error(Muon::nsw::format("Requested to decode {} bits but only {} bits are remaining",
                                          header_data.nwords * header_data.data_size, endOfData - readPointer));
    }
 
    m_stream_data.push_back(decode_data_payload(readPointer, header_data, version));
  }
  analyze_data(version);
}

decode_data_header()

Muon::nsw::NSWTriggerSTGL1AElink::DataHeader Muon::nsw::NSWTriggerSTGL1AElink::decode_data_header ( std::size_t &  readPointer, int  version  )

private

Decode the header of each data segment.

Contains information about type, number of words and bits per word

Parameters

readPointer

Current read pointer position (updated by function)

Returns

DataHeader Information from header

Definition at line 249 of file NSWTriggerSTGL1AElink.cxx.

                                         {
  if (version >= 3){
      return decode_data_header_v3(readPointer, version);
  }
  const auto current_stream_head_nbits = decode(readPointer, STGTPL1A::size_stream_head_nbits);
  const auto current_stream_head_nwords = decode(readPointer, STGTPL1A::size_stream_head_nwords);
  const auto current_stream_head_fifo_size = decode(readPointer, STGTPL1A::size_stream_head_fifo_size);
  const auto current_stream_head_streamID = decode(readPointer, STGTPL1A::size_stream_head_streamID);
 
  // zero padding to multiples of 16bits - TP logic - this is the real number
  // of bits to read
  const auto corrected_current_stream_head_nbits = correct_size_for_padding(current_stream_head_nbits);
 
  m_stream_head_nbits.push_back(corrected_current_stream_head_nbits);
  m_stream_head_nwords.push_back(current_stream_head_nwords);
  m_stream_head_fifo_size.push_back(current_stream_head_fifo_size);
  m_stream_head_streamID.push_back(current_stream_head_streamID);
 
  size_t word_size =  WORD_SIZE_DOUBLE;
  const auto data_size = static_cast<std::size_t>(std::ceil(corrected_current_stream_head_nbits / word_size));
  const auto total_expected_size = data_size * current_stream_head_nwords;
  
  ERS_DEBUG(2, Muon::nsw::format("stream_head_nbits: {}", corrected_current_stream_head_nbits));
  ERS_DEBUG(2, Muon::nsw::format("stream_head_nwords: {}", current_stream_head_nwords));
  ERS_DEBUG(2, Muon::nsw::format("stream_head_fifo_size: {}", current_stream_head_fifo_size));
  ERS_DEBUG(2, Muon::nsw::format("stream_head_streamID: {}", current_stream_head_streamID));
  ERS_DEBUG(2, Muon::nsw::format("total_expected_size: {}", data_size * current_stream_head_nwords));
  ERS_DEBUG(2, Muon::nsw::format("m_wordCountFlx: {}, ceil(readPointer/{}): {}", m_wordCountFlx, word_size,
                           ceil(readPointer / word_size)));
 
  return {corrected_current_stream_head_nbits, current_stream_head_nwords, current_stream_head_fifo_size,
          current_stream_head_streamID,        total_expected_size,        data_size};
}

decode_data_header_v3()

Muon::nsw::NSWTriggerSTGL1AElink::DataHeader Muon::nsw::NSWTriggerSTGL1AElink::decode_data_header_v3 ( std::size_t &  readPointer, int  version  )

private

Definition at line 179 of file NSWTriggerSTGL1AElink.cxx.

                                         {
  
 
  if (version != 3){
    throw std::invalid_argument("decode_data_header_v3 version should be exactly 3"); 
  }
 
  size_t felix_word_size =  WORD_SIZE_DOUBLE;
  auto PADDING_BITS_END = std::size_t{16};
  const auto stream_head_nbits = decode(readPointer, STGTPL1A::size_stream_head_nbits);
  const auto stream_head_nwords = decode(readPointer, STGTPL1A::size_stream_head_nwords);
  const auto current_stream_head_fifo_size = decode(readPointer, STGTPL1A::size_stream_head_fifo_size);
  const auto current_stream_head_streamID = decode(readPointer, STGTPL1A::size_stream_head_streamID);
  const auto total_expected_size = stream_head_nbits * stream_head_nwords;
  auto endOfData = m_wordCountFlx * felix_word_size - Muon::nsw::STGTPL1A::size_trailer_CRC - PADDING_BITS_END;
  size_t current_stream_head_nbits = 0;
  size_t current_stream_head_nwords = 0;
 
  switch (current_stream_head_streamID)
  {
        case STGTPPad::pad_stream_header:
           current_stream_head_nbits = STGTPPad::size_v3;
           break;
        case STGTPSegments::merge_stream_header:
           current_stream_head_nbits = STGTPSegments::size_v3;
           break;
        case STGTPMMData::mm_stream_header:
           current_stream_head_nbits = STGTPMMData::size_v3;
           break;
        default:
           break;
  }
 
  if (current_stream_head_nbits == 0 )
  {
      throw std::runtime_error( "Corrupted message - sTGC stream has an unrecognized stream header");
  } 
  
  if (readPointer +  total_expected_size > endOfData)
  {
     throw std::runtime_error("Corrupted message - sTGC expected size goes beyond the end of data");
  }
 
  current_stream_head_nwords = (stream_head_nwords == 0) ? 0 : total_expected_size / current_stream_head_nbits;
  size_t data_size = std::ceil(total_expected_size / felix_word_size);
 
  // in version 3 nbits correspond to either 16 or 32 bits. There is a stable packet size that we use and 
  // we extract it from the code. The 16 or 32 bits is a consequence of an optimization in the firmware that 
  // results in big gains wrt routing and resources
  m_stream_head_nbits.push_back(current_stream_head_nbits); 
  m_stream_head_nwords.push_back(current_stream_head_nwords);
  m_stream_head_fifo_size.push_back(current_stream_head_fifo_size);
  m_stream_head_streamID.push_back(current_stream_head_streamID);
 
   
 
  ERS_DEBUG(2, Muon::nsw::format("stream_head_nbits: {}", current_stream_head_nbits));
  ERS_DEBUG(2, Muon::nsw::format("stream_head_nwords: {}", current_stream_head_nwords));
  ERS_DEBUG(2, Muon::nsw::format("stream_head_fifo_size: {}", current_stream_head_fifo_size));
  ERS_DEBUG(2, Muon::nsw::format("stream_head_streamID: {}", current_stream_head_streamID));
  ERS_DEBUG(2, Muon::nsw::format("total_expected_size: {}", total_expected_size));
  ERS_DEBUG(2, Muon::nsw::format("m_wordCountFlx: {}, ceil(readPointer/{}): {}", m_wordCountFlx,felix_word_size,
                           ceil(readPointer / felix_word_size)));
 
 
  return {current_stream_head_nbits, current_stream_head_nwords, current_stream_head_fifo_size,
          current_stream_head_streamID,        total_expected_size,        data_size};
} 

decode_data_payload()

std::vector< std::vector< std::uint32_t > > Muon::nsw::NSWTriggerSTGL1AElink::decode_data_payload ( std::size_t &  readPointer, const DataHeader &  header, int  version  ) const

private

Decode the payload of each data segment.

Contains actual data from pad or segments

Parameters

readPointer	Current read pointer position (updated by function)
header	Information from data header

Returns

DataHeader Information from header

Definition at line 303 of file NSWTriggerSTGL1AElink.cxx.

                                                                         {
  std::vector<std::vector<std::uint32_t>> current_stream_data{};
 
  if (version >= 3)
     return decode_data_payload_v3( readPointer,  header,  version);
  size_t word_size = WORD_SIZE; 
  for (std::size_t i = 0; i < header.nwords; ++i) {
    std::vector<std::uint32_t> data{};
    for (std::size_t j = 0; j < header.data_size; ++j) {
      data.push_back(decode(readPointer, word_size));
    }
    current_stream_data.push_back(std::move(data));
  }
  return current_stream_data;
 
}

decode_data_payload_v3()

std::vector< std::vector< std::uint32_t > > Muon::nsw::NSWTriggerSTGL1AElink::decode_data_payload_v3 ( std::size_t &  readPointer, const DataHeader &  header, int  version  ) const

private

Definition at line 284 of file NSWTriggerSTGL1AElink.cxx.

                                                                         {
    std::vector<std::vector<std::uint32_t>> current_stream_data{};
 
  if (version < 3){
        throw std::invalid_argument("decode_data_header_v3 version should be at least 3");
  }
 
  size_t word_size = WORD_SIZE;
  size_t felix_n_words = (header.nwords == 0 ) ? 0 : std::ceil(header.data_size / header.nwords); // the number of felix words per stream word
  for (std::size_t i = 0; i < header.nwords; ++i) {
    std::vector<std::uint32_t> data{};
    for (std::size_t j = 0; j < felix_n_words; ++j) {
      data.push_back(decode(readPointer, word_size));
    }
    current_stream_data.push_back(std::move(data));
  }
  return current_stream_data;
}

decode_data_v3()

void Muon::nsw::NSWTriggerSTGL1AElink::decode_data_v3 ( std::size_t &  readPointer, int  version  )

private

Definition at line 116 of file NSWTriggerSTGL1AElink.cxx.

                                                                                     {
  
  auto PADDING_BITS_END = std::size_t{16};
 
  
  const auto endOfData = m_wordCountFlx * WORD_SIZE - Muon::nsw::STGTPL1A::size_trailer_CRC - PADDING_BITS_END;
  
  while (readPointer < endOfData) {
    static constexpr auto SIZE_DATA_HEADER = STGTPL1A::size_stream_head_nbits + STGTPL1A::size_stream_head_nwords +
                                             STGTPL1A::size_stream_head_fifo_size + STGTPL1A::size_stream_head_streamID;
    if (readPointer + SIZE_DATA_HEADER > endOfData) {
      throw std::length_error(
                              Muon::nsw::format("Read pointer ({}) would excede memory dedicated to data chunks ({}) while parsing the header (size: {})",
                                                readPointer, endOfData, SIZE_DATA_HEADER));
    }
    const auto header_data = decode_data_header_v3(readPointer, version);
    if (header_data.total_expected_size > m_wordCountFlx * WORD_SIZE    - readPointer + 1) {
      throw std::length_error(Muon::nsw::format("STG TP stream size {} larger than expected packet size {}",
                                          header_data.total_expected_size,
                                          m_wordCountFlx * WORD_SIZE - readPointer + 1));
    }
    if (header_data.nwords * header_data.data_size + readPointer > endOfData) {
      throw std::length_error(Muon::nsw::format("Requested to decode {} bits but only {} bits are remaining",
                                          header_data.nwords * header_data.data_size, endOfData - readPointer));
    }
    m_stream_data.push_back(decode_data_payload_v3(readPointer, header_data, version));
  }
  analyze_data_v3(version);
}

decode_header()

void Muon::nsw::NSWTriggerSTGL1AElink::decode_header ( std::size_t &  readPointer, int &  version  )

private

Decode the header.

Parameters

readPointer

Current read pointer position (updated by function)

Definition at line 30 of file NSWTriggerSTGL1AElink.cxx.

                                                                                     {
 
  // This part is constant for all versions
  m_head_fragID = Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_head_fragID);
  m_head_sectID = Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_head_sectID);
  m_head_EC =     Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_head_EC);
  m_head_flags =  Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_head_flags);
  m_head_BCID =   Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_head_BCID);
  m_head_orbit =  Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_head_orbit);
  m_head_spare =  Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_head_spare);
  m_L1ID =        Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_L1ID);
 
  ERS_DEBUG(2, Muon::nsw::format("\n TP header: \n"
                                 "  fradID: {}\n"
                                 "  sectID: {}\n"
                                 "  EC:     {}\n"
                                 "  flags:  {}\n"
                                 "  BCID:   {}\n"
                                 "  orbit:  {}\n"
                                 "  spare:  {}\n"
                                 "  L1ID:   {}",
                                 m_head_fragID, m_head_sectID, m_head_EC, m_head_flags, m_head_BCID, m_head_orbit, m_head_spare, m_L1ID));
 
  if (version == 1)
  {
      m_l1a_open_BCID =         Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_open_BCID);
      m_l1a_req_BCID =          Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_req_BCID);
      m_l1a_close_BCID =        Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_close_BCID);
      m_l1a_timeout =           Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_timeout); // overflow count
      m_l1a_wdw_matching_engines_usage = 
                                Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_wdw_matching_engines_usage);
      m_l1a_open_BCID_offset =  Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_open_BCID_offset);
      m_l1a_req_BCID_offset =   Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_req_BCID_offset);
      m_l1a_close_BCID_offset = Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_close_BCID_offset);
      m_l1a_timeout_config =    Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_timeout_config);
      
      m_l1a_link_const =        Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_link_const); 
  }
  else
  {
      m_l1a_versionID =         Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_versionID);
      if (m_l1a_versionID == 1)
      {
          version  = 2;
      }
      else if (m_l1a_versionID == 3)
      {
          version = m_l1a_versionID;
      }
      else
      {
           Muon::nsw::NSWTriggerException e ( Muon::nsw::format( "Stgc packet version not existent (corrupted message) expected 3, got ({})", m_l1a_versionID));
          throw e;
 
      }
      m_l1a_local_req_BCID =    Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_local_req_BCID);
      m_l1a_local_rel_BCID =    Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_local_rel_BCID);
      m_l1a_open_BCID =         Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_open_BCID);
      m_l1a_req_BCID =          Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_req_BCID);
      m_l1a_close_BCID =        Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_close_BCID);
      m_l1a_timeout =           Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_timeout);
      m_l1a_open_BCID_offset =  Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_open_BCID_offset);
      m_l1a_req_BCID_offset =   Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_req_BCID_offset);
      m_l1a_close_BCID_offset = Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_close_BCID_offset);
      m_l1a_timeout_config =    Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_timeout_config);
      m_l1a_busy_thr =          Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_busy_thr);
      m_l1a_engine_snapshot =   Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_engine_snapshot);
      m_l1a_link_const =        Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_link_const);
      m_l1a_padding =           Muon::nsw::decode_and_advance<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::size_l1a_padding);
  }
 
}

decode_header_v3()

void Muon::nsw::NSWTriggerSTGL1AElink::decode_header_v3 ( std::size_t &  readPointer, int &  version  )

private

decode_trailer()

void Muon::nsw::NSWTriggerSTGL1AElink::decode_trailer ( std::size_t &  readPointer )

private

Decode the trailer.

Parameters

readPointer

Current read pointer position (updated by function)

Definition at line 321 of file NSWTriggerSTGL1AElink.cxx.

                                                                        {
  // TODO: warning: how the swROD is behaving if the last work is a uint16 only? Just 0-padding?
  m_trailer_CRC = decode(readPointer, Muon::nsw::STGTPL1A::size_trailer_CRC);
}

decode_v3()

std::uint64_t Muon::nsw::NSWTriggerSTGL1AElink::decode_v3 ( std::size_t &  readPointer, std::size_t  size  ) const

private

elinkId()

const std::shared_ptr<Muon::nsw::NSWResourceId>& Muon::nsw::NSWTriggerElink::elinkId ( ) const

inlineinherited

Definition at line 63 of file NSWTriggerElink.h.

{return m_elinkId;};

elinkWord()

uint32_t Muon::nsw::NSWTriggerElink::elinkWord ( ) const

inlineinherited

Definition at line 62 of file NSWTriggerElink.h.

{return m_elinkWord;};

head_BCID()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::head_BCID ( ) const

inline

Definition at line 23 of file NSWTriggerSTGL1AElink.h.

{ return m_head_BCID; };

head_EC()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::head_EC ( ) const

inline

Definition at line 21 of file NSWTriggerSTGL1AElink.h.

{ return m_head_EC; };

head_flags()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::head_flags ( ) const

inline

Definition at line 22 of file NSWTriggerSTGL1AElink.h.

{ return m_head_flags; };

head_fragID()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::head_fragID ( ) const

inline

Definition at line 19 of file NSWTriggerSTGL1AElink.h.

{ return m_head_fragID; };

head_orbit()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::head_orbit ( ) const

inline

Definition at line 24 of file NSWTriggerSTGL1AElink.h.

{ return m_head_orbit; };

head_overflowCount()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::head_overflowCount ( ) const

inline

Definition at line 35 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_timeout;}; // compatibility version 1

head_sectID()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::head_sectID ( ) const

inline

Definition at line 20 of file NSWTriggerSTGL1AElink.h.

{ return m_head_sectID; };

head_spare()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::head_spare ( ) const

inline

Definition at line 25 of file NSWTriggerSTGL1AElink.h.

{ return m_head_spare; };

head_wdw_matching_engines_usage()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::head_wdw_matching_engines_usage ( ) const

inline

Definition at line 45 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_wdw_matching_engines_usage; };

l1a_busy_thr()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_busy_thr ( ) const

inline

Definition at line 40 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_busy_thr;};

l1a_close_BCID()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_close_BCID ( ) const

inline

Definition at line 33 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_close_BCID;};

l1a_close_BCID_offset()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_close_BCID_offset ( ) const

inline

Definition at line 38 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_close_BCID_offset;};

l1a_engine_snapshot()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_engine_snapshot ( ) const

inline

Definition at line 41 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_engine_snapshot;};

l1a_link_const()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_link_const ( ) const

inline

Definition at line 42 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_link_const;};

l1a_local_rel_BCID()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_local_rel_BCID ( ) const

inline

Definition at line 30 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_local_rel_BCID;};

l1a_local_req_BCID()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_local_req_BCID ( ) const

inline

Definition at line 29 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_local_req_BCID;};

l1a_open_BCID()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_open_BCID ( ) const

inline

Definition at line 31 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_open_BCID;};

l1a_open_BCID_offset()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_open_BCID_offset ( ) const

inline

Definition at line 36 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_open_BCID_offset;};

l1a_padding()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_padding ( ) const

inline

Definition at line 43 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_padding;};

l1a_req_BCID()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_req_BCID ( ) const

inline

Definition at line 32 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_req_BCID;};

l1a_req_BCID_offset()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_req_BCID_offset ( ) const

inline

Definition at line 37 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_req_BCID_offset;};

l1a_timeout()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_timeout ( ) const

inline

Definition at line 34 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_timeout;};

l1a_timeout_config()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_timeout_config ( ) const

inline

Definition at line 39 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_timeout_config;};

l1a_versionID()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::l1a_versionID ( ) const

inline

Definition at line 28 of file NSWTriggerSTGL1AElink.h.

{return m_l1a_versionID;};

L1ID()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::L1ID ( ) const

inline

Definition at line 26 of file NSWTriggerSTGL1AElink.h.

{ return m_L1ID; };

mm_packet()

const std::vector<STGTPMMPacket>& Muon::nsw::NSWTriggerSTGL1AElink::mm_packet ( ) const

inline

Definition at line 56 of file NSWTriggerSTGL1AElink.h.

{ return m_mm_packets; };

nwords()

unsigned int Muon::nsw::NSWTriggerElink::nwords ( ) const

inlineinherited

Definition at line 55 of file NSWTriggerElink.h.

{return m_wordCount;}; //self counted or expected in case it will be possible 

nwordsFlx()

unsigned int Muon::nsw::NSWTriggerElink::nwordsFlx ( ) const

inlineinherited

Definition at line 56 of file NSWTriggerElink.h.

{return m_wordCountFlx;}; //reading from packet felix header

pad_packets()

const std::vector<STGTPPadPacket>& Muon::nsw::NSWTriggerSTGL1AElink::pad_packets ( ) const

inline

Definition at line 54 of file NSWTriggerSTGL1AElink.h.

{ return m_pad_packets; };

parse_version_workaround()

int Muon::nsw::NSWTriggerSTGL1AElink::parse_version_workaround ( std::size_t &  readPointer )

private

parse version workaround

Parameters

std::size_t&

readPointer

Returns

version

Definition at line 103 of file NSWTriggerSTGL1AElink.cxx.

{
   auto anchor_value = Muon::nsw::STGTPL1A::version1_anchor_value;
   auto anchor = Muon::nsw::decode_at_loc<uint64_t>(m_data, readPointer, Muon::nsw::STGTPL1A::loc_version1_anchor, Muon::nsw::STGTPL1A::size_l1a_link_const);
   
   if (anchor == anchor_value)
   {
      return 1;
   }
 
   return -1;
}

segment_packet()

const std::vector<STGTPSegmentPacket>& Muon::nsw::NSWTriggerSTGL1AElink::segment_packet ( ) const

inline

Definition at line 55 of file NSWTriggerSTGL1AElink.h.

{ return m_segment_packets; };

status()

unsigned int Muon::nsw::NSWTriggerElink::status ( ) const

inlineinherited

Definition at line 57 of file NSWTriggerElink.h.

{return m_packet_status;}; //felix status

stream_data()

const std::vector<std::vector<std::vector<std::uint32_t> > >& Muon::nsw::NSWTriggerSTGL1AElink::stream_data ( ) const

inline

Definition at line 51 of file NSWTriggerSTGL1AElink.h.

{ return m_stream_data; };

stream_head_fifo_size()

const std::vector<std::uint32_t>& Muon::nsw::NSWTriggerSTGL1AElink::stream_head_fifo_size ( ) const

inline

Definition at line 49 of file NSWTriggerSTGL1AElink.h.

{ return m_stream_head_fifo_size; };

stream_head_nbits()

const std::vector<std::uint32_t>& Muon::nsw::NSWTriggerSTGL1AElink::stream_head_nbits ( ) const

inline

Definition at line 47 of file NSWTriggerSTGL1AElink.h.

{ return m_stream_head_nbits; };

stream_head_nwords()

const std::vector<std::uint32_t>& Muon::nsw::NSWTriggerSTGL1AElink::stream_head_nwords ( ) const

inline

Definition at line 48 of file NSWTriggerSTGL1AElink.h.

{ return m_stream_head_nwords; };

stream_head_streamID()

const std::vector<std::uint32_t>& Muon::nsw::NSWTriggerSTGL1AElink::stream_head_streamID ( ) const

inline

Definition at line 50 of file NSWTriggerSTGL1AElink.h.

{ return m_stream_head_streamID; };

strip_packet()

const std::vector<STGTPStripPacket>& Muon::nsw::NSWTriggerSTGL1AElink::strip_packet ( ) const

inline

Definition at line 57 of file NSWTriggerSTGL1AElink.h.

{ return m_strip_packets; };

suspect()

bool Muon::nsw::NSWTriggerElink::suspect ( ) const

inlineinherited

Definition at line 58 of file NSWTriggerElink.h.

{return m_packet_sus;}; //elink decoded but with triggering suspects

trailer_CRC()

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::trailer_CRC ( ) const

inline

Definition at line 52 of file NSWTriggerSTGL1AElink.h.

{ return m_trailer_CRC; };

Member Data Documentation

m_data

std::span<const std::uint32_t> Muon::nsw::NSWTriggerSTGL1AElink::m_data

private

Definition at line 145 of file NSWTriggerSTGL1AElink.h.

m_elinkId

std::shared_ptr<Muon::nsw::NSWResourceId> Muon::nsw::NSWTriggerElink::m_elinkId

protectedinherited

Definition at line 73 of file NSWTriggerElink.h.

m_elinkWord

uint32_t Muon::nsw::NSWTriggerElink::m_elinkWord {}

protectedinherited

Definition at line 72 of file NSWTriggerElink.h.

m_head_BCID

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_head_BCID {}

private

Definition at line 153 of file NSWTriggerSTGL1AElink.h.

m_head_EC

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_head_EC {}

private

Definition at line 151 of file NSWTriggerSTGL1AElink.h.

m_head_flags

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_head_flags {}

private

Definition at line 152 of file NSWTriggerSTGL1AElink.h.

m_head_fragID

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_head_fragID {}

private

Definition at line 149 of file NSWTriggerSTGL1AElink.h.

m_head_orbit

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_head_orbit {}

private

Definition at line 154 of file NSWTriggerSTGL1AElink.h.

m_head_sectID

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_head_sectID {}

private

Definition at line 150 of file NSWTriggerSTGL1AElink.h.

m_head_spare

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_head_spare {}

private

Definition at line 155 of file NSWTriggerSTGL1AElink.h.

m_l1a_busy_thr

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_busy_thr {}

private

Definition at line 171 of file NSWTriggerSTGL1AElink.h.

m_l1a_close_BCID

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_close_BCID {}

private

Definition at line 165 of file NSWTriggerSTGL1AElink.h.

m_l1a_close_BCID_offset

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_close_BCID_offset {}

private

Definition at line 169 of file NSWTriggerSTGL1AElink.h.

m_l1a_engine_snapshot

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_engine_snapshot {}

private

Definition at line 172 of file NSWTriggerSTGL1AElink.h.

m_l1a_link_const

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_link_const {}

private

Definition at line 173 of file NSWTriggerSTGL1AElink.h.

m_l1a_local_rel_BCID

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_local_rel_BCID {}

private

Definition at line 162 of file NSWTriggerSTGL1AElink.h.

m_l1a_local_req_BCID

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_local_req_BCID {}

private

Definition at line 161 of file NSWTriggerSTGL1AElink.h.

m_l1a_open_BCID

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_open_BCID {}

private

Definition at line 163 of file NSWTriggerSTGL1AElink.h.

m_l1a_open_BCID_offset

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_open_BCID_offset {}

private

Definition at line 167 of file NSWTriggerSTGL1AElink.h.

m_l1a_padding

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_padding {}

private

Definition at line 174 of file NSWTriggerSTGL1AElink.h.

m_l1a_req_BCID

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_req_BCID {}

private

Definition at line 164 of file NSWTriggerSTGL1AElink.h.

m_l1a_req_BCID_offset

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_req_BCID_offset {}

private

Definition at line 168 of file NSWTriggerSTGL1AElink.h.

m_l1a_timeout

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_timeout {}

private

Definition at line 166 of file NSWTriggerSTGL1AElink.h.

m_l1a_timeout_config

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_timeout_config {}

private

Definition at line 170 of file NSWTriggerSTGL1AElink.h.

m_l1a_versionID

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_versionID {}

private

Definition at line 160 of file NSWTriggerSTGL1AElink.h.

m_l1a_wdw_matching_engines_usage

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_l1a_wdw_matching_engines_usage {}

private

Definition at line 176 of file NSWTriggerSTGL1AElink.h.

m_L1ID

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_L1ID {}

private

Definition at line 157 of file NSWTriggerSTGL1AElink.h.

m_mm_packets

std::vector<STGTPMMPacket> Muon::nsw::NSWTriggerSTGL1AElink::m_mm_packets

private

Definition at line 190 of file NSWTriggerSTGL1AElink.h.

m_packet_status

unsigned int Muon::nsw::NSWTriggerElink::m_packet_status {}

protectedinherited

Definition at line 68 of file NSWTriggerElink.h.

m_packet_sus

bool Muon::nsw::NSWTriggerElink::m_packet_sus {}

protectedinherited

Definition at line 69 of file NSWTriggerElink.h.

m_packet_version

int Muon::nsw::NSWTriggerSTGL1AElink::m_packet_version

private

Definition at line 193 of file NSWTriggerSTGL1AElink.h.

m_pad_packets

std::vector<STGTPPadPacket> Muon::nsw::NSWTriggerSTGL1AElink::m_pad_packets

private

Definition at line 188 of file NSWTriggerSTGL1AElink.h.

m_segment_packets

std::vector<STGTPSegmentPacket> Muon::nsw::NSWTriggerSTGL1AElink::m_segment_packets

private

Definition at line 189 of file NSWTriggerSTGL1AElink.h.

m_stream_data

std::vector<std::vector<std::vector<std::uint32_t> > > Muon::nsw::NSWTriggerSTGL1AElink::m_stream_data

private

Definition at line 182 of file NSWTriggerSTGL1AElink.h.

m_stream_head_fifo_size

std::vector<std::uint32_t> Muon::nsw::NSWTriggerSTGL1AElink::m_stream_head_fifo_size

private

Definition at line 180 of file NSWTriggerSTGL1AElink.h.

m_stream_head_nbits

std::vector<std::uint32_t> Muon::nsw::NSWTriggerSTGL1AElink::m_stream_head_nbits

private

Definition at line 178 of file NSWTriggerSTGL1AElink.h.

m_stream_head_nwords

std::vector<std::uint32_t> Muon::nsw::NSWTriggerSTGL1AElink::m_stream_head_nwords

private

Definition at line 179 of file NSWTriggerSTGL1AElink.h.

m_stream_head_streamID

std::vector<std::uint32_t> Muon::nsw::NSWTriggerSTGL1AElink::m_stream_head_streamID

private

Definition at line 181 of file NSWTriggerSTGL1AElink.h.

m_strip_packets

std::vector<STGTPStripPacket> Muon::nsw::NSWTriggerSTGL1AElink::m_strip_packets

private

Definition at line 191 of file NSWTriggerSTGL1AElink.h.

m_trailer_CRC

std::uint32_t Muon::nsw::NSWTriggerSTGL1AElink::m_trailer_CRC {}

private

Definition at line 186 of file NSWTriggerSTGL1AElink.h.

m_wordCount

unsigned int Muon::nsw::NSWTriggerElink::m_wordCount {}

protectedinherited

Definition at line 66 of file NSWTriggerElink.h.

m_wordCountFlx

unsigned int Muon::nsw::NSWTriggerElink::m_wordCountFlx {}

protectedinherited

Definition at line 67 of file NSWTriggerElink.h.

WORD_SIZE

constexpr auto Muon::nsw::NSWTriggerSTGL1AElink::WORD_SIZE = sizeof(decltype(m_data)::element_type) * 8

staticconstexprprivate

Definition at line 146 of file NSWTriggerSTGL1AElink.h.

WORD_SIZE_DOUBLE

constexpr auto Muon::nsw::NSWTriggerSTGL1AElink::WORD_SIZE_DOUBLE = static_cast<double>(WORD_SIZE)

staticconstexprprivate

Definition at line 147 of file NSWTriggerSTGL1AElink.h.

---

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

• NSWTriggerSTGL1AElink.h
• NSWTriggerSTGL1AElink.cxx