Muon::nsw::STGTPSegmentPacket Class Reference

#include <STGTPPackets.h>

Collaboration diagram for Muon::nsw::STGTPSegmentPacket:

Classes
struct	SegmentData

Public Member Functions
	STGTPSegmentPacket (const std::vector< std::uint32_t > &payload)
virtual	~STGTPSegmentPacket ()=default
std::uint32_t	LUT_ChoiceSelection () const
std::uint32_t	NSW_SegmentSelector () const
std::uint32_t	ValidSegmentSelector () const
const std::array< SegmentData, STGTPSegments::num_segments > &	Segments () const
const SegmentData &	Segment (std::size_t segment) const
std::uint32_t	BCID () const
std::uint32_t	SectorID () const

Private Attributes
std::uint32_t	m_lut_choice {}
std::uint32_t	m_nsw_segment_selector {}
std::uint32_t	m_valid_segment_selector {}
std::array< SegmentData, STGTPSegments::num_segments >	m_segmentData {}
std::uint32_t	m_BCID {}
std::uint32_t	m_sectorID {}

Detailed Description

Definition at line 34 of file STGTPPackets.h.

Constructor & Destructor Documentation

STGTPSegmentPacket()

Muon::nsw::STGTPSegmentPacket::STGTPSegmentPacket ( const std::vector< std::uint32_t > &  payload )

explicit

Definition at line 48 of file STGTPPackets.cxx.

                                                                                {
  static constexpr auto PACKETS_SIZE = std::size_t{8};
  if (std::size(payload) != PACKETS_SIZE) {
    throw std::runtime_error(
                 Muon::nsw::format("Packet vector has size {} instead of expected size {}", std::size(payload), PACKETS_SIZE));
  }
  auto readPointer = std::size_t{0};
  const auto packets = std::span{payload.data(), std::size(payload)};
  auto decode = [&packets](std::size_t& readPointer, const std::size_t size) {
    return decode_and_advance<std::uint64_t, std::uint32_t>(packets, readPointer, size);
  };
 
  m_lut_choice = decode(readPointer, Muon::nsw::STGTPSegments::size_lut_choice_selection);
  m_nsw_segment_selector = decode(readPointer, Muon::nsw::STGTPSegments::size_nsw_segment_selector);
  m_valid_segment_selector = decode(readPointer, Muon::nsw::STGTPSegments::size_valid_segment_selector);
 
  for (std::size_t i = Muon::nsw::STGTPSegments::num_segments; i > 0; --i) {
    const auto index = i - 1;
    m_segmentData.at(index).monitor = decode(readPointer, Muon::nsw::STGTPSegments::size_output_segment_monitor);
    m_segmentData.at(index).spare = decode(readPointer, Muon::nsw::STGTPSegments::size_output_segment_spare);
    m_segmentData.at(index).lowRes = decode(readPointer, Muon::nsw::STGTPSegments::size_output_segment_lowRes);
    m_segmentData.at(index).phiRes = decode(readPointer, Muon::nsw::STGTPSegments::size_output_segment_phiRes);
    m_segmentData.at(index).dTheta = decode(readPointer, Muon::nsw::STGTPSegments::size_output_segment_dTheta);
    m_segmentData.at(index).phiID = decode(readPointer, Muon::nsw::STGTPSegments::size_output_segment_phiID);
    m_segmentData.at(index).rIndex = decode(readPointer, Muon::nsw::STGTPSegments::size_output_segment_rIndex);
  }
 
  m_BCID = decode(readPointer, Muon::nsw::STGTPSegments::size_bcid);
  m_sectorID = decode(readPointer, Muon::nsw::STGTPSegments::size_sectorID);
}

~STGTPSegmentPacket()

virtual Muon::nsw::STGTPSegmentPacket::~STGTPSegmentPacket ( )

virtualdefault

Member Function Documentation

BCID()

std::uint32_t Muon::nsw::STGTPSegmentPacket::BCID ( ) const

inline

Definition at line 56 of file STGTPPackets.h.

{ return m_BCID; };

LUT_ChoiceSelection()

std::uint32_t Muon::nsw::STGTPSegmentPacket::LUT_ChoiceSelection ( ) const

inline

Definition at line 49 of file STGTPPackets.h.

{ return m_lut_choice; }

NSW_SegmentSelector()

std::uint32_t Muon::nsw::STGTPSegmentPacket::NSW_SegmentSelector ( ) const

inline

Definition at line 50 of file STGTPPackets.h.

{ return m_nsw_segment_selector; }

SectorID()

std::uint32_t Muon::nsw::STGTPSegmentPacket::SectorID ( ) const

inline

Definition at line 57 of file STGTPPackets.h.

{ return m_sectorID; }

Segment()

const Muon::nsw::STGTPSegmentPacket::SegmentData & Muon::nsw::STGTPSegmentPacket::Segment

(

std::size_t

segment

)

const

Definition at line 79 of file STGTPPackets.cxx.

                                   {
  if (segment >= STGTPSegments::num_segments) {
    throw std::out_of_range(
                Muon::nsw::format("Requested segment {} which does not exist (max {})", segment, STGTPSegments::num_segments - 1));
  }
  return m_segmentData.at(segment);
}

Segments()

const std::array<SegmentData, STGTPSegments::num_segments>& Muon::nsw::STGTPSegmentPacket::Segments ( ) const

inline

Definition at line 53 of file STGTPPackets.h.

{ return m_segmentData; }

ValidSegmentSelector()

std::uint32_t Muon::nsw::STGTPSegmentPacket::ValidSegmentSelector ( ) const

inline

Definition at line 51 of file STGTPPackets.h.

{ return m_valid_segment_selector; }

Member Data Documentation

m_BCID

std::uint32_t Muon::nsw::STGTPSegmentPacket::m_BCID {}

private

Definition at line 66 of file STGTPPackets.h.

m_lut_choice

std::uint32_t Muon::nsw::STGTPSegmentPacket::m_lut_choice {}

private

Definition at line 60 of file STGTPPackets.h.

m_nsw_segment_selector

std::uint32_t Muon::nsw::STGTPSegmentPacket::m_nsw_segment_selector {}

private

Definition at line 61 of file STGTPPackets.h.

m_sectorID

std::uint32_t Muon::nsw::STGTPSegmentPacket::m_sectorID {}

private

Definition at line 67 of file STGTPPackets.h.

m_segmentData

std::array<SegmentData, STGTPSegments::num_segments> Muon::nsw::STGTPSegmentPacket::m_segmentData {}

private

Definition at line 64 of file STGTPPackets.h.

m_valid_segment_selector

std::uint32_t Muon::nsw::STGTPSegmentPacket::m_valid_segment_selector {}

private

Definition at line 62 of file STGTPPackets.h.

---

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

• STGTPPackets.h
• STGTPPackets.cxx