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, const int ver)
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 Member Functions
size_t	Size (const int ver)

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 66 of file STGTPPackets.h.

Constructor & Destructor Documentation

STGTPSegmentPacket()

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

explicit

Definition at line 169 of file STGTPPackets.cxx.

                                                                                                 {
  size_t packet_size_w = Size(ver);
 
  if (std::size(payload) != packet_size_w) {
    throw std::runtime_error(
                 Muon::nsw::format("Packet vector has size {} instead of expected size {}", std::size(payload), packet_size_w));
  }
  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);
  };
 
  if (ver < 3)
  {
     // In the versions prior to version 3, there was a LUT used to merge segments
     // the versions following 3 use an algorithm that simplifies the merge, and hence the 
     // structure of these data changed
     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);
  }
  else
  {
     decode(readPointer, Muon::nsw::STGTPSegments::size_v3_padding);
     m_nsw_segment_selector = decode(readPointer, Muon::nsw::STGTPSegments::size_valid_segment_v3);
     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 88 of file STGTPPackets.h.

{ return m_BCID; };

LUT_ChoiceSelection()

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

inline

Definition at line 81 of file STGTPPackets.h.

{ return m_lut_choice; }

NSW_SegmentSelector()

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

inline

Definition at line 82 of file STGTPPackets.h.

{ return m_nsw_segment_selector; }

SectorID()

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

inline

Definition at line 89 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 216 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 85 of file STGTPPackets.h.

{ return m_segmentData; }

Size()

size_t Muon::nsw::STGTPSegmentPacket::Size ( const int  ver )

private

Definition at line 149 of file STGTPPackets.cxx.

                                                   {
  size_t packet_size_w = 0;
  size_t word_size = 32;
  switch (ver) {
    case 1:
      packet_size_w =  Muon::nsw::STGTPSegments::size_v1 / word_size;;
      break;
    case 2:
      packet_size_w = Muon::nsw::STGTPSegments::size_v2 / word_size;;
      break;
    case 3:
      packet_size_w = Muon::nsw::STGTPSegments::size_v3 / word_size;
      break;
    default:
      packet_size_w = 0;
      break;
  }
  return packet_size_w;
}

ValidSegmentSelector()

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

inline

Definition at line 83 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 98 of file STGTPPackets.h.

m_lut_choice

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

private

Definition at line 92 of file STGTPPackets.h.

m_nsw_segment_selector

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

private

Definition at line 93 of file STGTPPackets.h.

m_sectorID

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

private

Definition at line 99 of file STGTPPackets.h.

m_segmentData

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

private

Definition at line 96 of file STGTPPackets.h.

m_valid_segment_selector

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

private

Definition at line 94 of file STGTPPackets.h.

---

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

• STGTPPackets.h
• STGTPPackets.cxx