quantrs2_device/neutral_atom/
config.rs

1//! Configuration management for neutral atom quantum devices
2
3use crate::DeviceResult;
4use serde::{Deserialize, Serialize};
5use std::collections::HashMap;
6use std::time::Duration;
7
8/// Advanced configuration for neutral atom quantum devices
9#[derive(Debug, Clone, Serialize, Deserialize, Default)]
10pub struct AdvancedNeutralAtomConfig {
11    /// Hardware-specific settings
12    pub hardware_settings: HardwareSettings,
13    /// Optimization parameters
14    pub optimization: OptimizationConfig,
15    /// Error correction settings
16    pub error_correction: ErrorCorrectionConfig,
17    /// Calibration parameters
18    pub calibration: CalibrationConfig,
19}
20
21/// Hardware-specific settings
22#[derive(Debug, Clone, Serialize, Deserialize, Default)]
23pub struct HardwareSettings {
24    /// Laser control parameters
25    pub laser_control: LaserControlConfig,
26    /// Trap configuration
27    pub trap_config: TrapConfig,
28    /// Detection settings
29    pub detection: DetectionConfig,
30}
31
32/// Laser control configuration
33#[derive(Debug, Clone, Serialize, Deserialize)]
34pub struct LaserControlConfig {
35    /// Main trapping laser wavelength (nm)
36    pub trapping_wavelength: f64,
37    /// Rydberg excitation laser wavelength (nm)
38    pub rydberg_wavelength: f64,
39    /// Maximum laser power (mW)
40    pub max_power: f64,
41    /// Beam waist (μm)
42    pub beam_waist: f64,
43    /// Laser stability specifications
44    pub stability: LaserStabilityConfig,
45}
46
47/// Laser stability configuration
48#[derive(Debug, Clone, Serialize, Deserialize)]
49pub struct LaserStabilityConfig {
50    /// Frequency stability (Hz)
51    pub frequency_stability: f64,
52    /// Power stability (%)
53    pub power_stability: f64,
54    /// Phase stability (mrad)
55    pub phase_stability: f64,
56}
57
58/// Trap configuration
59#[derive(Debug, Clone, Serialize, Deserialize)]
60pub struct TrapConfig {
61    /// Trap depth (μK)
62    pub trap_depth: f64,
63    /// Trap frequency (Hz)
64    pub trap_frequency: f64,
65    /// Anharmonicity coefficient
66    pub anharmonicity: f64,
67    /// Loading rate (atoms/s)
68    pub loading_rate: f64,
69}
70
71/// Detection configuration
72#[derive(Debug, Clone, Serialize, Deserialize)]
73pub struct DetectionConfig {
74    /// Detection efficiency
75    pub efficiency: f64,
76    /// Dark count rate (Hz)
77    pub dark_count_rate: f64,
78    /// Integration time (μs)
79    pub integration_time: f64,
80    /// Background subtraction
81    pub background_subtraction: bool,
82}
83
84/// Optimization configuration
85#[derive(Debug, Clone, Serialize, Deserialize)]
86pub struct OptimizationConfig {
87    /// Enable gate optimization
88    pub gate_optimization: bool,
89    /// Enable circuit compilation optimization
90    pub circuit_optimization: bool,
91    /// Maximum optimization time (ms)
92    pub max_optimization_time: Duration,
93    /// Optimization target
94    pub optimization_target: OptimizationTarget,
95}
96
97/// Optimization targets
98#[derive(Debug, Clone, Serialize, Deserialize)]
99pub enum OptimizationTarget {
100    /// Minimize execution time
101    Speed,
102    /// Maximize fidelity
103    Fidelity,
104    /// Balance speed and fidelity
105    Balanced,
106    /// Custom optimization function
107    Custom(String),
108}
109
110/// Error correction configuration
111#[derive(Debug, Clone, Serialize, Deserialize)]
112pub struct ErrorCorrectionConfig {
113    /// Enable error correction
114    pub enabled: bool,
115    /// Error correction scheme
116    pub scheme: ErrorCorrectionScheme,
117    /// Syndrome detection parameters
118    pub syndrome_detection: SyndromeDetectionConfig,
119    /// Recovery protocol
120    pub recovery_protocol: RecoveryProtocolConfig,
121}
122
123/// Error correction schemes
124#[derive(Debug, Clone, Serialize, Deserialize)]
125pub enum ErrorCorrectionScheme {
126    /// No error correction
127    None,
128    /// Repetition code
129    Repetition,
130    /// Surface code
131    Surface,
132    /// Color code
133    Color,
134    /// Custom scheme
135    Custom(String),
136}
137
138/// Syndrome detection configuration
139#[derive(Debug, Clone, Serialize, Deserialize)]
140pub struct SyndromeDetectionConfig {
141    /// Detection threshold
142    pub threshold: f64,
143    /// Measurement rounds
144    pub measurement_rounds: usize,
145    /// Majority voting
146    pub majority_voting: bool,
147}
148
149/// Recovery protocol configuration
150#[derive(Debug, Clone, Serialize, Deserialize)]
151pub struct RecoveryProtocolConfig {
152    /// Maximum correction attempts
153    pub max_attempts: usize,
154    /// Recovery timeout (ms)
155    pub timeout: Duration,
156    /// Adaptive recovery
157    pub adaptive: bool,
158}
159
160/// Calibration configuration
161#[derive(Debug, Clone, Serialize, Deserialize)]
162pub struct CalibrationConfig {
163    /// Auto-calibration enabled
164    pub auto_calibration: bool,
165    /// Calibration interval (hours)
166    pub calibration_interval: Duration,
167    /// Calibration procedures
168    pub procedures: Vec<CalibrationProcedure>,
169    /// Reference measurements
170    pub reference_measurements: HashMap<String, f64>,
171}
172
173/// Calibration procedures
174#[derive(Debug, Clone, Serialize, Deserialize)]
175pub enum CalibrationProcedure {
176    /// Laser frequency calibration
177    LaserFrequency,
178    /// Power calibration
179    PowerCalibration,
180    /// Trap depth calibration
181    TrapDepth,
182    /// Gate fidelity calibration
183    GateFidelity,
184    /// Detection efficiency calibration
185    DetectionEfficiency,
186    /// Custom procedure
187    Custom(String),
188}
189
190impl Default for LaserControlConfig {
191    fn default() -> Self {
192        Self {
193            trapping_wavelength: 852.0,
194            rydberg_wavelength: 480.0,
195            max_power: 100.0,
196            beam_waist: 1.0,
197            stability: LaserStabilityConfig::default(),
198        }
199    }
200}
201
202impl Default for LaserStabilityConfig {
203    fn default() -> Self {
204        Self {
205            frequency_stability: 1000.0,
206            power_stability: 0.1,
207            phase_stability: 0.01,
208        }
209    }
210}
211
212impl Default for TrapConfig {
213    fn default() -> Self {
214        Self {
215            trap_depth: 1000.0,
216            trap_frequency: 100_000.0,
217            anharmonicity: 0.01,
218            loading_rate: 1000.0,
219        }
220    }
221}
222
223impl Default for DetectionConfig {
224    fn default() -> Self {
225        Self {
226            efficiency: 0.95,
227            dark_count_rate: 10.0,
228            integration_time: 100.0,
229            background_subtraction: true,
230        }
231    }
232}
233
234impl Default for OptimizationConfig {
235    fn default() -> Self {
236        Self {
237            gate_optimization: true,
238            circuit_optimization: true,
239            max_optimization_time: Duration::from_millis(1000),
240            optimization_target: OptimizationTarget::Balanced,
241        }
242    }
243}
244
245impl Default for ErrorCorrectionConfig {
246    fn default() -> Self {
247        Self {
248            enabled: false,
249            scheme: ErrorCorrectionScheme::None,
250            syndrome_detection: SyndromeDetectionConfig::default(),
251            recovery_protocol: RecoveryProtocolConfig::default(),
252        }
253    }
254}
255
256impl Default for SyndromeDetectionConfig {
257    fn default() -> Self {
258        Self {
259            threshold: 0.5,
260            measurement_rounds: 3,
261            majority_voting: true,
262        }
263    }
264}
265
266impl Default for RecoveryProtocolConfig {
267    fn default() -> Self {
268        Self {
269            max_attempts: 3,
270            timeout: Duration::from_millis(100),
271            adaptive: true,
272        }
273    }
274}
275
276impl Default for CalibrationConfig {
277    fn default() -> Self {
278        Self {
279            auto_calibration: true,
280            calibration_interval: Duration::from_secs(3600),
281            procedures: vec![
282                CalibrationProcedure::LaserFrequency,
283                CalibrationProcedure::PowerCalibration,
284                CalibrationProcedure::TrapDepth,
285            ],
286            reference_measurements: HashMap::new(),
287        }
288    }
289}
290
291/// Validate advanced configuration
292pub fn validate_advanced_config(config: &AdvancedNeutralAtomConfig) -> DeviceResult<()> {
293    // Validate laser control
294    if config.hardware_settings.laser_control.max_power <= 0.0 {
295        return Err(crate::DeviceError::InvalidInput(
296            "Maximum laser power must be positive".to_string(),
297        ));
298    }
299
300    // Validate trap configuration
301    if config.hardware_settings.trap_config.trap_depth <= 0.0 {
302        return Err(crate::DeviceError::InvalidInput(
303            "Trap depth must be positive".to_string(),
304        ));
305    }
306
307    // Validate detection efficiency
308    let efficiency = config.hardware_settings.detection.efficiency;
309    if !(0.0..=1.0).contains(&efficiency) {
310        return Err(crate::DeviceError::InvalidInput(
311            "Detection efficiency must be between 0 and 1".to_string(),
312        ));
313    }
314
315    Ok(())
316}
quantrs2_device/neutral_atom/config.rs

quantrs2_device/neutral_atom/
config.rs
