chemrust-parser 0.2.0

The core modules defining the flow and structs of data in computational chemistry routines.
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

use std::collections::HashMap;

use nalgebra::Vector3;
use nom::{
    branch::alt,
    bytes::complete::tag,
    character::complete::{char, space0, space1},
    combinator::recognize,
    sequence::{delimited, preceded, separated_pair, terminated, tuple},
    IResult,
};

use crate::{decimal, float};

use super::{Analyzed, MsiParser};

pub fn hashmap_attrs<'a>(attributes: &[&'a str]) -> HashMap<String, &'a str> {
    let mut hashmap: HashMap<String, &str> = HashMap::new();
    attributes.iter().for_each(|item| {
        let (attr_str, key) = MsiParser::<Analyzed>::get_attribute_type(item).unwrap();
        hashmap.insert(key.into(), attr_str);
    });
    hashmap
}

pub fn parse_cry_display(input: &str) -> IResult<&str, (u32, u32)> {
    let (rest, value_str) = preceded(
        tuple((tag("I"), space1, tag("CRY/DISPLAY"), space1)),
        delimited(
            char('('),
            separated_pair(decimal, space1, decimal),
            char(')'),
        ),
    )(input)?;
    let value = (
        value_str.0.parse::<u32>().unwrap(),
        value_str.1.parse::<u32>().unwrap(),
    );
    Ok((rest, value))
}

pub fn parse_periodic_type(input: &str) -> IResult<&str, u8> {
    let (rest, value_str) = preceded(
        tuple((tag("I"), space1, tag("PeriodicType"), space1)),
        decimal,
    )(input)?;
    Ok((rest, value_str.parse::<u8>().unwrap()))
}

pub fn parse_space_group(input: &str) -> IResult<&str, &str> {
    preceded(
        tuple((tag("C"), space1, tag("SpaceGroup"), space1)),
        delimited(
            char('"'),
            recognize(separated_pair(decimal, space1, decimal)),
            char('"'),
        ),
    )(input)
}

pub fn parse_cry_tolerance(input: &str) -> IResult<&str, f64> {
    let (rest, value_str) = preceded(
        tuple((tag("D"), space1, tag("CRY/TOLERANCE"), space1)),
        float,
    )(input)?;
    Ok((rest, value_str.parse::<f64>().unwrap()))
}

pub fn parse_vector(input: &str) -> IResult<&str, Vector3<f64>> {
    let (rest, vec_str): (&str, (&str, &str, &str)) = preceded(
        tuple((
            tag("D"),
            space1,
            alt((tag("A3"), tag("B3"), tag("C3"))),
            space1,
        )),
        delimited(
            char('('),
            tuple((
                terminated(alt((float, decimal)), space0),
                terminated(alt((float, decimal)), space0),
                alt((float, decimal)),
            )),
            char(')'),
        ),
    )(input)?;
    let (x, y, z) = vec_str;
    let (x, y, z) = (
        x.parse::<f64>().unwrap(),
        y.parse::<f64>().unwrap(),
        z.parse::<f64>().unwrap(),
    );
    let vec: [f64; 3] = [x, y, z];
    Ok((rest, Vector3::from(vec)))
}