donnager 0.1.2

Blazingly fast astrodynamics calculations in Rust
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
148
149
150
151
152
153
154
155
156
157
158
159

/*
Fluid dynamics
*/

use crate::constants as cst;

/// Calculate mass flow of nozzle
/// 
/// Inputs
/// ------
/// throat_area : `f64`
///     Area of nozzle throat
/// 
/// p_chamber : `f64`
///     Chamber pressure
/// 
/// c_star : `f64`
///     Characteristic velocity
/// 
/// Outputs
/// -------
/// mass_flow : `f64`
///     Mass flow rate through throat
pub fn calc_mass_flow(
    throat_area: f64,
    p_chamber: f64,
    c_star: f64
) -> f64 {
    let mass_flow: f64 = p_chamber * throat_area / c_star; 
    return mass_flow
}


pub fn calc_atmos_pressure(
    p_ref: f64,
    t_ref: f64,
    delta_h: f64,
    molar_mass: f64
) -> f64 {
    let exp: f64 = 
        cst::GRAV_CONST * molar_mass * delta_h / (cst::GAS_CONST * t_ref);
    let pressure: f64 = p_ref * exp.exp();
    return pressure
}


/// Calculate mach number
/// 
/// Inputs
/// ------
/// velocity : `f64`
///     Fluid or object velocity
/// 
/// temperature : `f64`
///     Fluid temperature
/// 
/// heat_capacity_ratio : `f64`
///     Heat capacity ratio of fluid
/// 
/// Outputs
/// -------
/// mach_number : `f64`
///     Fluid or object  mach number
pub fn calc_mach_number(
    velocity: f64,
    temperature: f64,
    heat_capacity_ratio: f64
) -> f64 {
    let speed_of_sound: f64 = 
        (heat_capacity_ratio * cst::GAS_CONST * temperature).sqrt();
    let mach_number: f64 = velocity / speed_of_sound;
    return mach_number 
}


pub fn calc_aerodynamic_force(
    density: f64,
    velocity: f64,
    coeff: f64,
    normal_area: f64
) -> f64 {
    // Can be used for drag or lift or both
    let force: f64 = density * velocity.powi(2) * coeff * normal_area / 2.0;
    return force
}


pub fn calc_characteristic_vel(
    heat_capacity_ratio: f64,
    t_chamber: f64
) -> f64 {
    let c_f: f64 = 
        (2.0/(heat_capacity_ratio + 1.0)).powf(
            -(heat_capacity_ratio + 1.0)/(2.0*(heat_capacity_ratio - 1.0))); 
    let exhaust_vel: f64 = 
        (cst::GAS_CONST * t_chamber * heat_capacity_ratio).sqrt() / 
        heat_capacity_ratio;
    let c_star: f64 = exhaust_vel * c_f;
    return c_star
}


pub fn calc_thrust_coeff(
    heat_capacity_ratio: f64, 
    expansion_ratio: f64,
    p_chamber: f64,
    p_atm: f64,
    p_exhaust: f64
) -> f64 {
    let a: f64 = 
        2.0 * heat_capacity_ratio.powi(2) / (heat_capacity_ratio - 1.0);
    let b: f64 = 
        (2.0 / (heat_capacity_ratio + 1.0)).powf(
            (heat_capacity_ratio + 1.0)/(heat_capacity_ratio - 1.0));
    let c: f64 = 
        1.0 - (p_exhaust / p_chamber).powf(
            (heat_capacity_ratio - 1.0) / heat_capacity_ratio);

    let jet_thurst: f64 = (a * b * c).sqrt();
    let press_thrust: f64 = 
        (p_exhaust / p_chamber - p_atm / p_chamber) * expansion_ratio;
    let c_f: f64 = jet_thurst + press_thrust;
    return c_f
}


/// Calculate specific impulse of engine
/// 
/// Inputs
/// ------
/// heat_capacity_ratio : `f64`
///     Heat capacity ratio    
/// 
/// expansion_ratio : `f64`
///     Nozzle expansion ratio
/// 
/// t_chamber : `f64`
///     Chamber temperature
/// 
/// p_chamber : `f64`    
///     Chamber pressure
pub fn calc_engine_isp(
    heat_capacity_ratio: f64, 
    expansion_ratio: f64,
    t_chamber: f64,
    p_chamber: f64,
    p_atm: f64,
    p_exhaust: f64
) -> f64 {
    let thrust_coeff: f64 = calc_thrust_coeff(
        heat_capacity_ratio, 
        expansion_ratio, 
        p_chamber, 
        p_atm, 
        p_exhaust);
    let c_star: f64 = calc_characteristic_vel(heat_capacity_ratio, t_chamber);
    let isp: f64 = thrust_coeff * c_star;
    return isp
}