sciforge-lib 0.0.4

Scientific computing library — mathematics, physics, chemistry, biology, astronomy, geology, meteorology.
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
160
161
162

use crate::constants::{C, E_CHARGE, EPSILON_0, MU_0};
use std::f64::consts::PI;

pub fn lorentz_factor(velocity_m_per_s: f64) -> f64 {
    let beta_sq = (velocity_m_per_s / C).powi(2);
    1.0 / (1.0 - beta_sq).sqrt()
}

pub fn beta_factor(velocity_m_per_s: f64) -> f64 {
    velocity_m_per_s / C
}

pub fn e_field_transverse_boost(
    e_perp_v_per_m: f64,
    b_perp_t: f64,
    velocity_m_per_s: f64,
    boost_direction_sign: f64,
) -> f64 {
    let gamma = lorentz_factor(velocity_m_per_s);
    gamma * (e_perp_v_per_m + boost_direction_sign * velocity_m_per_s * b_perp_t)
}

pub fn b_field_transverse_boost(
    b_perp_t: f64,
    e_perp_v_per_m: f64,
    velocity_m_per_s: f64,
    boost_direction_sign: f64,
) -> f64 {
    let gamma = lorentz_factor(velocity_m_per_s);
    gamma * (b_perp_t - boost_direction_sign * velocity_m_per_s * e_perp_v_per_m / (C * C))
}

pub fn doppler_shift_relativistic_em(
    source_frequency_hz: f64,
    velocity_m_per_s: f64,
    angle_rad: f64,
) -> f64 {
    let beta = velocity_m_per_s / C;
    let gamma = 1.0 / (1.0 - beta * beta).sqrt();
    source_frequency_hz / (gamma * (1.0 - beta * angle_rad.cos()))
}

pub fn aberration_angle(angle_source_rad: f64, velocity_m_per_s: f64) -> f64 {
    let beta = velocity_m_per_s / C;
    let cos_t = (angle_source_rad.cos() - beta) / (1.0 - beta * angle_source_rad.cos());
    cos_t.acos()
}

pub fn lienard_wiechert_potential_scalar(
    charge_c: f64,
    distance_m: f64,
    velocity_m_per_s: f64,
    angle_rad: f64,
) -> f64 {
    let beta = velocity_m_per_s / C;
    charge_c / (4.0 * PI * EPSILON_0 * distance_m * (1.0 - beta * angle_rad.cos()))
}

pub fn lienard_wiechert_vector_magnitude(
    charge_c: f64,
    velocity_m_per_s: f64,
    distance_m: f64,
    angle_rad: f64,
) -> f64 {
    let beta = velocity_m_per_s / C;
    MU_0 * charge_c * velocity_m_per_s
        / (4.0 * PI * distance_m * (1.0 - beta * angle_rad.cos()))
}

pub fn larmor_power_relativistic(
    acceleration_m_per_s2_parallel: f64,
    acceleration_m_per_s2_perp: f64,
    velocity_m_per_s: f64,
) -> f64 {
    let gamma = lorentz_factor(velocity_m_per_s);
    let prefactor = E_CHARGE * E_CHARGE / (6.0 * PI * EPSILON_0 * C.powi(3));
    prefactor * gamma.powi(6)
        * (acceleration_m_per_s2_parallel.powi(2)
            + acceleration_m_per_s2_perp.powi(2) / (gamma * gamma))
}

pub fn synchrotron_critical_frequency(
    gamma_lorentz: f64,
    radius_m: f64,
) -> f64 {
    3.0 * gamma_lorentz.powi(3) * C / (4.0 * PI * radius_m)
}

pub fn synchrotron_total_power(
    gamma_lorentz: f64,
    radius_m: f64,
) -> f64 {
    let prefactor = E_CHARGE * E_CHARGE * C / (6.0 * PI * EPSILON_0);
    prefactor * gamma_lorentz.powi(4) / (radius_m * radius_m)
}

pub fn synchrotron_energy_loss_per_turn_ev(
    gamma_lorentz: f64,
    radius_m: f64,
) -> f64 {
    let prefactor = E_CHARGE / (3.0 * EPSILON_0);
    prefactor * gamma_lorentz.powi(4) / radius_m / E_CHARGE
}

pub fn cherenkov_angle(refractive_index: f64, velocity_m_per_s: f64) -> f64 {
    let beta = velocity_m_per_s / C;
    (1.0 / (refractive_index * beta)).acos()
}

pub fn cherenkov_threshold_velocity(refractive_index: f64) -> f64 {
    C / refractive_index
}

pub fn cherenkov_photons_per_unit_length(
    charge_number: f64,
    refractive_index: f64,
    velocity_m_per_s: f64,
    wavelength_min_m: f64,
    wavelength_max_m: f64,
) -> f64 {
    let alpha = crate::constants::ALPHA_FINE;
    let beta = velocity_m_per_s / C;
    let sin2 = 1.0 - 1.0 / (refractive_index * beta).powi(2);
    if sin2 <= 0.0 {
        0.0
    } else {
        2.0 * PI * alpha * charge_number * charge_number * sin2
            * (1.0 / wavelength_min_m - 1.0 / wavelength_max_m)
    }
}

pub fn relativistic_cyclotron_frequency(
    charge_c: f64,
    b_t: f64,
    mass_kg: f64,
    velocity_m_per_s: f64,
) -> f64 {
    let gamma = lorentz_factor(velocity_m_per_s);
    charge_c.abs() * b_t / (gamma * mass_kg)
}

pub fn thomas_precession_frequency(
    acceleration_m_per_s2: f64,
    velocity_m_per_s: f64,
) -> f64 {
    let gamma = lorentz_factor(velocity_m_per_s);
    (gamma * gamma / (gamma + 1.0)) * (acceleration_m_per_s2 * velocity_m_per_s) / (C * C)
}

pub fn invariant_em_field(
    e_v_per_m: f64,
    b_t: f64,
) -> f64 {
    e_v_per_m * e_v_per_m - C * C * b_t * b_t
}

pub fn invariant_e_dot_b(
    ex: f64, ey: f64, ez: f64,
    bx: f64, by: f64, bz: f64,
) -> f64 {
    ex * bx + ey * by + ez * bz
}