refeff-io 0.2.0

FEFF file-format readers and writers (feff.inp, .dat/.bin handoffs, PAD encoding) for the refeff FEFF10 port
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

use crate::error::{IoError, Result};

pub(super) fn parse_element(line: usize, token: &str) -> Result<String> {
    let valid_len = (1..=2).contains(&token.len());
    let valid_chars = token.chars().all(|ch| ch.is_ascii_alphabetic());
    if valid_len && valid_chars {
        Ok(canonical_symbol(token))
    } else {
        Err(IoError::ConfigInpParse {
            field: "element",
            line,
            token: token.to_string(),
        })
    }
}

pub(super) fn parse_orbital(line: usize, token: &str) -> Result<String> {
    let orbital = token.to_ascii_lowercase();
    if is_allowed_orbital(&orbital) {
        Ok(orbital)
    } else {
        Err(IoError::ConfigInpParse {
            field: "orbital",
            line,
            token: token.to_string(),
        })
    }
}

pub(super) fn parse_i32(line: usize, field: &'static str, token: &str) -> Result<i32> {
    token.parse::<i32>().map_err(|_| IoError::ConfigInpParse {
        field,
        line,
        token: token.to_string(),
    })
}

pub(super) fn parse_f64(line: usize, field: &'static str, token: &str) -> Result<f64> {
    token.parse::<f64>().map_err(|_| IoError::ConfigInpParse {
        field,
        line,
        token: token.to_string(),
    })
}

pub(super) fn validate_finite(field: &'static str, value: f64) -> Result<()> {
    if value.is_finite() {
        Ok(())
    } else {
        Err(invalid_config_inp(field, "value must be finite"))
    }
}

pub(super) fn invalid_config_inp(field: &'static str, message: impl Into<String>) -> IoError {
    IoError::InvalidConfigInp {
        field,
        message: message.into(),
    }
}

pub(super) fn canonical_noble_gas(token: &str) -> Option<String> {
    match token.to_ascii_uppercase().as_str() {
        "HE" => Some("He".to_string()),
        "NE" => Some("Ne".to_string()),
        "AR" => Some("Ar".to_string()),
        "KR" => Some("Kr".to_string()),
        "XE" => Some("Xe".to_string()),
        "HG" => Some("Hg".to_string()),
        "RN" => Some("Rn".to_string()),
        _ => None,
    }
}

pub(super) fn is_zero_base_token(token: &str) -> bool {
    token == "0"
}

pub(super) fn canonical_symbol(token: &str) -> String {
    let mut chars = token.chars();
    let mut symbol = String::new();
    if let Some(first) = chars.next() {
        symbol.push(first.to_ascii_uppercase());
    }
    if let Some(second) = chars.next() {
        symbol.push(second.to_ascii_lowercase());
    }
    symbol
}

pub(super) fn is_allowed_orbital(orbital: &str) -> bool {
    matches!(
        orbital,
        "1s" | "2s"
            | "2p"
            | "3s"
            | "3p"
            | "3d"
            | "4s"
            | "4p"
            | "4d"
            | "4f"
            | "5s"
            | "5p"
            | "5d"
            | "5f"
            | "5g"
            | "6s"
            | "6p"
            | "6d"
            | "6f"
            | "7s"
            | "7p"
            | "7d"
            | "8s"
            | "8p"
    )
}

pub(super) fn is_s_orbital(orbital: &str) -> bool {
    orbital.ends_with('s')
}