KiThe 0.1.5

A collection of structures and functions useful for chemical kinetics, chemical thermodynamics, combustion, heat and mass transfer, shock tubes and so on and so far. Work in progress. Advices and contributions will be appreciated
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

// SECTION UNDER CONSTRUCTION

use crate::Kinetics::molmass::calculate_molar_mass;
use std::collections::HashMap;

enum ErrorEnum {
    ParseError,
    MolarMassError,
    UnknownElement,
    UnknownLibrary,
}

/*
fn parse_and_calculate_molar_mass_wrapper(formula: &str) -> Result<(f64, HashMap<String, usize>), ErrorEnum> {
    let (molmass, atomic_composition) = calculate_molar_mass(formula.to_string());
    match (molmass,atomic_composition) {
        Ok( (molmass,atomic_composition) )  => Ok((molmass, atomic_composition)),


        Err(_) => Err(ErrorEnum::MolarMassError),
    }
}

 */
////////////////////////////////////////////////////////////////////////////////
#[derive(Debug, Clone)]
pub struct UserSubstances {
    pub vec_of_substances: Vec<String>,
    pub map_of_substances: HashMap<String, IndividualSubstance>,
    pub atomic_matrix: Vec<Vec<f64>>,
    pub parse_errors: HashMap<String, String>,
}
impl UserSubstances {
    pub fn new() -> Self {
        Self {
            vec_of_substances: Vec::new(),
            map_of_substances: HashMap::new(),
            atomic_matrix: Vec::new(),
            parse_errors: HashMap::new(),
        }
    }

    pub fn set_vec_of_substances(&mut self, vec_of_substances: Vec<String>) {
        self.vec_of_substances = vec_of_substances;
    }
    pub fn set_map_of_substances(&mut self) {
        for substance in &self.vec_of_substances {
            let mut individual_substance = IndividualSubstance::new();
            individual_substance.set_formula(substance.to_string());
            //  individual_substance.parse_and_calculate_molar_mass();
            self.map_of_substances
                .insert(substance.to_string(), individual_substance);
        }
    }
}
#[derive(Debug, Clone)]
// thermal data library
enum ThermalDataLib {
    NASA,
    NIST,
}

impl ThermalDataLib {
    fn from_str(s: &str) -> Option<Self> {
        match s {
            "NASA" => Some(Self::NASA),
            "NIST" => Some(Self::NIST),
            _ => None,
        }
    }

    fn as_str(&self) -> &str {
        match self {
            Self::NASA => "NASA",
            Self::NIST => "NIST",
        }
    }
}

#[derive(Debug, Clone)]
enum TransportLib {
    Aramco,
    CEA,
}

impl TransportLib {
    fn from_str(s: &str) -> Option<Self> {
        match s {
            "Aramco" => Some(Self::Aramco),
            "CEA" => Some(Self::CEA),
            _ => None,
        }
    }
    fn as_str(&self) -> &str {
        match self {
            Self::Aramco => "Aramco",
            Self::CEA => "CEA",
        }
    }
}

// struct for individual substance
#[allow(non_snake_case)]
#[derive(Debug, Clone)]
pub struct IndividualSubstance {
    pub formula: String,
    pub molar_mass: f64,
    pub composition: HashMap<String, usize>,
    pub Cp: HashMap<ThermalDataLib, Vec<String>>, // heat capacity polynomial coefficients for substance
    pub dH: HashMap<ThermalDataLib, Vec<String>>, // heat of formation polynomial coefficients for substance
    pub dS: HashMap<ThermalDataLib, Vec<String>>, // entropy polynomial coefficients for substance
    pub dG: HashMap<ThermalDataLib, Vec<String>>, // Gibbs free energy polynomial coefficients for substance
    pub Lambda: HashMap<TransportLib, Vec<String>>, // thermal conductivity polynomial coefficients for substance
}
impl IndividualSubstance {
    pub fn new() -> Self {
        Self {
            formula: String::new(),
            molar_mass: 0.0,
            composition: HashMap::new(),
            Cp: HashMap::new(),
            dH: HashMap::new(),
            dS: HashMap::new(),
            dG: HashMap::new(),
            Lambda: HashMap::new(),
        }
    }
    pub fn set_formula(&mut self, formula: String) {
        self.formula = formula;
    }
    /*
    pub fn parse_and_calculate_molar_mass(&mut self) {
        match parse_and_calculate_molar_mass_wrapper (&self.formula) {
            Ok((molar_mass, composition)) => {
                self.molar_mass = molar_mass;
                self.composition = composition;
            }
            Err(_) => {
                self.molar_mass = 0.0;
                self.composition = HashMap::new();
            }
        }// end of match

    } // end of parse_and_calculate_molar_mass
    */
    pub fn collct_data_from_library(&mut self, _lib: ThermalDataLib) {}
} // end of IndividualSubstance