oxyroot 0.1.25

Another attempt to make library reading and writing of `.root` binary files which are commonly used in particle physics
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

mod common;

use anyhow::Result;
use common::TemplateWriter;
use oxyroot::RBuffer;

fn read_int_struct(split_level: i32) -> Result<()> {
    let outdir = format!("/tmp/rust/struct/read_int_struct_split={}", split_level);
    let temp = TemplateWriter::default().with_outdir(outdir)?;

    let macro_content = format!(
        r#"{{
    struct sd_t {{
         Int_t a;   
         Int_t b;   
           
     }};
    sd_t sd;

   TFile *hfile = hfile = TFile::Open("o.root","RECREATE", "", {COMPRESSION});

   TTree *tree = new TTree("T","data for rust tests");
   tree->Branch("v_i",&sd, 3200000, {SPLIT_LEVEL});
   
   for (int i = -10; i < 100000; ++i)
     {{
       sd.a = i;
       sd.b = i*13;
       tree->Fill(); 
     }}   

   tree->Print();
   tree->Write();   
   delete hfile;
}}
"#,
        COMPRESSION = 207,
        SPLIT_LEVEL = split_level
    );

    temp.write_raw_macro(&macro_content)?;
    temp.execute_macro()?;

    #[derive(Debug)]
    struct Sd {
        a: i32,
        b: i32,
    };

    let parse = |r: &mut RBuffer| Sd {
        a: r.read_i32().unwrap(),
        b: r.read_i32().unwrap(),
    };

    let tree = temp.tree()?;
    let mut b = tree.branch("v_i").unwrap().get_basket(parse);

    for i in -10..10 {
        let sd = b.next().unwrap();
        assert_eq!(sd.a, i);
        assert_eq!(sd.b, i * 13);
    }

    while let Some(sd) = b.next() {
        assert_eq!(sd.b, sd.a * 13);
    }

    Ok(())
}

#[test]
fn read_int_struct_split_level_1() -> Result<()> {
    read_int_struct(1)
}

#[test]
fn read_int_struct_split_level_0() -> Result<()> {
    read_int_struct(0)
}

#[test]
fn read_int_struct_split_level_2() -> Result<()> {
    read_int_struct(2)
}