fastpasta 1.22.0

CLI for verifying or examining readout data from the ALICE detector.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

//! Struct definition of the custom checks configuration TOML file.
use crate::util::*;
use descriptive_toml_derive::TomlConfig;

/// Struct for the configuration of various expected counters in the data.
#[derive(TomlConfig, Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CustomChecks {
    #[description = "Number of CRU Data Packets expected in the data"]
    #[example = "20, 500532"]
    cdps: Option<u32>,

    #[description = "Number of Physics (PhT) Triggers expected in the data"]
    #[example = "0, 10"]
    triggers_pht: Option<u32>,

    #[description = "Legal Chip ordering for Outer Barrel (ML/OL). Needs to be a list of lists of chip IDs"]
    #[example = "[[0, 1, 2, 3, 4, 5, 6], [8, 9, 10, 11, 12, 13, 14], [1, 2, 3, 4, 5, 6, 7]]"]
    chip_orders_ob: Option<Vec<Vec<u8>>>,

    #[description = "Number of chips expected in the data from Outer Barrel (ML/OL)"]
    #[example = "7"]
    chip_count_ob: Option<u8>,

    // RDH format specification
    #[description = "The RDH version expected in the data"]
    #[example = "7"]
    rdh_version: Option<u8>,
}

impl CustomChecks {
    /// Get the number of CDPS expected in the data, if it is set.
    pub fn cdps(&self) -> Option<u32> {
        self.cdps
    }

    /// Get the number of sent Triggers expected in the data, if it is set.
    pub fn triggers_pht(&self) -> Option<u32> {
        self.triggers_pht
    }

    /// Get the number of chips expected in the data from Outer Barrel (ML/OL), if it is set.
    pub fn chip_count_ob(&self) -> Option<u8> {
        self.chip_count_ob
    }

    /// Get the expected RDH version, if it is set.
    pub fn rdh_version(&self) -> Option<u8> {
        self.rdh_version
    }

