Struct RBEventHeader

pub struct RBEventHeader {

    pub rb_id: u8,
    pub event_id: u32,
    pub stop_cell: u16,
    pub pid_ch12: u8,
    pub pid_ch34: u8,
    pub pid_ch56: u8,
    pub pid_ch78: u8,
    pub pid_ch_order: u8,
    pub rsvd1: u8,
    pub rsvd2: u8,
    pub rsvd3: u8,
    pub fpga_temp: u16,
    pub drs_deadtime: u16,
    pub timestamp32: u32,
    pub timestamp16: u16,
    pub deadtime_instead_temp: bool,
    pub status_byte: u8,
    pub channel_mask: u16,
}

The RBEvent header gets generated once per event per RB. Contains information about event id, timestamps, etc.

Fields

rb_id: u8

Readoutboard ID - should be in the range 1-50 not consecutive, there are some missing. In general, we have 40 boards

event_id: u32

The event ID as sent from the MTB or self-generated if not latched to the MTB

stop_cell: u16

The DRS stop cell. This is vital information which is needed for the calibration

pid_ch12: u8

RBPaddleID - component

pid_ch34: u8

RBPaddleID - component

pid_ch56: u8

RBPaddleID - component

pid_ch78: u8

RBPaddleID - component

pid_ch_order: u8

RBPaddleID - component

rsvd1: u8

Reserved

rsvd2: u8

Reserved

rsvd3: u8

Reserved

fpga_temp: u16

The adc value for the temperature of the FPGA

drs_deadtime: u16

DRS deadtime as read out from the register

timestamp32: u32

timestamp16: u16

deadtime_instead_temp: bool

Store the drs_deadtime instead of the fpga temperature

status_byte: u8

The status byte contains information about lsos of lock and event fragments and needs to be decoded

channel_mask: u16

The channel mask is 9bit for the 9 channels. This leaves 7 bits of space so we actually hijack that for the version information

Bit 15 will be set 1 in case we are sending the DRS_DEADTIME instead of FPGA TEMP

FIXME - make this proper and use ProtocolVersion instead

Implementations

impl RBEventHeader

pub fn new() -> Self

pub fn set_channel_mask(&mut self, channel_mask: u16)

Set the channel mask with the 9bit number

Set bit 15 to either 1 or 0 depending on deadtime_instead_temp

pub fn get_channel_mask(&self) -> u16

Just return the channel mask and strip of the part which contains the information about drs deadtime or fpga temp

pub fn parse_channel_mask(ch_mask: u16) -> (bool, u16)

Get the channel mask from a bytestream.

This takes into acount that bit 15 is used to convey information about if we stored the drs temperature or deadtime

pub fn extract_eventid_from_rbheader(stream: &Vec<u8>) -> u32

Only get the eventid from a binary stream

pub fn is_event_fragment(&self) -> bool

pub fn drs_lost_trigger(&self) -> bool

pub fn lost_lock(&self) -> bool

pub fn lost_lock_last_sec(&self) -> bool

pub fn is_locked(&self) -> bool

pub fn is_locked_last_sec(&self) -> bool

pub fn parse_status(&mut self, status_bytes: u16)

extract lock, drs busy and fpga temp from status field

pub fn get_fpga_temp(&self) -> f32

Get the temperature value (Celsius) from the fpga_temp adc.

pub fn has_ch9(&self) -> bool

Check if the channel 9 is present in the channel mask

pub fn get_rbpaddleid(&self) -> RBPaddleID

pub fn set_rbpaddleid(&mut self, pid: &RBPaddleID)

pub fn get_channels(&self) -> Vec<u8>

Decode the channel mask into channel ids.

The channel ids inside the memory representation of the RB Event data (“blob”) are from 0-7

We keep ch9 seperate.

pub fn get_active_paddles(&self) -> Vec<(u8, bool)>

Get the active paddles

pub fn get_nchan(&self) -> usize

Get the number of data channels + 1 for ch9

pub fn get_timestamp48(&self) -> u64

Trait Implementations

impl Clone for RBEventHeader

fn clone(&self) -> RBEventHeader

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RBEventHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RBEventHeader

fn default() -> Self

Returns the “default value” for a type.

impl Display for RBEventHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for RBEventHeader

fn eq(&self, other: &RBEventHeader) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialization for RBEventHeader

const HEAD: u16 = 43_690u16

Byte marker to mark beginning of payload

const TAIL: u16 = 21_845u16

Byte marker to mark end of payload

const SIZE: usize = 30usize

The SIZE is the size of the serialized bytestream INCLUDING 4 bytes for head and tail bytes. In case the struct does NOT HAVE a fixed size, SIZE will be 0 (so default value of the trait

fn from_bytestream( stream: &Vec<u8>, pos: &mut usize, ) -> Result<Self, SerializationError>

Decode a serializable from a bytestream

fn to_bytestream(&self) -> Vec<u8>

Encode a serializable to a bytestream

fn verify_fixed( stream: &Vec<u8>, pos: &mut usize, ) -> Result<(), SerializationError>

Verify that the serialized representation of the struct has the correct size, including header + footer.

fn from_bytestream_alt( bytestream: &Vec<u8>, pos: &mut usize, ) -> Result<Self, SerializationError>

where Self: Sized,

Decode a serializable from a bytestream. This provides an alternative method to get the packet. If not implemented, it will be the same as from_bytestream.

impl Copy for RBEventHeader

impl StructuralPartialEq for RBEventHeader