autd3 38.1.0

AUTD3 library
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

use autd3_core::derive::*;

/// [`Gain`] that output uniform phase and intensity
#[derive(Gain, Clone, Copy, PartialEq, Debug)]
pub struct Uniform {
    /// The intensity of all transducers.
    pub intensity: Intensity,
    /// The phase of all transducers.
    pub phase: Phase,
}

impl Uniform {
    /// Create a new [`Uniform`]
    #[must_use]
    pub const fn new(intensity: Intensity, phase: Phase) -> Self {
        Self { intensity, phase }
    }
}

impl GainCalculator<'_> for Uniform {
    fn calc(&self, _: &Transducer) -> Drive {
        Drive {
            intensity: self.intensity,
            phase: self.phase,
        }
    }
}

impl GainCalculatorGenerator<'_> for Uniform {
    type Calculator = Uniform;

    fn generate(&mut self, _: &Device) -> Self::Calculator {
        *self
    }
}

impl Gain<'_> for Uniform {
    type G = Uniform;

    fn init(self, _: &Geometry, _: &Environment, _: &TransducerMask) -> Result<Self::G, GainError> {
        Ok(self)
    }
}

#[cfg(test)]
mod tests {
    use crate::tests::create_geometry;

    use super::*;
    use rand::RngExt;

    #[test]
    fn uniform() {
        let mut rng = rand::rng();

        let geometry = create_geometry(1);

        let intensity = Intensity(rng.random());
        let phase = Phase(rng.random());
        let g = Uniform::new(intensity, phase);

        let mut b = g;
        geometry.iter().for_each(|dev| {
            let d = b.generate(dev);
            dev.iter().for_each(|tr| {
                let d = d.calc(tr);
                assert_eq!(phase, d.phase);
                assert_eq!(intensity, d.intensity);
            });
        });
    }
}