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>,
}

DRS4 calibration routine for the TOF readoutboards.

Translate adc per bin to voltage (mV) over time (nanoseconds)

This bascially calibrates the capacitor array of the DRS4 chip and produces a number of calibration constants.

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 = 2

pub const SINMAX: usize = 60

pub const DVCUT: f32 = 15.0

pub const NOMINALFREQ: f32 = 2.0

pub const CALFREQ: f32 = 0.025

pub fn assemble_from_flightcal( fcal_t: RBCalibrationFlightT, fcal_v: RBCalibrationFlightV, ) -> Result<Self, CalibrationError>

Re-assemble a RBCalibration from chopped up parts

pub fn emit_flighttcal(&self) -> RBCalibrationFlightT

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) -> RBCalibrationFlightV

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

pub fn passes_timing_checks(&self) -> bool

Self check if the timing constants are sane

pub fn passes_voltage_checks(&self) -> bool

Self check if the voltage constants are sane

pub fn check(&self) -> bool

Check voltage and timing constants for sanity

for each RB channel take distribution of 1024 calibration constants and confirm

Tcal: average value between 0.48824 and 0.48834 standard deviation between 0.08 and 0.15. Most common problem: avg of tcal distribution is < 0.48824

Vcal1 (offsets): average value between 4200 and 5200 standard deviation less than 150

Vcal2 (droop): average value between -0.5 and 0.5 print out a warning if the standard deviation for any channel is > 5.0 Note that ch1 on any particular board has a more dramatic droop so if ch1 droop is the only channel on the board with this warning, it can be ignored

Vcal3 (gain): average value between 0.06 and 0.07 standard deviation less than 0.00025

Trait Implementations

impl Clone for RBCalibrations

fn clone(&self) -> RBCalibrations

Returns a duplicate 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 FromRandom for RBCalibrations

Available on crate feature random only.

fn from_random() -> Self

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

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 = 0xAAAA

Byte marker to mark beginning of payload

const TAIL: u16 = 0x5555

Byte marker to mark end of payload

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

const TOF_PACKET_TYPE: TofPacketType = TofPacketType::RBCalibration

const TOF_PACKET_TYPE_ALT: TofPacketType = TofPacketType::Unknown

fn pack(&self) -> TofPacket

where Self: Serialization,

Wrap myself in a TofPacket

impl StructuralPartialEq for RBCalibrations