Struct TelemetryEvent 

pub struct TelemetryEvent {
    pub header: TelemetryPacketHeader,
    pub creation_time: u64,
    pub event_id: u32,
    pub tracker_hits: Vec<TrackerHit>,
    pub tracker_oscillators: Vec<u64>,
    pub tof_event: TofEvent,
    pub raw_data: Vec<u8>,
    pub flags0: u8,
    pub flags1: u8,
    pub version: u8,
}

Fields

header: TelemetryPacketHeader

creation_time: u64

event_id: u32

tracker_hits: Vec<TrackerHit>

tracker_oscillators: Vec<u64>

tof_event: TofEvent

raw_data: Vec<u8>

flags0: u8

flags1: u8

version: u8

Implementations

impl TelemetryEvent

pub fn new() -> Self

pub fn dehydrate( &mut self, tof_paddles: &HashMap<u8, TofPaddle>, trk_strips: &HashMap<u32, TrackerStrip>, )

Restore position information from database

pub fn mask_strips(&mut self, masks: &HashMap<u32, TrackerStripMask>)

pub fn apply_signal_cut( &mut self, cut: f32, pedestals: &HashMap<u32, TrackerStripPedestal>, )

Applies a cut based on adc values

pub fn cmn_noise( hit: &TrackerHit, pedestals: &HashMap<u32, TrackerStripPedestal>, cmn_noise: &HashMap<u32, TrackerStripCmnNoise>, ) -> Option<f32>

Calculate the absolute common noise (adc)

pub fn get_trk_energy(adc: f32, tf: &TrackerStripTransferFunction) -> f32

Calculate the energy deposition

pub fn calibrate_tracker( &mut self, remove_cmn_noise: bool, pedestals: &HashMap<u32, TrackerStripPedestal>, transfer_fn: &HashMap<u32, TrackerStripTransferFunction>, cmn_noise: &HashMap<u32, TrackerStripCmnNoise>, )

Trait Implementations

impl Display for TelemetryEvent

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

Formats the value using the given formatter.

impl Serialization for TelemetryEvent

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

Decode a serializable from a bytestream

const HEAD: u16 = 0xAAAA

Byte marker to mark beginning of payload

const TAIL: u16 = 0x5555

Byte marker to mark end of payload

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.

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

Encode a serializable to a bytestream

impl TelemetryPackable for TelemetryEvent

const TEL_PACKET_TYPE: TelemetryPacketType = TelemetryPacketType::Unknown

packet type for any kind of telemetry packet which is NOT an event

const TEL_PACKET_TYPES_EVENT: [TelemetryPacketType; 4] = _

TelemetryEvents can “occupy” several packet types, e.g. GapsTrigger, Boring, etc