Crate alice_protocol_reader

This module contains mainly the InputScanner that reads the input data, and the CdpChunk data structure that wraps the data read from the input. Additionally it contains a helper function spawn_reader that spawns a thread that reads input and sents it to a channel that is returned from the function.

The InputScanner is a generic type that can be instantiated with any type that implements the BufferedReaderWrapper trait. This trait is implemented for the StdInReaderSeeker and the std::io::BufReader types. Allowing the InputScanner to read from both stdin and files, in a convenient and effecient way.

The CdpChunk is a wrapper for the data read from the input, it contains the data and the memory address of the first byte of the data.

Example

First add the alice_protocol_reader crate to your project

$ cargo add alice_protocol_reader

Then use the convenience init_reader()-function to add the appropriate reader (stdin or file) at runtime. Instantiate the InputScanner with the reader and start reading ALICE data.

use alice_protocol_reader::input_scanner::InputScanner;
use alice_protocol_reader::init_reader;
use alice_protocol_reader::rdh::RdhCru;

let reader = init_reader(&Some(test_file_path)).unwrap();

let mut input_scanner = InputScanner::minimal(reader);

let rdh = input_scanner.load_rdh_cru::<RdhCru<u8>>().unwrap();

println!("{rdh:?}");

Example output

RdhCru
        Rdh0 { header_id: 7, header_size: 64, fee_id: 20522, priority_bit: 0, system_id: 32, reserved0: 0 }
        offset_new_packet: 5088
        memory_size: 5088
        link_id: 0
        packet_counter: 0
        cruid_dw: 24
        Rdh1 { bc_reserved0: 0, orbit: 192796021 }
        dataformat_reserved0: 2
        Rdh2 { trigger_type: 27139, pages_counter: 0, stop_bit: 0, reserved0: 0 }
        reserved1: 0
        Rdh3 { detector_field: 0, par_bit: 0, reserved0: 0 }
        reserved2: 0

Customize InputScanner behaviour with a config

Implement the FilterOpt on your own config struct and pass it to the InputScanner to customize its behaviour

use alice_protocol_reader::filter::FilterOpt;

struct MyCfg;

impl FilterOpt for MyCfg {
    fn skip_payload(&self) -> bool {
        // Implement your config rules for determining if you're skipping the payload (only reading `RDH`s)
    }

    fn filter_link(&self) -> Option<u8> {
        // Implement your config rules for setting a link to filter by
    }

    fn filter_fee(&self) -> Option<u16> {
        // Implement your config rules for setting a FEE ID to filter by
    }

    fn filter_its_stave(&self) -> Option<u16> {
        // Implement your config rules for setting an ITS Stave to filter by
    }
}

use alice_protocol_reader::input_scanner::InputScanner;
use alice_protocol_reader::init_reader;
use alice_protocol_reader::rdh::RdhCru;
pub fn main() {
    let reader = init_reader(&Some(test_file_path)).unwrap();

    let mut input_scanner = input_scanner::InputScanner::new(&MyCfg, reader, None); // None: Option<flume::Sender<InputStatType>>

    let rdh = input_scanner.load_cdp::<RdhCru<u8>>();
}

Modules

• bufreader_wrapper
  Wrapper trait for std::io::BufReader, requires that the reader implements std::io::Read and std::io::Seek
• config
  Options for configuring the InputScanner
• data_wrapper
  A convenience vector-like wrapper struct for CDPs. Contains a vector of RDHs, a vector of payloads and a vector of memory positions.
• input_scanner
  Contains the InputScanner & ScanCDP trait, responsible for reading and forwarding input data.
• mem_pos_tracker
  Contains the MemPosTracker struct that aids in tracking the memory position in the input data.
• prelude
  Includes all the basics for working with the ALICE DAQ input module.
• rdh
  This module contains all struct definitions for the words that are used in supported data formats.
• scan_cdp
  Contains the ScanCDP trait for reading CDPs from a file or stdin (readable instance)
• stats
  Contains the InputStatType enum for which kind of statistics are gathered, and the Stats struct for tracking and reporting statistics about the input data.
• stdin_reader
  Wrapper for a reader, implements BufferedReaderWrapper.

Macros

• load_bytes
  Macro to load a given number of bytes from a reader into a byte array buffer, to avoid heap allocation.

Functions

• init_reader
  Initializes the reader based on the input mode (file or stdin) and returns it
• spawn_reader
  Spawns a reader thread that reads CDPs from the input and sends them to a producer channel