Muon::nsw::STGTPMMPacket Class Reference

#include <STGTPPackets.h>

Collaboration diagram for Muon::nsw::STGTPMMPacket:

Classes
struct	MMSegmentData

Public Member Functions
	STGTPMMPacket (const std::vector< std::uint32_t > &payload, const int ver)
virtual	~STGTPMMPacket ()=default
size_t	Size (const int ver)
const std::array< MMSegmentData, STGTPMMData::num_mm > &	Segments () const
const MMSegmentData &	Segment (std::size_t segment) const
std::uint32_t	BCID () const

Private Attributes
std::array< MMSegmentData, STGTPMMData::num_mm >	m_segmentData {}
std::uint32_t	m_BCID {}
std::uint32_t	m_valids {}

Detailed Description

Definition at line 18 of file STGTPPackets.h.

Constructor & Destructor Documentation

STGTPMMPacket()

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

explicit

Definition at line 38 of file STGTPPackets.cxx.

                                                                                     {
 
  if (ver < 3){
     // This section did not exist before v3
     return;
  }
 
  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));
  }
 
  const auto packets = std::span{payload.data(), std::size(payload)};
  auto readPointer = std::size_t{0};
  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);
  };
 
 
  decode(readPointer, Muon::nsw::STGTPMMData::size_v3_padding);
  m_valids = decode(readPointer, Muon::nsw::STGTPMMData::size_output_mm_valids);
  for (std::size_t i = Muon::nsw::STGTPMMData::num_mm; i > 0; --i) {
    const auto index = i - 1;
    uint32_t segment_bit = 1 << index;
    uint32_t valid_segment = (m_valids & segment_bit);
    m_segmentData.at(index).monitor = decode(readPointer, Muon::nsw::STGTPMMData::size_output_mm_monitor);
    m_segmentData.at(index).spare = decode(readPointer, Muon::nsw::STGTPMMData::size_output_mm_spare);
    m_segmentData.at(index).lowRes = decode(readPointer, Muon::nsw::STGTPMMData::size_output_mm_lowRes);
    m_segmentData.at(index).phiRes = decode(readPointer, Muon::nsw::STGTPMMData::size_output_mm_phiRes);
    m_segmentData.at(index).dTheta = decode(readPointer, Muon::nsw::STGTPMMData::size_output_mm_dTheta);
    m_segmentData.at(index).phiID = decode(readPointer, Muon::nsw::STGTPMMData::size_output_mm_phiID);
    m_segmentData.at(index).rIndex = decode(readPointer, Muon::nsw::STGTPMMData::size_output_mm_rIndex);
    if (!valid_segment)
    {
    m_segmentData.at(index).monitor = 0;
    m_segmentData.at(index).spare = 0;
    m_segmentData.at(index).lowRes = 0;
    m_segmentData.at(index).phiRes = 0;
    m_segmentData.at(index).dTheta = Muon::nsw::STGTPMMData::mm_stream_invalid_dTheta; // this is the invalid flag
    m_segmentData.at(index).phiID = 0;
    m_segmentData.at(index).rIndex = 0;
    }
 }
  m_BCID = decode(readPointer, Muon::nsw::STGTPMMData::size_bcid);
 
}

~STGTPMMPacket()

virtual Muon::nsw::STGTPMMPacket::~STGTPMMPacket ( )

virtualdefault

Member Function Documentation

BCID()

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

inlinenodiscard

Definition at line 38 of file STGTPPackets.h.

{ return m_BCID; };

Segment()

const Muon::nsw::STGTPMMPacket::MMSegmentData & Muon::nsw::STGTPMMPacket::Segment ( std::size_t segment ) const

nodiscard

Definition at line 87 of file STGTPPackets.cxx.

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

Segments()

const std::array< MMSegmentData, STGTPMMData::num_mm > & Muon::nsw::STGTPMMPacket::Segments ( ) const

inlinenodiscard

Definition at line 35 of file STGTPPackets.h.

{ return m_segmentData; }

Size()

size_t Muon::nsw::STGTPMMPacket::Size

(

const int

ver

)

Definition at line 19 of file STGTPPackets.cxx.

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

Member Data Documentation

m_BCID

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

private

Definition at line 42 of file STGTPPackets.h.

{};

m_segmentData

std::array<MMSegmentData, STGTPMMData::num_mm> Muon::nsw::STGTPMMPacket::m_segmentData {}

private

Definition at line 41 of file STGTPPackets.h.

{};

m_valids

std::uint32_t Muon::nsw::STGTPMMPacket::m_valids {}

private

Definition at line 43 of file STGTPPackets.h.

{};

---

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

• STGTPPackets.h
• STGTPPackets.cxx