quantrs2_tytan/realtime_quantum_integration/
metrics.rs

1//! Metrics types for Real-time Quantum Computing Integration
2//!
3//! This module provides metrics and calibration-related types.
4
5use scirs2_core::ndarray::{Array1, Array2};
6use serde::{Deserialize, Serialize};
7use std::collections::{HashMap, VecDeque};
8use std::time::{Duration, SystemTime};
9
10use super::hardware::DecoherenceRates;
11
12/// Device metrics collected during monitoring
13#[derive(Debug, Clone, Serialize, Deserialize)]
14pub struct DeviceMetrics {
15    /// Timestamp
16    pub timestamp: SystemTime,
17    /// CPU utilization
18    pub cpu_utilization: f64,
19    /// Memory utilization
20    pub memory_utilization: f64,
21    /// Network utilization
22    pub network_utilization: f64,
23    /// Hardware metrics
24    pub hardware_metrics: HardwareMetrics,
25    /// Quantum metrics
26    pub quantum_metrics: QuantumMetrics,
27    /// Environmental metrics
28    pub environmental_metrics: EnvironmentalMetrics,
29}
30
31/// Hardware-level metrics
32#[derive(Debug, Clone, Serialize, Deserialize)]
33pub struct HardwareMetrics {
34    /// Temperature readings
35    pub temperatures: HashMap<String, f64>,
36    /// Power consumption
37    pub power_consumption: f64,
38    /// Vibration levels
39    pub vibration_levels: HashMap<String, f64>,
40    /// Magnetic field measurements
41    pub magnetic_fields: HashMap<String, f64>,
42}
43
44/// Quantum-specific metrics
45#[derive(Debug, Clone, Serialize, Deserialize)]
46pub struct QuantumMetrics {
47    /// Current gate fidelities
48    pub gate_fidelities: HashMap<String, f64>,
49    /// Current measurement fidelities
50    pub measurement_fidelities: HashMap<usize, f64>,
51    /// Coherence time measurements
52    pub coherence_measurements: HashMap<usize, DecoherenceRates>,
53    /// Cross-talk measurements
54    pub crosstalk_matrix: Option<Array2<f64>>,
55}
56
57/// Environmental metrics
58#[derive(Debug, Clone, Serialize, Deserialize)]
59pub struct EnvironmentalMetrics {
60    /// Ambient temperature
61    pub ambient_temperature: f64,
62    /// Humidity
63    pub humidity: f64,
64    /// Atmospheric pressure
65    pub pressure: f64,
66    /// Air quality index
67    pub air_quality: Option<f64>,
68}
69
70/// Calibration data for quantum devices
71#[derive(Debug, Clone, Serialize, Deserialize)]
72pub struct CalibrationData {
73    /// Last calibration time
74    pub last_calibration: SystemTime,
75    /// Calibration results
76    pub calibration_results: CalibrationResults,
77    /// Calibration schedule
78    pub calibration_schedule: CalibrationSchedule,
79    /// Drift monitoring
80    pub drift_monitoring: DriftMonitoring,
81}
82
83impl Default for CalibrationData {
84    fn default() -> Self {
85        Self {
86            last_calibration: SystemTime::now(),
87            calibration_results: CalibrationResults {
88                gate_calibrations: HashMap::new(),
89                measurement_calibrations: HashMap::new(),
90                crosstalk_calibration: None,
91                overall_score: 0.95,
92            },
93            calibration_schedule: CalibrationSchedule {
94                regular_interval: Duration::from_secs(24 * 3600), // Daily
95                next_calibration: SystemTime::now() + Duration::from_secs(24 * 3600),
96                trigger_conditions: vec![],
97                maintenance_integration: true,
98            },
99            drift_monitoring: DriftMonitoring {
100                drift_parameters: HashMap::new(),
101                prediction_model: None,
102                drift_thresholds: HashMap::new(),
103            },
104        }
105    }
106}
107
108/// Calibration results
109#[derive(Debug, Clone, Serialize, Deserialize)]
110pub struct CalibrationResults {
111    /// Gate calibrations
112    pub gate_calibrations: HashMap<String, GateCalibration>,
113    /// Measurement calibrations
114    pub measurement_calibrations: HashMap<usize, MeasurementCalibration>,
115    /// Crosstalk calibration
116    pub crosstalk_calibration: Option<CrosstalkCalibration>,
117    /// Overall calibration score
118    pub overall_score: f64,
119}
120
121/// Gate calibration data
122#[derive(Debug, Clone, Serialize, Deserialize)]
123pub struct GateCalibration {
124    /// Gate name
125    pub gate_name: String,
126    /// Target qubits
127    pub target_qubits: Vec<usize>,
128    /// Fidelity achieved
129    pub fidelity: f64,
130    /// Parameters
131    pub parameters: HashMap<String, f64>,
132    /// Calibration time
133    pub calibration_time: Duration,
134}
135
136/// Measurement calibration data
137#[derive(Debug, Clone, Serialize, Deserialize)]
138pub struct MeasurementCalibration {
139    /// Qubit index
140    pub qubit_index: usize,
141    /// Measurement fidelity
142    pub fidelity: f64,
143    /// Readout parameters
144    pub readout_parameters: ReadoutParameters,
145    /// Calibration matrices
146    pub calibration_matrices: Option<Array2<f64>>,
147}
148
149/// Readout parameters for measurement
150#[derive(Debug, Clone, Serialize, Deserialize)]
151pub struct ReadoutParameters {
152    /// Measurement pulse parameters
153    pub pulse_parameters: HashMap<String, f64>,
154    /// Integration weights
155    pub integration_weights: Option<Array1<f64>>,
156    /// Discrimination threshold
157    pub discrimination_threshold: f64,
158}
159
160/// Crosstalk calibration data
161#[derive(Debug, Clone, Serialize, Deserialize)]
162pub struct CrosstalkCalibration {
163    /// Crosstalk matrix
164    pub crosstalk_matrix: Array2<f64>,
165    /// Mitigation strategy
166    pub mitigation_strategy: CrosstalkMitigation,
167    /// Effectiveness score
168    pub effectiveness_score: f64,
169}
170
171/// Crosstalk mitigation strategies
172#[derive(Debug, Clone, Serialize, Deserialize)]
173pub enum CrosstalkMitigation {
174    None,
175    StaticCompensation,
176    DynamicCompensation,
177    PostProcessing,
178}
179
180/// Calibration schedule configuration
181#[derive(Debug, Clone, Serialize, Deserialize)]
182pub struct CalibrationSchedule {
183    /// Regular calibration interval
184    pub regular_interval: Duration,
185    /// Next scheduled calibration
186    pub next_calibration: SystemTime,
187    /// Trigger conditions
188    pub trigger_conditions: Vec<CalibrationTrigger>,
189    /// Maintenance integration
190    pub maintenance_integration: bool,
191}
192
193/// Calibration trigger conditions
194#[derive(Debug, Clone, Serialize, Deserialize)]
195pub enum CalibrationTrigger {
196    TimeInterval(Duration),
197    PerformanceDegradation(f64),
198    EnvironmentalChange(f64),
199    UserRequest,
200    MaintenanceEvent,
201}
202
203/// Drift monitoring configuration
204#[derive(Debug, Clone, Serialize, Deserialize)]
205pub struct DriftMonitoring {
206    /// Drift tracking parameters
207    pub drift_parameters: HashMap<String, DriftParameter>,
208    /// Drift prediction model
209    pub prediction_model: Option<DriftPredictionModel>,
210    /// Alert thresholds
211    pub drift_thresholds: HashMap<String, f64>,
212}
213
214/// Drift parameter tracking
215#[derive(Debug, Clone, Serialize, Deserialize)]
216pub struct DriftParameter {
217    /// Parameter name
218    pub parameter_name: String,
219    /// Current value
220    pub current_value: f64,
221    /// Baseline value
222    pub baseline_value: f64,
223    /// Drift rate
224    pub drift_rate: f64,
225    /// History
226    pub value_history: VecDeque<(SystemTime, f64)>,
227}
228
229/// Drift prediction model
230#[derive(Debug, Clone, Serialize, Deserialize)]
231pub struct DriftPredictionModel {
232    /// Model type
233    pub model_type: String,
234    /// Model parameters
235    pub parameters: HashMap<String, f64>,
236    /// Prediction accuracy
237    pub accuracy: f64,
238    /// Last update
239    pub last_update: SystemTime,
240}