molly 0.6.1

A fast reader and writer for the xtc file format
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

mod common;
use common::trajectories;

// The trajectory for this test is very large so it does not live within the repository. If the
// trajectory is not present, we always pass the test. Discussed in #20.
#[test]
#[ignore = "trajectory file is not present"]
fn read_large_steps() {
    let mut molly_reader = molly::XTCReader::open(trajectories::LARGE_STEP).unwrap();

    let mut buffered_read_frames = Vec::new();
    molly_reader
        .read_frames::<true>(
            &mut buffered_read_frames,
            &molly::selection::FrameSelection::All,
            &molly::selection::AtomSelection::All,
        )
        .expect("Could not read frames using buffered reading.");
    molly_reader
        .home()
        .expect("Could not reset reader to initial position.");

    let mut unbuffered_read_frames = Vec::new();
    molly_reader
        .read_frames::<false>(
            &mut unbuffered_read_frames,
            &molly::selection::FrameSelection::All,
            &molly::selection::AtomSelection::All,
        )
        .expect("Could not read frames using unbuffered reading.");
    molly_reader
        .home()
        .expect("Could not reset reader to initial position.");
    assert_eq!(
        buffered_read_frames, unbuffered_read_frames,
        "the buffered and unbuffered readers should give identical results"
    );
    assert_eq!(buffered_read_frames.len(), 11);
    assert_eq!(unbuffered_read_frames.len(), 11);

    let expected_steps = [
        3000000000, 3000005000, 3000010000, 3000015000, 3000020000, 3000025000, 3000030000,
        3000035000, 3000040000, 3000045000, 3000050000,
    ]
    .into_iter();

    assert!(buffered_read_frames
        .iter()
        .map(|frame| frame.step)
        .eq(expected_steps.clone()));

    assert!(unbuffered_read_frames
        .iter()
        .map(|frame| frame.step)
        .eq(expected_steps));
}

#[test]
fn test_skip_positions() {
    let mut reader = molly::XTCReader::open(trajectories::COB).unwrap();
    let mut frame = molly::Frame::default();
    reader.read_frame(&mut frame).unwrap();
    reader.read_frame(&mut frame).unwrap();
    let step2 = frame.step;

    reader.home().unwrap();

    let header1 = reader.read_header().unwrap();
    reader.skip_positions(&header1).unwrap();
    let header2 = reader.read_header().unwrap();
    assert_eq!(step2, header2.step);
}

#[test]
fn test_skip_to_time() {
    let mut reader = molly::XTCReader::open(trajectories::ADK).unwrap();
    let mut frame = molly::Frame::default();
    reader.read_frame(&mut frame).unwrap();
    reader.read_frame(&mut frame).unwrap();
    reader.read_frame(&mut frame).unwrap();
    let step3 = frame.step;
    let time3 = frame.time;
    println!("{step3} {time3}");

    reader.home().unwrap();

    let header = reader.skip_to_time(time3).unwrap();
    assert_eq!(time3, header.time);
}

#[test]
fn test_skip_frames() {
    let mut reader = molly::XTCReader::open(trajectories::ADK).unwrap();
    let mut frame = molly::Frame::default();
    reader.read_frame(&mut frame).unwrap();
    reader.read_frame(&mut frame).unwrap();
    reader.read_frame(&mut frame).unwrap();
    let step3 = frame.step;
    let time3 = frame.time;
    println!("{step3} {time3}");

    reader.home().unwrap();

    reader.skip_frames(2).unwrap();
    let header = reader.read_header().unwrap();
    assert_eq!(time3, header.time);
}

#[test]
fn test_seek_prev() {
    let mut reader = molly::XTCReader::open(trajectories::ADK).unwrap();
    let mut frame = molly::Frame::default();
    reader.read_frame(&mut frame).unwrap();
    reader.read_frame(&mut frame).unwrap();
    let step2 = frame.step;
    let time2 = frame.time;
    println!("{step2} {time2}");

    let header = reader.seek_prev().unwrap();
    assert_eq!(time2, header.time);
}

#[test]
fn test_read_last() {
    let mut reader = molly::XTCReader::open(trajectories::ADK).unwrap();
    let frames = reader.read_all_frames().unwrap();
    let last_time = frames.last().unwrap().time;

    reader.home().unwrap();

    let mut fr = molly::Frame::default();
    reader.read_last_frame(&mut fr).unwrap();
    assert_eq!(last_time, fr.time);
}