molar 1.3.4

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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

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: *mut System,
}

impl<'a> SelParMut<'a> {
    pub(crate) fn new(sys: *mut 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 as *const System
    }
}

// PosMutProvider and AtomMutProvider are implemented directly (not via SysMutProvider)
// so that shared fields (box, bonds, molecules) cannot be mutated during parallel use.
impl PosMutProvider for SelParMut<'_> {
    unsafe fn coords_ptr_mut(&mut self) -> *mut Pos {
        (*self.sys).st.coords.as_mut_ptr()
    }
}
impl AtomMutProvider for SelParMut<'_> {
    unsafe fn atoms_ptr_mut(&mut self) -> *mut Atom {
        (*self.sys).top.atoms.as_mut_ptr()
    }
}
// VelMutProvider and ForceMutProvider are implemented directly (same reason as above).
// VelProvider and ForceProvider are covered by blanket impls via SystemProvider.
impl VelMutProvider for SelParMut<'_> {
    unsafe fn vel_ptr_mut(&mut self) -> *mut Vel {
        let v = &mut (*self.sys).st.velocities;
        if v.is_empty() { std::ptr::null_mut() } else { v.as_mut_ptr() }
    }
}
impl ForceMutProvider for SelParMut<'_> {
    unsafe fn force_ptr_mut(&mut self) -> *mut Force {
        let v = &mut (*self.sys).st.forces;
        if v.is_empty() { std::ptr::null_mut() } else { v.as_mut_ptr() }
    }
}

//============================================================================
/// 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 as *mut System, &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(())
    }
}