grafen 0.9.1

Create graphene and other substrates for use in molecular dynamics simulations.
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

//! Iterate over atoms in components.

use coord::Coord;
use system::{Atom, Residue};

/// The return type for `Iterator` functions.
///
/// Has to be boxed to return a fixed size. `impl Iterator` could be used
/// but it is in nightly, not stable.
pub type AtomIterItem<'a> = Box<Iterator<Item = CurrentAtom<'a>> + 'a>;
//pub type AtomIterItem<'a> = impl Iterator<Item = CurrentAtom<'a>>;

#[derive(Debug, PartialEq)]
/// Information about an atom, ready for output.
pub struct CurrentAtom<'a> {
    /// Relative atom index in the component. 0-indexed.
    pub atom_index: u64,
    /// Relative residue index in the component. 0-indexed.
    pub residue_index: u64,
    /// Current atom type.
    pub atom: &'a Atom,
    /// Current residue type.
    pub residue: &'a Residue,
    /// Atom position, relative to the component origin.
    pub position: Coord,
}

/// An `Iterator` over all the `Atom`s in a component.
///
/// Will yield objects of type `CurrentAtom`.
pub struct AtomIterator<'a> {
    /// Current index of atom in the `Residue`.
    atom_index: usize,
    /// Current index in coordinate list.
    coord_index: usize,
    /// Current absolute atom index in the component.
    atom_count: u64,
    /// A reference to the `Residue` that is yielded.
    residue: Option<&'a Residue>,
    /// Component origin position which is added to the relative atom positions.
    origin: Coord,
    /// List of coordinates to yield.
    coords: &'a [Coord],
}

impl<'a> AtomIterator<'a> {
    /// Construct an `Iterator` by supplying the `Residue`, list of `Coord`s
    /// and origin of a component.
    ///
    /// The `Residue` is given as an (optional) reference to avoid a lot of copies.
    pub fn new(residue: Option<&'a Residue>, coords: &'a [Coord], origin: Coord)
            -> AtomIterator<'a> {
        AtomIterator {
            atom_index: 0,
            coord_index: 0,
            atom_count: 0,
            residue: residue,
            origin,
            coords: &coords,
        }
    }
}

impl<'a> Iterator for AtomIterator<'a> {
    type Item = CurrentAtom<'a>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.coords.get(self.coord_index) {
            Some(&coord) => {
                if let Some(residue) = self.residue {
                    if let Some(atom) = residue.atoms.get(self.atom_index) {
                        let position = atom.position + coord + self.origin;

                        let current = CurrentAtom {
                            atom_index: self.atom_count,
                            residue_index: self.coord_index as u64,
                            atom: &atom,
                            residue: &residue,
                            position,
                        };

                        self.atom_index += 1;
                        self.atom_count += 1;

                        Some(current)

                    } else {
                        self.atom_index = 0;
                        self.coord_index += 1;

                        self.next()
                    }
                } else {
                    None
                }
            },

            None => None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn atom_iterator_yields_correct_values() {
        let atom1 = Atom { code: "A".to_string(), position: Coord::new(0.0, 0.1, 0.2) };
        let atom2 = Atom { code: "B".to_string(), position: Coord::new(0.5, 0.6, 0.7) };
        let residue = Residue {
            code: "RES".to_string(),
            atoms: vec![atom1.clone(), atom2.clone()]
        };

        let coord1 = Coord::new(10.0, 11.0, 12.0);
        let coord2 = Coord::new(20.0, 21.0, 22.0);
        let coords = [coord1.clone(), coord2.clone()];

        let origin = Coord::new(5.0, 6.0, 7.0);

        let mut iter = AtomIterator::new(Some(&residue), &coords, origin);

        // Verify the third atom
        assert!(iter.next().is_some());
        assert!(iter.next().is_some());

        let current = iter.next().unwrap();
        assert_eq!(2, current.atom_index);
        assert_eq!(1, current.residue_index);
        assert_eq!(&atom1, current.atom);
        assert_eq!(&residue, current.residue);
        assert_eq!(atom1.position + coord2 + origin, current.position);

        assert!(iter.next().is_some());
        assert!(iter.next().is_none());
    }

    #[test]
    fn atom_iterator_with_no_residue_is_empty() {
        let coords = [Coord::new(0.0, 0.0, 0.0)];
        let mut iter = AtomIterator::new(None, &coords, Coord::ORIGO);
        assert!(iter.next().is_none());
    }
}