Struct RBCalibrations

pub struct RBCalibrations {
    pub rb_id: u8,
    pub d_v: f32,
    pub timestamp: u32,
    pub serialize_event_data: bool,
    pub v_offsets: [[f32; 1024]; 9],
    pub v_dips: [[f32; 1024]; 9],
    pub v_inc: [[f32; 1024]; 9],
    pub tbin: [[f32; 1024]; 9],
    pub vcal_data: Vec<RBEvent>,
    pub tcal_data: Vec<RBEvent>,
    pub noi_data: Vec<RBEvent>,
}

Fields

rb_id: u8

d_v: f32

timestamp: u32

serialize_event_data: bool

v_offsets: [[f32; 1024]; 9]

v_dips: [[f32; 1024]; 9]

v_inc: [[f32; 1024]; 9]

tbin: [[f32; 1024]; 9]

vcal_data: Vec<RBEvent>

tcal_data: Vec<RBEvent>

noi_data: Vec<RBEvent>

Implementations

impl RBCalibrations

pub const NSKIP: usize = 2usize

pub const SINMAX: usize = 60usize

pub const DVCUT: f32 = 15f32

pub const NOMINALFREQ: f32 = 2f32

pub const CALFREQ: f32 = 0.0250000004f32

pub fn assemble_from_flightcal( fcal_t: RBCalibrationsFlightT, fcal_v: RBCalibrationsFlightV, ) -> Result<Self, CalibrationError>

Re-assemble a RBCalibration from chopped up parts

pub fn emit_flighttcal(&self) -> RBCalibrationsFlightT

Return the timing part of the calibration in a package digestable by the flight computer.

Additonal compression by using f16

pub fn emit_flightvcal(&self) -> RBCalibrationsFlightV

Return the voltage part of the calibration in a package digestable by the flight computer.

Additional compression by using f16

pub fn clean_input_data(&mut self)

Remove events with invalid traces or event fragment bits set

pub fn apply_vcal_constants( &self, adc: &Vec<f32>, channel: usize, stop_cell: usize, ) -> Vec<f32>

pub fn timing_calibration( &self, edge: &Edge, apply_vcal: bool, ) -> Result<Vec<Vec<f32>>, CalibrationError>

Voltage calibration has to be applied

Returns

vec[ch[9], tbin[1024]]

pub fn calibrate(&mut self) -> Result<(), CalibrationError>

Call to the calibration routine, using the set input data

pub fn spike_cleaning( voltages: &mut Vec<Vec<f32>>, stop_cell: u16, ) -> Result<(), WaveformError>

Apply the spike cleaning to all channels

pub fn voltages( &self, channel: usize, stop_cell: usize, adc: &Vec<u16>, waveform: &mut Vec<f32>, )

Apply the voltage calibration to a single channel FIXME - mixing of naming conventions for the channels

FIXME - make it return Result<(), CalibrationError>

Arguments

• channel : Channel id 1-9
• stop_cell : This channels stop cell
• adc : Uncalibrated channel data
• waveform : Pre-allocated array to hold calibrated waveform data.

pub fn nanoseconds( &self, channel: usize, stop_cell: usize, times: &mut Vec<f32>, )

Apply the timing calibration to a single channel

This will allocate the array for the waveform time bins (unit is ns)

Arguments

• channel : Channel id 1-9
• stop_cell : This channels stop cell

pub fn new(rb_id: u8) -> Self

pub fn discard_data(&mut self)

Discard the data to reduce the memory footprint

pub fn from_file( filename: String, discard_data: bool, ) -> Result<Self, SerializationError>

Gets the calibration from a file which has the RBCalibration stored in a TofPacket

E.g. if it was written with TofPacketWriter

pub fn from_txtfile(filename: &Path) -> Self

Load a calibration from an asci file This is deperacted and only kept for compatibility reasons with older data

Arguments:

• filename : human readable textfile with all calibraiton constants

pub fn get_id_from_filename(&mut self, filename: &Path) -> u8

Infer the readoutboard id from the filename

Assuming a certain naming scheme for the filename “rbXX_cal.txt” we extract the readoutboard id

Trait Implementations

impl Clone for RBCalibrations

fn clone(&self) -> RBCalibrations

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RBCalibrations

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

Formats the value using the given formatter.

impl Default for RBCalibrations

fn default() -> Self

Returns the “default value” for a type.

impl Display for RBCalibrations

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

Formats the value using the given formatter.

impl From<&Path> for RBCalibrations

fn from(path: &Path) -> Self

Read an asci text file with calibration constants.

impl From<&RBCalibrations> for TofPacket

fn from(calib: &RBCalibrations) -> Self

Converts to this type from the input type.

impl From<&mut RBCalibrations> for TofPacket

fn from(calib: &mut RBCalibrations) -> Self

Converts to this type from the input type.

impl FromRandom for RBCalibrations

fn from_random() -> Self

impl Packable for RBCalibrations

const PACKET_TYPE: PacketType = PacketType::RBCalibration

fn pack(&self) -> TofPacket

where Self: Serialization,

Wrap myself in a TofPacket

impl PartialEq for RBCalibrations

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

const SIZE: usize = 294_918usize

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

const HEAD: u16 = 43_690u16

const TAIL: u16 = 21_845u16

fn from_bytestream( bytestream: &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_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 StructuralPartialEq for RBCalibrations