Struct TofHit

pub struct TofHit {

    pub paddle_id: u8,
    pub time_a: f16,
    pub time_b: f16,
    pub peak_a: f16,
    pub peak_b: f16,
    pub charge_a: f16,
    pub charge_b: f16,
    pub paddle_len: f32,
    pub cable_len: f32,
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub coax_cable_time: f32,
    pub hart_cable_time: f32,
    pub event_t0: f32,
    pub timestamp32: u32,
    pub timestamp16: u16,
    pub ctr_etx: u8,
    pub charge_min_i: u16,
    pub pos_across: u16,
    pub t0: u16,
    pub reserved: u8,
    pub version: ProtocolVersion,
    pub baseline_a: f16,
    pub baseline_a_rms: f16,
    pub baseline_b: f16,
    pub baseline_b_rms: f16,
    pub phase: f16,
    pub valid: bool,
    pub ftime_a: f32,
    pub ftime_b: f32,
    pub fpeak_a: f32,
    pub fpeak_b: f32,
}

Comprehensive paddle information

Results of the (online) waveform analysis

A and B are the different ends of the paddle

Fields

paddle_id: u8

The ID of the paddle in TOF notation (1-160)

time_a: f16

time_b: f16

peak_a: f16

peak_b: f16

charge_a: f16

charge_b: f16

paddle_len: f32

The paddle length will not get serialized and has to be set after the hit has been created

cable_len: f32

The Harting cable length to the RB will not get serialized and has to be set after the hit has been created

x: f32

The coordinates will not get serialized and has to be set after the hit has been created

y: f32

z: f32

coax_cable_time: f32

cable times will get populated from the db

hart_cable_time: f32

event_t0: f32

normalized t0, where we have the phase difference limited to -pi/2 -> pi/2

timestamp32: u32

timestamp16: u16

ctr_etx: u8

charge_min_i: u16

pos_across: u16

DEPRECATED Reconstructed particle interaction position across the paddle

t0: u16

DEPRECATED Reconstructed particle interaction time

reserved: u8

version: ProtocolVersion

baseline_a: f16

baseline_a_rms: f16

baseline_b: f16

baseline_b_rms: f16

phase: f16

valid: bool

ftime_a: f32

ftime_b: f32

fpeak_a: f32

fpeak_b: f32

Implementations

impl TofHit

pub fn new() -> Self

pub fn set_paddle(&mut self, paddle: &Paddle)

pub fn get_pid(paddle_end_id: u16) -> u8

Get the (official) paddle id

Convert the paddle end id following the convention

A-side : paddle id + 1000 B-side : paddle id + 2000

FIXME - maybe return Result?

pub fn add_peak(&mut self, peak: &Peak)

pub fn get_pos(&self) -> f32

Calculate the position across the paddle from the two times at the paddle ends

This will be measured from the A side

Just to be extra clear, this assumes the two sets of cables for each paddle end have the same length

pub fn obeys_causality(&self) -> bool

If the two reconstructed pulse times are not related to each other by the paddle length, meaning that they can’t be caused by the same event, we dub this hit as “not following causality”

pub fn get_cable_delay(&self) -> f32

Get the cable correction time

pub fn get_phase_delay(&self) -> f32

Get the delay relative to other readoutboards based on the channel9 sine wave

pub fn get_phase_rollovers(&self) -> i16

pub fn get_t0(&self) -> f32

That this works, the length of the paddle has to be set before (in mm). This assumes that the cable on both sides of the paddle are the same length

pub fn get_t0_uncorrected(&self) -> f32

Calculate the interaction time based on the peak timings measured at the paddle ends A and B

This does not correct for any cable length or ch9 phase shift

pub fn get_edep(&self) -> f32

Philip’s energy deposition based on peak height

pub fn get_time_a(&self) -> f32

pub fn set_time_a(&mut self, t: f32)

pub fn get_time_b(&self) -> f32

pub fn set_time_b(&mut self, t: f32)

pub fn get_peak_a(&self) -> f32

pub fn set_peak_a(&mut self, p: f32)

pub fn get_peak_b(&self) -> f32

pub fn set_peak_b(&mut self, p: f32)

pub fn get_charge_a(&self) -> f32

pub fn set_charge_a(&mut self, c: f32)

pub fn get_charge_b(&self) -> f32

pub fn set_charge_b(&mut self, c: f32)

pub fn get_bl_a(&self) -> f32

pub fn get_bl_b(&self) -> f32

pub fn get_bl_a_rms(&self) -> f32

pub fn get_bl_b_rms(&self) -> f32

pub fn from_random() -> TofHit

Trait Implementations

impl Clone for TofHit

fn clone(&self) -> TofHit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TofHit

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

Formats the value using the given formatter.

impl Default for TofHit

fn default() -> Self

Returns the “default value” for a type.

impl Display for TofHit

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

Formats the value using the given formatter.

impl PartialEq for TofHit

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

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

Serialize the packet

Not all fields will get serialized, only the relevant data for the flight computer **A note about protocol versions ** When we serialize (to_bytestream) we will always write the latest version. Deserialization can also read previous versions

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

Deserialization

Arguments:

• bytestream :

const HEAD: u16 = 61_680u16

const TAIL: u16 = 3_855u16

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 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_tofpacket(packet: &TofPacket) -> Result<Self, SerializationError>

where Self: Sized,

Decode a serializable directly from a TofPacket

fn from_slice( _slice: &[u8], _start_pos: usize, ) -> Result<Self, SerializationError>

where Self: Sized,

fn to_slice(&self) -> &[u8]

where Self: Sized,

Construct byte slice out of self.

impl Copy for TofHit

impl StructuralPartialEq for TofHit