alpha_g_physics 0.1.5

Data analysis library for the ALPHA-g experiment
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

use super::*;
use alpha_g_detector::padwing::{
    map::{TpcPadColumn, TpcPadRow, TPC_PAD_COLUMNS, TPC_PAD_ROWS},
    PWB_MAX, PWB_MIN,
};

fn all_within_limits(run_number: u32) -> bool {
    for row in 0..TPC_PAD_ROWS {
        let row = TpcPadRow::try_from(row).unwrap();
        for column in 0..TPC_PAD_COLUMNS {
            let column = TpcPadColumn::try_from(column).unwrap();
            let pad_position = TpcPadPosition { row, column };

            let baseline = try_pad_baseline(run_number, pad_position);
            if let Ok(baseline) = baseline {
                if !(PWB_MIN..=PWB_MAX).contains(&baseline) {
                    return false;
                }
            }
        }
    }
    true
}

#[test]
fn all_within_limits_in_baseline_map() {
    assert!(all_within_limits(9277));
    assert!(all_within_limits(11084));
    assert!(all_within_limits(u32::MAX));
}

#[test]
fn try_pad_baseline_map_error() {
    // Too slow to run all run numbers on CI. Just check limits.
    for run_number in [0, 9276] {
        for row in 0..TPC_PAD_ROWS {
            let row = TpcPadRow::try_from(row).unwrap();
            for column in 0..TPC_PAD_COLUMNS {
                let column = TpcPadColumn::try_from(column).unwrap();
                let pad_position = TpcPadPosition { row, column };

                assert!(try_pad_baseline(run_number, pad_position).is_err());
            }
        }
    }
}

#[test]
fn try_pad_baseline_correctness_9277() {
    let mut missing = 0;
    for row in 0..TPC_PAD_ROWS {
        let row = TpcPadRow::try_from(row).unwrap();
        for column in 0..TPC_PAD_COLUMNS {
            let column = TpcPadColumn::try_from(column).unwrap();
            let pad_position = TpcPadPosition { row, column };

            let baseline = try_pad_baseline(9277, pad_position);
            if baseline.is_err() {
                missing += 1;
            }
        }
    }
    assert_eq!(missing, 721);

    assert_eq!(
        try_pad_baseline(
            9277,
            TpcPadPosition {
                row: TpcPadRow::try_from(0).unwrap(),
                column: TpcPadColumn::try_from(0).unwrap(),
            }
        )
        .unwrap(),
        1665
    );
    assert_eq!(
        try_pad_baseline(
            9277,
            TpcPadPosition {
                row: TpcPadRow::try_from(429).unwrap(),
                column: TpcPadColumn::try_from(14).unwrap(),
            }
        )
        .unwrap(),
        1729
    );
    assert_eq!(
        try_pad_baseline(
            9277,
            TpcPadPosition {
                row: TpcPadRow::try_from(200).unwrap(),
                column: TpcPadColumn::try_from(5).unwrap(),
            }
        )
        .unwrap(),
        1714
    );
}

#[test]
fn try_pad_baseline_correctness_11084() {
    assert_eq!(
        try_pad_baseline(
            11084,
            TpcPadPosition {
                row: TpcPadRow::try_from(0).unwrap(),
                column: TpcPadColumn::try_from(0).unwrap(),
            }
        )
        .unwrap(),
        1679
    );
}

#[test]
fn try_pad_baseline_correctness_sim() {
    for column in 0..TPC_PAD_COLUMNS {
        let column = TpcPadColumn::try_from(column).unwrap();
        for row in 0..TPC_PAD_ROWS {
            let row = TpcPadRow::try_from(row).unwrap();
            let pad_position = TpcPadPosition { row, column };

            let baseline = try_pad_baseline(u32::MAX, pad_position).unwrap();
            assert_eq!(baseline, 1725);
        }
    }
}