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

//! Protein charge schemes.

/// Protein charge scheme.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum ProteinScheme {
    /// AMBER ffSB (AMBER ff99SB, ff14SB, ff19SB).
    #[default]
    AmberFFSB,
    /// AMBER ff03.
    AmberFF03,
    /// CHARMM (CHARMM22, CHARMM27, CHARMM22/CMAP, CHARMM36, CHARMM36m).
    Charmm,
}

impl ProteinScheme {
    /// Returns the internal key for this scheme.
    pub(crate) const fn key(self) -> &'static str {
        match self {
            Self::AmberFFSB => "amber-ffsb",
            Self::AmberFF03 => "amber-ff03",
            Self::Charmm => "charmm",
        }
    }

    /// Returns all available schemes.
    pub const fn all() -> &'static [Self] {
        &[Self::AmberFFSB, Self::AmberFF03, Self::Charmm]
    }

    /// Returns the partial charge for an atom in a protein residue.
    ///
    /// # Arguments
    ///
    /// * `pos` - Position of the residue in the chain.
    /// * `residue` - Residue name (e.g., "ALA", "ARG").
    /// * `atom` - Atom name (e.g., "CA", "HB1").
    ///
    /// # Returns
    ///
    /// `Option<f32>` - Partial charge if found, otherwise `None`.
    pub fn charge(self, pos: crate::Position, residue: &str, atom: &str) -> Option<f32> {
        crate::generated::get_protein_charge(self.key(), pos.key(), residue, atom)
    }
}

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

    #[test]
    fn default() {
        assert_eq!(ProteinScheme::default(), ProteinScheme::AmberFFSB);
    }

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

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