oxiphoton 0.1.1

Pure Rust Computational Photonics & Optical Simulation Framework
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

use crate::material::{DispersiveMaterial, DrudeLorentzPole};
use crate::units::{RefractiveIndex, Wavelength};
use num_complex::Complex64;
use std::f64::consts::PI;

use crate::units::conversion::SPEED_OF_LIGHT;

/// Drude model for metals: eps(omega) = eps_inf - omega_p^2 / (omega^2 + i*gamma*omega)
#[derive(Debug, Clone)]
pub struct Drude {
    pub name: String,
    /// High-frequency permittivity
    pub eps_inf: f64,
    /// Plasma frequency (rad/s)
    pub omega_p: f64,
    /// Damping rate (rad/s)
    pub gamma: f64,
}

impl Drude {
    pub fn new(name: impl Into<String>, eps_inf: f64, omega_p: f64, gamma: f64) -> Self {
        Self {
            name: name.into(),
            eps_inf,
            omega_p,
            gamma,
        }
    }

    fn permittivity_at_omega(&self, omega: f64) -> Complex64 {
        let eps_inf = Complex64::new(self.eps_inf, 0.0);
        let wp2 = self.omega_p * self.omega_p;
        let denom = Complex64::new(omega * omega, self.gamma * omega);
        eps_inf - wp2 / denom
    }
}

impl DispersiveMaterial for Drude {
    fn refractive_index(&self, wavelength: Wavelength) -> RefractiveIndex {
        let omega = 2.0 * PI * SPEED_OF_LIGHT / wavelength.0;
        let eps = self.permittivity_at_omega(omega);
        let n_complex = eps.sqrt();
        RefractiveIndex {
            n: n_complex.re.abs(),
            k: n_complex.im.abs(),
        }
    }

    fn permittivity(&self, wavelength: Wavelength) -> Complex64 {
        let omega = 2.0 * PI * SPEED_OF_LIGHT / wavelength.0;
        self.permittivity_at_omega(omega)
    }

    fn fdtd_poles(&self) -> Vec<DrudeLorentzPole> {
        vec![DrudeLorentzPole {
            amplitude: self.omega_p * self.omega_p,
            frequency: 0.0, // Drude: resonance at 0
            damping: self.gamma,
        }]
    }

    fn name(&self) -> &str {
        &self.name
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn drude_metal_has_complex_index() {
        let metal = Drude::new("TestMetal", 1.0, 1.37e16, 4.08e13);
        let ri = metal.refractive_index(Wavelength::from_nm(800.0));
        assert!(
            ri.k > 0.0,
            "Metal should have nonzero extinction coefficient"
        );
    }
}