    /// Get the chip orders expected in the data, if it is set.
    ///
    /// Returns a slice over the valid orderings, representing the legal chip orders for the Outer Barrel (ML/OL).
    pub fn chip_orders_ob(&self) -> Option<&[Vec<u8>]> {
        self.chip_orders_ob.as_deref()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq;
    use temp_dir::TempDir;

    #[test]
    fn test_serde_consistency() {
        let custom_checks = CustomChecks {
            cdps: Some(10),
            triggers_pht: Some(0),
            chip_orders_ob: Some(vec![
                vec![0, 1, 2, 3, 4, 5, 6],
                vec![8, 9, 10, 11, 12, 13, 14],
            ]),
            chip_count_ob: Some(7),
            rdh_version: Some(7),
        };

        let toml = custom_checks.to_string_pretty_toml();

        let custom_checks_deserde: CustomChecks =
            toml::from_str(&toml).expect("Failed to parse TOML");

        assert_eq!(custom_checks_deserde, custom_checks);
    }

    #[test]
    fn test_serialize_custom_checks() {
        let custom_checks = CustomChecks::default();
        let custom_checks_toml = custom_checks.to_string_pretty_toml();
        println!(
            "==== TOML ====\n{}\n==== End of TOML ====",
            custom_checks_toml
        );
        assert_eq!(
            custom_checks_toml,
            r#"# Number of CRU Data Packets expected in the data
# Example: 20, 500532
#cdps = None [ u32 ] # (Uncomment and set to enable)

# Number of Physics (PhT) Triggers expected in the data
# Example: 0, 10
#triggers_pht = None [ u32 ] # (Uncomment and set to enable)

# Legal Chip ordering for Outer Barrel (ML/OL). Needs to be a list of lists of chip IDs
# Example: [[0, 1, 2, 3, 4, 5, 6], [8, 9, 10, 11, 12, 13, 14], [1, 2, 3, 4, 5, 6, 7]]
#chip_orders_ob = None [ Vec < Vec < u8 > > ] # (Uncomment and set to enable)

# Number of chips expected in the data from Outer Barrel (ML/OL)
# Example: 7
#chip_count_ob = None [ u8 ] # (Uncomment and set to enable)

# The RDH version expected in the data
# Example: 7
#rdh_version = None [ u8 ] # (Uncomment and set to enable)

"#
        );
    }

    #[test]
    fn test_deserialize_counters_default() {
        let custom_checks_toml = r#"
# Number of CRU Data Packets expected in the data
# Example: 20, 500532
#cdps = None [ u32 ] # (Uncomment and set to enable)

# Number of Physics (PhT) Triggers expected in the data
# Example: 0, 10
#triggers_pht = None [ u32 ] # (Uncomment and set to enable)

# Legal Chip ordering for Outer Barrel (ML/OL). Needs to be a list of lists of chip IDs
# Example: [[0, 1, 2, 3, 4, 5, 6], [8, 9, 10, 11, 12, 13, 14], [1, 2, 3, 4, 5, 6, 7]]
#chip_orders_ob = None [ Vec < Vec < u8 > > ] # (Uncomment and set to enable)

# The RDH version expected in the data
# Example: 7
#rdh_version = None [ u8 ] # (Uncomment and set to enable)
"#;
        let custom_checks: CustomChecks = toml::from_str(custom_checks_toml).unwrap();
        assert_eq!(custom_checks, CustomChecks::default());
    }

    #[test]
    fn test_deserialize_counters_some_values() {
        let counters_toml = r#"
# Number of CRU Data Packets expected in the data
# Example: 20, 500532
cdps = 10

# Number of Physics (PhT) Triggers expected in the data
# Example: 0, 10
triggers_pht = 0

# Legal Chip ordering for Outer Barrel (ML/OL). Needs to be a list of lists of chip IDs
# Example: [[0, 1, 2, 3, 4, 5, 6], [8, 9, 10, 11, 12, 13, 14], [1, 2, 3, 4, 5, 6, 7]]
chip_orders_ob = [[0, 1, 2, 3, 4, 5, 6], [8, 9, 10, 11, 12, 13, 14]]

chip_count_ob = 7

rdh_version = 6

"#;
        let custom_checks: CustomChecks = toml::from_str(counters_toml).unwrap();
        println!("custom checks: {:?}", custom_checks);
        assert_eq!(
            custom_checks,
            CustomChecks {
                cdps: Some(10),
                triggers_pht: Some(0),
                chip_orders_ob: Some(vec![
                    vec![0, 1, 2, 3, 4, 5, 6],
                    vec![8, 9, 10, 11, 12, 13, 14]
                ]),
                chip_count_ob: Some(7),
                rdh_version: Some(6)
            }
        );
    }

    #[test]
    fn test_write_toml_to_file() {
        let counters = CustomChecks::default();
        let toml = counters.to_string_pretty_toml();

        let tmp_dir = TempDir::new().unwrap();
        let toml_file = tmp_dir.child("counters.toml");
        fs::write(&toml_file, &toml).unwrap();

        assert_eq!(fs::read_to_string(toml_file).unwrap(), toml);
    }

    #[test]
    fn test_read_toml_from_file() {
        let counters = CustomChecks::default();
        let toml = counters.to_string_pretty_toml();
        println!("toml string:\n{toml}");
        let tmp_dir = TempDir::new().unwrap();
        let toml_file = tmp_dir.child("counters.toml");
        fs::write(&toml_file, &toml).unwrap();
        let toml_deserde = fs::read_to_string(toml_file).expect("Failed to read TOML file");
        let custom_checks_from_toml: CustomChecks =
            toml::from_str(&toml_deserde).expect("Failed to parse TOML");

        println!("Struct from toml file: {custom_checks_from_toml:?}");
        assert_eq!(custom_checks_from_toml.cdps(), None);
        assert_eq!(custom_checks_from_toml.triggers_pht(), None);
    }
}