scirs2-metrics 0.3.2

Machine Learning evaluation metrics module for SciRS2 (scirs2-metrics)
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
135

//! Safety and reliability metrics
//!
//! This module provides metrics for evaluating robotic system safety,
//! reliability, failure analysis, and maintenance requirements.

#![allow(clippy::too_many_arguments)]
#![allow(dead_code)]

use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Safety and reliability evaluation metrics
#[derive(Debug, Clone)]
pub struct SafetyReliabilityMetrics {
    /// Failure analysis metrics
    pub failure_metrics: FailureMetrics,
    /// Risk assessment
    pub risk_assessment: RiskAssessmentMetrics,
    /// System redundancy evaluation
    pub redundancy_metrics: RedundancyMetrics,
    /// Maintenance and diagnostics
    pub maintenance_metrics: MaintenanceMetrics,
}

/// Failure analysis and tracking
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FailureMetrics {
    /// Mean Time Between Failures (MTBF)
    pub mtbf: Duration,
    /// Mean Time To Repair (MTTR)
    pub mttr: Duration,
    /// Failure rate per operation hour
    pub failure_rate: f64,
    /// Critical failure rate
    pub critical_failure_rate: f64,
    /// System availability
    pub availability: f64,
}

/// Risk assessment metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RiskAssessmentMetrics {
    /// Overall risk score
    pub overall_risk_score: f64,
    /// Safety integrity level
    pub safety_integrity_level: u8,
    /// Hazard identification coverage
    pub hazard_coverage: f64,
    /// Risk mitigation effectiveness
    pub mitigation_effectiveness: f64,
}

/// System redundancy evaluation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RedundancyMetrics {
    /// Redundancy level
    pub redundancy_level: u8,
    /// Graceful degradation capability
    pub graceful_degradation: f64,
    /// Fault detection coverage
    pub fault_detection_coverage: f64,
    /// Recovery time
    pub recovery_time: Duration,
}

/// Maintenance and diagnostics metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MaintenanceMetrics {
    /// Predictive maintenance accuracy
    pub predictive_accuracy: f64,
    /// Diagnostic coverage
    pub diagnostic_coverage: f64,
    /// Maintenance efficiency
    pub maintenance_efficiency: f64,
    /// Component life prediction accuracy
    pub life_prediction_accuracy: f64,
}

impl SafetyReliabilityMetrics {
    /// Create new safety and reliability metrics
    pub fn new() -> Self {
        Self {
            failure_metrics: FailureMetrics::default(),
            risk_assessment: RiskAssessmentMetrics::default(),
            redundancy_metrics: RedundancyMetrics::default(),
            maintenance_metrics: MaintenanceMetrics::default(),
        }
    }
}

// Default implementations
impl Default for FailureMetrics {
    fn default() -> Self {
        Self {
            mtbf: Duration::from_secs(86400), // 24 hours
            mttr: Duration::from_secs(3600),  // 1 hour
            failure_rate: 0.001,
            critical_failure_rate: 0.0001,
            availability: 0.99,
        }
    }
}

impl Default for RiskAssessmentMetrics {
    fn default() -> Self {
        Self {
            overall_risk_score: 0.1,
            safety_integrity_level: 2,
            hazard_coverage: 0.95,
            mitigation_effectiveness: 0.9,
        }
    }
}

impl Default for RedundancyMetrics {
    fn default() -> Self {
        Self {
            redundancy_level: 2,
            graceful_degradation: 1.0,
            fault_detection_coverage: 0.95,
            recovery_time: Duration::from_secs(10),
        }
    }
}

impl Default for MaintenanceMetrics {
    fn default() -> Self {
        Self {
            predictive_accuracy: 0.8,
            diagnostic_coverage: 0.9,
            maintenance_efficiency: 0.85,
            life_prediction_accuracy: 0.75,
        }
    }
}