molar 1.3.1

Molar is a rust library for analysis of MD trajectories and molecular modeling
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

use crate::prelude::*;

//================================================
/// Read-only subsystem for non-blocking parallel access to atoms and posisitons
/// Doesn't have access to shared fields such as box and bonds.
//================================================
pub struct SelPar<'a> {
    index: &'a [usize],
    sys: *const System,
}

impl<'a> SelPar<'a> {
    pub(crate) fn new(sys: &'a System, index: &'a [usize]) -> SelPar<'a> {
        Self {
            index,
            sys,
        }
    }
}

unsafe impl Sync for SelPar<'_> {}
unsafe impl Send for SelPar<'_> {}

impl IndexSliceProvider for SelPar<'_> {
    fn get_index_slice(&self) -> &[usize] {
        self.index
    }
}

impl SystemProvider for SelPar<'_> {
    fn get_system_ptr(&self) -> *const System {
        self.sys
    }
}

//================================================
/// Read-write subsystem for non-blocking parallel access to atoms and posisitons
/// Doesn't have access to shared fields such as box and bonds.
//================================================
pub struct SelParMut<'a> {
    index: &'a [usize],
    sys: *const System,
}

impl<'a> SelParMut<'a> {
    pub(crate) fn new(sys: &'a System, index: &'a [usize]) -> SelParMut<'a> {
        Self {
            index,
            sys,
        }
    }
}

unsafe impl Sync for SelParMut<'_> {}
unsafe impl Send for SelParMut<'_> {}

impl IndexSliceProvider for SelParMut<'_> {
    fn get_index_slice(&self) -> &[usize] {
        self.index
    }
}

impl SystemProvider for SelParMut<'_> {
    fn get_system_ptr(&self) -> *const System {
        self.sys
    }
}

// Mutable access to coords and atoms is allowed
impl AtomPosAnalysisMut for SelParMut<'_> {}
// NonAtomPosAnalysisMut is NOT implemeneted to avoid races!

//============================================================================
/// Collection of non-overlapping selections that could be mutated in parallel
/// Selections don't have access to shared fields such as box and bonds.
//============================================================================
pub struct ParSplit {
    pub(crate) selections: Vec<Sel>,
    pub(crate) max_index: usize,
}

impl ParSplit {
    pub(crate) fn check_bounds(&self, sys: &System) {
        if self.max_index >= sys.len() {
            panic!("max index of ParSplit is out of bounds");
        }
    }

    pub fn get_bound_mut<'a>(&'a self, sys: &'a mut System, i: usize) -> SelParMut<'a> {
        self.check_bounds(sys);
        SelParMut::new(sys, &self.selections[i].0)
    }

    pub fn get_bound<'a>(&'a self, sys: &'a System, i: usize) -> SelPar<'a> {
        self.check_bounds(sys);
        SelPar::new(sys, &self.selections[i].0)
    }

    pub fn into_selections(self) -> Vec<Sel> {
        self.selections
    }
}


#[cfg(test)]
mod tests {
    use rayon::iter::ParallelIterator;

    use crate::prelude::*;

    #[test]
    fn par_unwrap() -> anyhow::Result<()> {
        // Load file
        let mut sys = System::from_file("tests/membr.gro")?;

        // Make a parallel split for each POPG lipid molecule
        let par = sys.split_par(|p| {
            if p.atom.resname == "POPG" {
                // Whenever new distinct result is returned form this closure
                // new selection is created, so each distinct POPG residue
                // becomes a separate selection.
                Some(p.atom.resindex)
            } else {
                // All other atoms are ignored
                None
            }
        })?;

        // Bind split to a system
        sys.iter_par_split_mut(&par) 
            // Run unwrap on each selection in parallel
            .try_for_each(|mut sel| sel.unwrap_simple())?; 
        Ok(())
    }
}