autd3/datagram/gain/
uniform.rs

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
use autd3_driver::{derive::*, firmware::fpga::Drive};

#[derive(Gain, Clone, PartialEq, Debug, Builder)]
pub struct Uniform {
    #[get]
    drive: Drive,
}

impl Uniform {
    pub fn new(drive: impl Into<Drive>) -> Self {
        Self {
            drive: drive.into(),
        }
    }
}

impl Gain for Uniform {
    fn calc(&self, _geometry: &Geometry) -> Result<GainCalcFn, AUTDInternalError> {
        let d = self.drive;
        Ok(Self::transform(move |_| move |_| d))
    }
}

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

    use super::*;
    use autd3_driver::firmware::fpga::{EmitIntensity, Phase};
    use rand::Rng;

    #[test]
    fn test_uniform() -> anyhow::Result<()> {
        let mut rng = rand::thread_rng();

        let geometry = create_geometry(1);

        let intensity = EmitIntensity::new(rng.gen());
        let phase = Phase::new(rng.gen());
        let g = Uniform::new((intensity, phase));

        assert_eq!(intensity, g.drive().intensity());
        assert_eq!(phase, g.drive().phase());

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