quantrs2_tytan/realtime_quantum_integration/
hardware.rs

1//! Hardware monitoring types for Real-time Quantum Computing Integration
2//!
3//! This module provides hardware monitor and device-related types.
4
5use serde::{Deserialize, Serialize};
6use std::collections::{HashMap, VecDeque};
7use std::time::{Duration, Instant, SystemTime};
8
9use super::config::MonitorConfig;
10use super::metrics::{CalibrationData, DeviceMetrics};
11use super::types::{
12    AuthenticationType, ComponentStatus, ConnectionStatus, ConnectivityType, DeviceType,
13    IssueSeverity, IssueType, MaintenanceType, MeasurementBasis, OverallStatus, WarningType,
14};
15
16/// Live hardware monitor for quantum devices
17#[allow(dead_code)]
18pub struct HardwareMonitor {
19    /// Device information
20    pub(crate) device_info: DeviceInfo,
21    /// Current status
22    pub(crate) current_status: DeviceStatus,
23    /// Metrics history
24    pub(crate) metrics_history: VecDeque<DeviceMetrics>,
25    /// Calibration data
26    pub(crate) calibration_data: CalibrationData,
27    /// Monitor configuration
28    pub(crate) monitor_config: MonitorConfig,
29    /// Last update time
30    pub(crate) last_update: Instant,
31}
32
33/// Device information
34#[derive(Debug, Clone, Serialize, Deserialize)]
35pub struct DeviceInfo {
36    /// Device ID
37    pub device_id: String,
38    /// Device type
39    pub device_type: DeviceType,
40    /// Device capabilities
41    pub capabilities: DeviceCapabilities,
42    /// Location information
43    pub location: LocationInfo,
44    /// Connection details
45    pub connection: ConnectionInfo,
46    /// Specifications
47    pub specifications: DeviceSpecifications,
48}
49
50/// Device capabilities
51#[derive(Debug, Clone, Serialize, Deserialize)]
52pub struct DeviceCapabilities {
53    /// Number of qubits
54    pub num_qubits: usize,
55    /// Supported gates
56    pub supported_gates: Vec<String>,
57    /// Connectivity graph
58    pub connectivity: ConnectivityGraph,
59    /// Maximum circuit depth
60    pub max_circuit_depth: usize,
61    /// Measurement capabilities
62    pub measurement_capabilities: MeasurementCapabilities,
63    /// Error rates
64    pub error_rates: ErrorRates,
65}
66
67/// Connectivity graph
68#[derive(Debug, Clone, Serialize, Deserialize)]
69pub struct ConnectivityGraph {
70    /// Adjacency matrix
71    pub adjacency_matrix: Vec<Vec<bool>>,
72    /// Connectivity type
73    pub connectivity_type: ConnectivityType,
74    /// Coupling strengths
75    pub coupling_strengths: HashMap<(usize, usize), f64>,
76}
77
78/// Measurement capabilities
79#[derive(Debug, Clone, Serialize, Deserialize)]
80pub struct MeasurementCapabilities {
81    /// Measurement bases
82    pub measurement_bases: Vec<MeasurementBasis>,
83    /// Measurement fidelity
84    pub measurement_fidelity: f64,
85    /// Readout time
86    pub readout_time: Duration,
87    /// Simultaneous measurements
88    pub simultaneous_measurements: bool,
89}
90
91/// Error rates
92#[derive(Debug, Clone, Serialize, Deserialize)]
93pub struct ErrorRates {
94    /// Single-qubit gate error
95    pub single_qubit_gate_error: f64,
96    /// Two-qubit gate error
97    pub two_qubit_gate_error: f64,
98    /// Measurement error
99    pub measurement_error: f64,
100    /// Decoherence rates
101    pub decoherence_rates: DecoherenceRates,
102}
103
104/// Decoherence rates
105#[derive(Debug, Clone, Serialize, Deserialize)]
106pub struct DecoherenceRates {
107    /// T1 time (relaxation)
108    pub t1_time: Duration,
109    /// T2 time (dephasing)
110    pub t2_time: Duration,
111    /// T2* time (inhomogeneous dephasing)
112    pub t2_star_time: Duration,
113}
114
115/// Location information
116#[derive(Debug, Clone, Serialize, Deserialize)]
117pub struct LocationInfo {
118    /// Physical location
119    pub physical_location: String,
120    /// Timezone
121    pub timezone: String,
122    /// Coordinates
123    pub coordinates: Option<(f64, f64)>,
124    /// Network latency
125    pub network_latency: Duration,
126}
127
128/// Connection information
129#[derive(Debug, Clone, Serialize, Deserialize)]
130pub struct ConnectionInfo {
131    /// Endpoint URL
132    pub endpoint: String,
133    /// Authentication type
134    pub auth_type: AuthenticationType,
135    /// Connection status
136    pub connection_status: ConnectionStatus,
137    /// API version
138    pub api_version: String,
139    /// Rate limits
140    pub rate_limits: RateLimits,
141}
142
143/// Rate limits
144#[derive(Debug, Clone, Serialize, Deserialize)]
145pub struct RateLimits {
146    /// Requests per minute
147    pub requests_per_minute: usize,
148    /// Concurrent requests
149    pub concurrent_requests: usize,
150    /// Data transfer limits
151    pub data_transfer_limits: DataTransferLimits,
152}
153
154/// Data transfer limits
155#[derive(Debug, Clone, Serialize, Deserialize)]
156pub struct DataTransferLimits {
157    /// Maximum upload size
158    pub max_upload_size: usize,
159    /// Maximum download size
160    pub max_download_size: usize,
161    /// Bandwidth limit
162    pub bandwidth_limit: usize,
163}
164
165/// Device specifications
166#[derive(Debug, Clone, Serialize, Deserialize)]
167pub struct DeviceSpecifications {
168    /// Operating temperature
169    pub operating_temperature: f64,
170    /// Operating frequency range
171    pub frequency_range: (f64, f64),
172    /// Power consumption
173    pub power_consumption: f64,
174    /// Physical dimensions
175    pub dimensions: PhysicalDimensions,
176    /// Environmental requirements
177    pub environmental_requirements: EnvironmentalRequirements,
178}
179
180/// Physical dimensions
181#[derive(Debug, Clone, Serialize, Deserialize)]
182pub struct PhysicalDimensions {
183    /// Length in meters
184    pub length: f64,
185    /// Width in meters
186    pub width: f64,
187    /// Height in meters
188    pub height: f64,
189    /// Weight in kilograms
190    pub weight: f64,
191}
192
193/// Environmental requirements
194#[derive(Debug, Clone, Serialize, Deserialize)]
195pub struct EnvironmentalRequirements {
196    /// Temperature range
197    pub temperature_range: (f64, f64),
198    /// Humidity range
199    pub humidity_range: (f64, f64),
200    /// Vibration tolerance
201    pub vibration_tolerance: f64,
202    /// Electromagnetic shielding
203    pub em_shielding_required: bool,
204}
205
206/// Device status
207#[derive(Debug, Clone, Serialize, Deserialize)]
208pub struct DeviceStatus {
209    /// Overall status
210    pub overall_status: OverallStatus,
211    /// Availability
212    pub availability: Availability,
213    /// Current load
214    pub current_load: f64,
215    /// Queue status
216    pub queue_status: QueueStatus,
217    /// Health indicators
218    pub health_indicators: HealthIndicators,
219    /// Last maintenance
220    pub last_maintenance: SystemTime,
221    /// Next scheduled maintenance
222    pub next_maintenance: Option<SystemTime>,
223}
224
225impl Default for DeviceStatus {
226    fn default() -> Self {
227        Self {
228            overall_status: OverallStatus::Online,
229            availability: Availability {
230                available: true,
231                expected_available_time: None,
232                availability_percentage: 0.99,
233                planned_downtime: vec![],
234            },
235            current_load: 0.5,
236            queue_status: QueueStatus {
237                jobs_in_queue: 0,
238                estimated_wait_time: Duration::ZERO,
239                next_job_position: 0,
240                processing_rate: 1.0,
241            },
242            health_indicators: HealthIndicators {
243                system_temperature: 22.0,
244                error_rate: 0.001,
245                performance_metrics: PerformanceIndicators {
246                    gate_fidelity: 0.99,
247                    measurement_fidelity: 0.95,
248                    coherence_times: DecoherenceRates {
249                        t1_time: Duration::from_micros(100),
250                        t2_time: Duration::from_micros(50),
251                        t2_star_time: Duration::from_micros(30),
252                    },
253                    throughput: 1000.0,
254                    latency: Duration::from_millis(10),
255                },
256                component_health: HashMap::new(),
257                warning_flags: vec![],
258            },
259            last_maintenance: SystemTime::now(),
260            next_maintenance: None,
261        }
262    }
263}
264
265/// Availability information
266#[derive(Debug, Clone, Serialize, Deserialize)]
267pub struct Availability {
268    /// Is device available
269    pub available: bool,
270    /// Expected availability time
271    pub expected_available_time: Option<SystemTime>,
272    /// Availability percentage
273    pub availability_percentage: f64,
274    /// Planned downtime
275    pub planned_downtime: Vec<MaintenanceWindow>,
276}
277
278/// Maintenance window
279#[derive(Debug, Clone, Serialize, Deserialize)]
280pub struct MaintenanceWindow {
281    /// Start time
282    pub start_time: SystemTime,
283    /// End time
284    pub end_time: SystemTime,
285    /// Maintenance type
286    pub maintenance_type: MaintenanceType,
287    /// Description
288    pub description: String,
289}
290
291/// Queue status
292#[derive(Debug, Clone, Serialize, Deserialize)]
293pub struct QueueStatus {
294    /// Number of jobs in queue
295    pub jobs_in_queue: usize,
296    /// Estimated wait time
297    pub estimated_wait_time: Duration,
298    /// Queue position for next job
299    pub next_job_position: usize,
300    /// Processing rate
301    pub processing_rate: f64,
302}
303
304/// Health indicators
305#[derive(Debug, Clone, Serialize, Deserialize)]
306pub struct HealthIndicators {
307    /// System temperature
308    pub system_temperature: f64,
309    /// Error rate
310    pub error_rate: f64,
311    /// Performance metrics
312    pub performance_metrics: PerformanceIndicators,
313    /// Component health
314    pub component_health: HashMap<String, ComponentHealth>,
315    /// Warning flags
316    pub warning_flags: Vec<WarningFlag>,
317}
318
319/// Performance indicators
320#[derive(Debug, Clone, Serialize, Deserialize)]
321pub struct PerformanceIndicators {
322    /// Gate fidelity
323    pub gate_fidelity: f64,
324    /// Measurement fidelity
325    pub measurement_fidelity: f64,
326    /// Coherence times
327    pub coherence_times: DecoherenceRates,
328    /// Throughput
329    pub throughput: f64,
330    /// Latency
331    pub latency: Duration,
332}
333
334/// Component health
335#[derive(Debug, Clone, Serialize, Deserialize)]
336pub struct ComponentHealth {
337    /// Component name
338    pub component_name: String,
339    /// Health score
340    pub health_score: f64,
341    /// Status
342    pub status: ComponentStatus,
343    /// Last checked
344    pub last_checked: SystemTime,
345    /// Issues
346    pub issues: Vec<ComponentIssue>,
347}
348
349/// Component issue
350#[derive(Debug, Clone, Serialize, Deserialize)]
351pub struct ComponentIssue {
352    /// Issue type
353    pub issue_type: IssueType,
354    /// Severity
355    pub severity: IssueSeverity,
356    /// Description
357    pub description: String,
358    /// First occurrence
359    pub first_occurrence: SystemTime,
360    /// Frequency
361    pub frequency: f64,
362}
363
364/// Warning flag
365#[derive(Debug, Clone, Serialize, Deserialize)]
366pub struct WarningFlag {
367    /// Warning type
368    pub warning_type: WarningType,
369    /// Message
370    pub message: String,
371    /// Timestamp
372    pub timestamp: SystemTime,
373    /// Acknowledged
374    pub acknowledged: bool,
375}
376
377// Implementation for HardwareMonitor
378impl HardwareMonitor {
379    /// Create a new hardware monitor for the given device
380    pub fn new(device_info: DeviceInfo) -> Self {
381        Self {
382            device_info,
383            current_status: DeviceStatus::default(),
384            metrics_history: VecDeque::new(),
385            calibration_data: CalibrationData::default(),
386            monitor_config: MonitorConfig::default(),
387            last_update: Instant::now(),
388        }
389    }
390
391    /// Update metrics for the device
392    pub fn update_metrics(&mut self) -> Result<(), String> {
393        use super::metrics::{EnvironmentalMetrics, HardwareMetrics, QuantumMetrics};
394
395        // Simulate metric collection
396        let metrics = DeviceMetrics {
397            timestamp: SystemTime::now(),
398            cpu_utilization: 0.5,
399            memory_utilization: 0.6,
400            network_utilization: 0.3,
401            hardware_metrics: HardwareMetrics {
402                temperatures: {
403                    let mut temps = HashMap::new();
404                    temps.insert("cpu".to_string(), 45.0);
405                    temps.insert("quantum_chip".to_string(), 0.01);
406                    temps
407                },
408                power_consumption: 150.0,
409                vibration_levels: HashMap::new(),
410                magnetic_fields: HashMap::new(),
411            },
412            quantum_metrics: QuantumMetrics {
413                gate_fidelities: HashMap::new(),
414                measurement_fidelities: HashMap::new(),
415                coherence_measurements: HashMap::new(),
416                crosstalk_matrix: None,
417            },
418            environmental_metrics: EnvironmentalMetrics {
419                ambient_temperature: 22.0,
420                humidity: 45.0,
421                pressure: 1013.25,
422                air_quality: None,
423            },
424        };
425
426        self.metrics_history.push_back(metrics);
427        if self.metrics_history.len() > 1000 {
428            self.metrics_history.pop_front();
429        }
430
431        self.last_update = Instant::now();
432        Ok(())
433    }
434
435    /// Get the current device status
436    pub fn get_current_status(&self) -> DeviceStatus {
437        self.current_status.clone()
438    }
439}
quantrs2_tytan/realtime_quantum_integration/hardware.rs

quantrs2_tytan/realtime_quantum_integration/
hardware.rs
