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

use std::collections::HashMap;

use autd3_driver::derive::*;

/// Gain with uniform emission intensity and phase
#[derive(Gain, Clone, PartialEq, Debug, Builder)]
pub struct Uniform {
    #[get]
    intensity: EmitIntensity,
    #[getset]
    phase: Phase,
}

impl Uniform {
    /// constructor
    ///
    /// # Arguments
    ///
    /// * `intensity` - Emission intensity
    ///
    pub fn new(intensity: impl Into<EmitIntensity>) -> Self {
        Self {
            intensity: intensity.into(),
            phase: Phase::new(0),
        }
    }
}

impl Gain for Uniform {
    fn calc(
        &self,
        geometry: &Geometry,
        filter: GainFilter,
    ) -> Result<HashMap<usize, Vec<Drive>>, AUTDInternalError> {
        Ok(Self::transform(geometry, filter, |_, _| {
            Drive::new(self.phase, self.intensity)
        }))
    }
}

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

    use super::*;
    use rand::Rng;

    fn uniform_check(
        g: Uniform,
        intensity: EmitIntensity,
        phase: Phase,
        geometry: &Geometry,
    ) -> anyhow::Result<()> {
        assert_eq!(intensity, g.intensity());
        assert_eq!(phase, g.phase());

        let b = g.calc(geometry, GainFilter::All)?;
        assert_eq!(geometry.num_devices(), b.len());
        b.iter().for_each(|(&idx, d)| {
            assert_eq!(geometry[idx].num_transducers(), d.len());
            d.iter().for_each(|d| {
                assert_eq!(phase, d.phase());
                assert_eq!(intensity, d.intensity());
            });
        });

        Ok(())
    }

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

        let geometry = create_geometry(1);

        let intensity = EmitIntensity::new(rng.gen());
        let g = Uniform::new(intensity);
        uniform_check(g, intensity, Phase::new(0), &geometry)?;

        let intensity = EmitIntensity::new(rng.gen());
        let phase = Phase::new(rng.gen());
        let g = Uniform::new(intensity).with_phase(phase);
        uniform_check(g, intensity, phase, &geometry)?;

        Ok(())
    }

    #[test]
    fn test_uniform_derive() {
        let gain = Uniform::new(0x1F);
        let gain2 = gain.clone();
        assert_eq!(gain, gain2);
        let _ = gain.operation_with_segment(Segment::S0, true);
    }
}