crseo 2.5.3

Cuda Engined Optics Rust Interface
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

use ffi::pyramid;
use serde::{Deserialize, Serialize};

use crate::{
    imaging::LensletArray,
    wavefrontsensor::{Calibration, GmtSegmentation, SegmentWiseSensorBuilder},
    Builder, CrseoError,
};

use super::{piston_sensor::PistonSensor, Modulation, Pyramid};

/// [Pyramid] builder
///
/// Default properties:
///   - n_lenslet: 30
///   - n_px_lenslet: 8px
///   - lenslet_pitch: 0
///   - no modulation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PyramidBuilder {
    pub lenslet_array: LensletArray,
    modulation: Option<Modulation>,
    alpha: f32,
    n_gs: i32,
    pub piston_sensor: Option<PistonSensor>,
}
impl Default for PyramidBuilder {
    fn default() -> Self {
        Self {
            lenslet_array: LensletArray {
                n_side_lenslet: 30,
                n_px_lenslet: 8,
                d: 0f64,
            },
            modulation: None::<Modulation>,
            alpha: 0.5f32,
            n_gs: 1,
            piston_sensor: None,
        }
    }
}

impl PyramidBuilder {
    /// Sets the number of equivalent lenslets
    pub fn n_lenslet(mut self, n_lenslet: usize) -> Self {
        self.lenslet_array.n_side_lenslet = n_lenslet;
        self
    }
    /// Sets the equivalent lenslet array
    pub fn lenslet_array(mut self, lenslet_array: LensletArray) -> Self {
        self.lenslet_array = lenslet_array;
        self
    }
    /// Sets the modulation amplitude and sampling
    ///
    /// The amplitude is given in units of lambda/d
    pub fn modulation(mut self, amplitude: f32, sampling: i32) -> Self {
        self.modulation = Some(Modulation {
            amplitude,
            sampling,
        });
        self
    }
    pub fn piston_sensor<G: Into<GmtSegmentation>>(
        &mut self,
        calibration: &Calibration,
        gmt_segmentation: G,
    ) -> Result<(), CrseoError> {
        self.piston_sensor = Some(PistonSensor::new(
            self,
            calibration.masks(),
            gmt_segmentation.into(),
            calibration.src.clone(),
        )?);
        Ok(())
    }

    /*     pub fn piston_mask<'a>(
        &self,
        masks: impl Iterator<Item = Option<&'a nalgebra::DMatrix<bool>>>,
        segmentation: GmtSegmentation,
        gs: SourceBuilder,
    ) -> Result<(Vec<bool>, Vec<bool>), CrseoError> {
        let piston_sensor = PistonSensor::new(&self, masks, segmentation, gs)?;
        Ok(piston_sensor.mask)
    } */
}

impl SegmentWiseSensorBuilder for PyramidBuilder {
    fn pupil_sampling(&self) -> usize {
        let LensletArray {
            n_side_lenslet,
            n_px_lenslet,
            ..
        } = self.lenslet_array;
        n_side_lenslet * n_px_lenslet
    }
}

impl Builder for PyramidBuilder {
    type Component = Pyramid;

    fn build(self) -> crate::Result<Self::Component> {
        let mut pym = Pyramid {
            _c_: pyramid::default(),
            lenslet_array: self.lenslet_array,
            alpha: self.alpha,
            modulation: self.modulation,
            piston_sensor: self.piston_sensor,
        };
        let LensletArray {
            n_side_lenslet,
            n_px_lenslet,
            ..
        } = self.lenslet_array;
        let n_pupil_sampling = n_side_lenslet * n_px_lenslet;
        let Modulation {
            amplitude,
            sampling,
        } = self.modulation.unwrap_or_default();
        unsafe {
            pym._c_.setup(
                n_side_lenslet as i32,
                n_pupil_sampling as i32,
                amplitude,
                sampling,
                self.alpha,
                self.n_gs,
            );
        };

        Ok(pym)
    }
}