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

//! Ion charge schemes.

/// Ion charge scheme.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum IonScheme {
    /// Classic (formal charges).
    #[default]
    Classic,
}

impl IonScheme {
    /// Returns the internal key for this scheme.
    pub(crate) const fn key(self) -> &'static str {
        match self {
            Self::Classic => "classic",
        }
    }

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

    /// Returns the partial charge for an ion residue.
    ///
    /// # Arguments
    ///
    /// * `residue` - Residue name (e.g., "NA", "CL").
    ///
    /// # Returns
    ///
    /// `Option<f32>` - Partial charge if found, otherwise `None`.
    pub fn charge(self, residue: &str) -> Option<f32> {
        crate::generated::get_ion_charge(self.key(), residue)
    }
}

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

    #[test]
    fn default() {
        assert_eq!(IonScheme::default(), IonScheme::Classic);
    }

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

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