Struct RBEvent 

pub struct RBEvent {
    pub data_type: DataType,
    pub status: EventStatus,
    pub header: RBEventHeader,
    pub adc: Vec<Vec<u16>>,
    pub hits: Vec<TofHit>,
    pub creation_time: Option<Instant>,
}

Event data for each individual ReadoutBoard (RB)

Fields

data_type: DataType

status: EventStatus

header: RBEventHeader

adc: Vec<Vec<u16>>

hits: Vec<TofHit>

creation_time: Option<Instant>

Implementations

impl RBEvent

pub fn new() -> Self

pub fn trace_check(&self) -> bool

pub fn has_any_mangling_flag(&self) -> bool

pub fn self_check(&self) -> Result<(), AnalysisError>

Check if we have all the channel data even as indicated by the header

pub fn get_rbwaveforms(&self) -> Vec<RBWaveform>

Deconstruct the RBEvent to form RBWaveforms

pub fn extract_datatype( stream: &Vec<u8>, ) -> Result<DataType, SerializationError>

Get the datatype from a bytestream when we know that it is an RBEvent

The data type is encoded in byte 3

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

decode the len field in the in memroy represention of RBEventMemoryView

pub fn extract_eventid(stream: &Vec<u8>) -> Result<u32, SerializationError>

Get the event id from a RBEvent represented by bytestream without decoding the whole event

This should be faster than decoding the whole event.

pub fn get_ndatachan(&self) -> usize

pub fn get_channel_by_id(&self, ch: usize) -> Result<&Vec<u16>, UserError>

pub fn get_channel_by_label(&self, ch: u8) -> Result<&Vec<u16>, UserError>

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

Similar to the “official” from_bytestream, this will get the event from a bytestream, omitting the waveforms. This will allow for a faster readout in case waveforms are not needed.

Trait Implementations

impl Clone for RBEvent

fn clone(&self) -> RBEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RBEvent

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

Formats the value using the given formatter.

impl Default for RBEvent

fn default() -> Self

Returns the “default value” for a type.

impl Display for RBEvent

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

Formats the value using the given formatter.

impl FromRandom for RBEvent

Available on crate feature random only.

fn from_random() -> Self

impl PartialEq for RBEvent

fn eq(&self, other: &RBEvent) -> 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 RBEvent

const HEAD: u16 = 0xAAAA

Byte marker to mark beginning of payload

const TAIL: u16 = 0x5555

Byte marker to mark end of payload

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

const SIZE: usize = 0

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 guess_size( stream: &Vec<u8>, pos: usize, offset: usize, ) -> Result<(usize, usize, usize), SerializationError>

Guess the size of te packet. This can be a preformance issue if te offset position is far off

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 TofPackable for RBEvent

const TOF_PACKET_TYPE: TofPacketType = TofPacketType::RBEvent

const TOF_PACKET_TYPE_ALT: TofPacketType = TofPacketType::Unknown

fn pack(&self) -> TofPacket

where Self: Serialization,

Wrap myself in a TofPacket

impl StructuralPartialEq for RBEvent