ffcharge 0.2.1

A lightweight pure Rust library for fast, residue-based force field charge assignment (AMBER/CHARMM) in molecular modeling pipelines.
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

//! Water charge schemes.

/// Water charge scheme.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum WaterScheme {
    /// TIP3P.
    #[default]
    Tip3p,
    /// TIP3P-FB.
    Tip3pFb,
    /// SPC.
    Spc,
    /// SPC/E.
    SpcE,
    /// OPC3.
    Opc3,
}

impl WaterScheme {
    /// Returns the internal key for this scheme.
    pub(crate) const fn key(self) -> &'static str {
        match self {
            Self::Tip3p => "tip3p",
            Self::Tip3pFb => "tip3p-fb",
            Self::Spc => "spc",
            Self::SpcE => "spc-e",
            Self::Opc3 => "opc3",
        }
    }

    /// Returns all available schemes.
    pub const fn all() -> &'static [Self] {
        &[
            Self::Tip3p,
            Self::Tip3pFb,
            Self::Spc,
            Self::SpcE,
            Self::Opc3,
        ]
    }

    /// Returns the partial charges for a water molecule.
    ///
    /// # Returns
    ///
    /// `Option<crate::WaterCharges>` - Partial charges if found, otherwise `None`.
    pub fn charges(self) -> Option<crate::WaterCharges> {
        crate::generated::get_water_charges(self.key())
    }
}

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

    #[test]
    fn default() {
        assert_eq!(WaterScheme::default(), WaterScheme::Tip3p);
    }

    #[test]
    fn count() {
        assert_eq!(WaterScheme::all().len(), 5);
    }

    #[test]
    fn key_format() {
        for s in WaterScheme::all() {
            let k = s.key();
            assert!(
                k.chars()
                    .all(|c| c.is_ascii_lowercase() || c == '-' || c.is_ascii_digit())
            );
        }
    }
}