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 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 paddle_len: f32,
    pub timing_offset: f32,
    pub coax_cable_time: f32,
    pub hart_cable_time: f32,
    pub event_t0: f32,
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub valid: bool,
}

An extracted hit from a TofPaddle, as extracted by the online software and provided algorithm (in v0.11 algorithm is provided by J.Zweerink)

A TofHit holds the information for an extracted single hit on a peak, which is defined by a peak in at least one of the two waveforms. The TofHit holds extracted information for both of the waveforms, only if both are available a position reconstruction on the paddle can be attempted.

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

reserved: u8

version: ProtocolVersion

baseline_a: f16

baseline_a_rms: f16

baseline_b: f16

baseline_b_rms: f16

phase: f16

paddle_len: f32

Length of the paddle the hit is on, will get populated from db

timing_offset: f32

(In)famous constant timing offset per paddle

coax_cable_time: f32

hart_cable_time: f32

event_t0: f32

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

x: f32

y: f32

z: f32

valid: bool

Implementations

impl TofHit

pub fn new() -> Self

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

Adds an extracted peak to this TofHit. A peak will be for only a single waveform only, so we have to take care of the A/B sorting by means of PaddleEndId

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

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

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

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

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

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

impl TofHit

pub fn distance(&self, other: &TofHit) -> f32

Calculate the distance to another hit. For this to work, the hit coordinates have had to be determined, so this will only return a propper result after the paddle information is added

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”

impl TofHit

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 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_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_edep_att(&self) -> f32

Elena’s energy deposition including attenuation

pub fn get_time_a(&self) -> f32

Arrival time of the photons at side A

pub fn get_time_b(&self) -> f32

Arrival time of the photons at side B

pub fn get_peak_a(&self) -> f32

pub fn get_peak_b(&self) -> f32

pub fn get_charge_a(&self) -> f32

pub fn get_charge_b(&self) -> 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 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 get_phase_rollovers(&self) -> i16

impl TofHit

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

Trait Implementations

impl Clone for TofHit

fn clone(&self) -> TofHit

Returns a duplicate 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

Byte marker to mark beginning of payload

const TAIL: u16 = 3_855u16

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 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 TofHit

impl StructuralPartialEq for TofHit