Skip to main content

qualia_core_db/specialized_libs/physics_simulation/
metrics.rs

1use super::*;
2
3/// Physics performance monitor
4pub struct PhysicsPerformanceMonitor {
5    simulation_metrics: SimulationMetrics,
6    solver_metrics: SolverMetrics,
7    mesh_metrics: MeshMetrics,
8    data_metrics: DataMetrics,
9}
10
11/// Simulation metrics
12#[derive(Debug, Clone)]
13pub struct SimulationMetrics {
14    pub total_simulations: u64,
15    pub average_simulation_time: f64,
16    pub time_step_count: u64,
17    pub convergence_rate: f64,
18    pub stability_metrics: StabilityMetrics,
19}
20
21/// Stability metrics
22#[derive(Debug, Clone)]
23pub struct StabilityMetrics {
24    pub cfl_number: f64,
25    pub numerical_dissipation: f64,
26    pub error_growth_rate: f64,
27    pub energy_conservation: f64,
28}
29
30/// Solver metrics
31#[derive(Debug, Clone)]
32pub struct SolverMetrics {
33    pub linear_solver_metrics: LinearSolverMetrics,
34    pub nonlinear_solver_metrics: NonlinearSolverMetrics,
35    pub eigenvalue_solver_metrics: EigenvalueSolverMetrics,
36    pub optimization_solver_metrics: OptimizationSolverMetrics,
37}
38
39/// Linear solver metrics
40#[derive(Debug, Clone)]
41pub struct LinearSolverMetrics {
42    pub average_iterations: f64,
43    pub convergence_rate: f64,
44    pub condition_number: f64,
45    pub residual_reduction: f64,
46}
47
48/// Nonlinear solver metrics
49#[derive(Debug, Clone)]
50pub struct NonlinearSolverMetrics {
51    pub average_iterations: f64,
52    pub convergence_rate: f64,
53    pub line_search_steps: f64,
54    pub function_evaluations: f64,
55}
56
57/// Eigenvalue solver metrics
58#[derive(Debug, Clone)]
59pub struct EigenvalueSolverMetrics {
60    pub average_iterations: f64,
61    pub convergence_rate: f64,
62    pub eigenvalue_accuracy: f64,
63    pub eigenvector_orthogonality: f64,
64}
65
66/// Optimization solver metrics
67#[derive(Debug, Clone)]
68pub struct OptimizationSolverMetrics {
69    pub average_iterations: f64,
70    pub convergence_rate: f64,
71    pub objective_value: f64,
72    pub constraint_violation: f64,
73}
74
75/// Mesh metrics
76#[derive(Debug, Clone)]
77pub struct MeshMetrics {
78    pub total_nodes: u64,
79    pub total_elements: u64,
80    pub mesh_quality: MeshQualityMetrics,
81    pub partition_metrics: PartitionMetrics,
82}
83
84/// Partition metrics
85#[derive(Debug, Clone)]
86pub struct PartitionMetrics {
87    pub number_of_partitions: u32,
88    pub load_balance_factor: f64,
89    pub communication_volume: u64,
90    pub surface_to_volume_ratio: f64,
91}
92
93/// Data metrics
94#[derive(Debug, Clone)]
95pub struct DataMetrics {
96    pub total_data_size: u64,
97    pub data_throughput: f64,
98    pub cache_hit_rate: f64,
99    pub compression_ratio: f64,
100    pub storage_utilization: f64,
101}
102
103impl PhysicsPerformanceMonitor {
104    /// Creates a monitor with zeroed physics metrics.
105    pub fn new() -> Self {
106        Self {
107            simulation_metrics: SimulationMetrics::new(),
108            solver_metrics: SolverMetrics::new(),
109            mesh_metrics: MeshMetrics::new(),
110            data_metrics: DataMetrics::new(),
111        }
112    }
113
114    /// Snapshot of aggregated `PhysicsPerformanceMetrics`.
115    pub fn get_metrics(&self) -> PhysicsPerformanceMetrics {
116        PhysicsPerformanceMetrics {
117            simulation_metrics: self.simulation_metrics.clone(),
118            solver_metrics: self.solver_metrics.clone(),
119            mesh_metrics: self.mesh_metrics.clone(),
120            data_metrics: self.data_metrics.clone(),
121            average_execution_time: self.simulation_metrics.average_simulation_time,
122            operations_count: self.simulation_metrics.total_simulations,
123        }
124    }
125}
126
127impl SimulationMetrics {
128    /// Creates zeroed `SimulationMetrics`.
129    pub fn new() -> Self {
130        Self {
131            total_simulations: 0,
132            average_simulation_time: 0.0,
133            time_step_count: 0,
134            convergence_rate: 0.0,
135            stability_metrics: StabilityMetrics::new(),
136        }
137    }
138}
139
140impl StabilityMetrics {
141    /// Creates zeroed `StabilityMetrics`.
142    pub fn new() -> Self {
143        Self {
144            cfl_number: 0.0,
145            numerical_dissipation: 0.0,
146            error_growth_rate: 0.0,
147            energy_conservation: 0.0,
148        }
149    }
150}
151
152impl SolverMetrics {
153    /// Creates zeroed `SolverMetrics`.
154    pub fn new() -> Self {
155        Self {
156            linear_solver_metrics: LinearSolverMetrics::new(),
157            nonlinear_solver_metrics: NonlinearSolverMetrics::new(),
158            eigenvalue_solver_metrics: EigenvalueSolverMetrics::new(),
159            optimization_solver_metrics: OptimizationSolverMetrics::new(),
160        }
161    }
162}
163
164impl LinearSolverMetrics {
165    /// Creates zeroed `LinearSolverMetrics`.
166    pub fn new() -> Self {
167        Self {
168            average_iterations: 0.0,
169            convergence_rate: 0.0,
170            condition_number: 0.0,
171            residual_reduction: 0.0,
172        }
173    }
174}
175
176impl NonlinearSolverMetrics {
177    /// Creates zeroed `NonlinearSolverMetrics`.
178    pub fn new() -> Self {
179        Self {
180            average_iterations: 0.0,
181            convergence_rate: 0.0,
182            line_search_steps: 0.0,
183            function_evaluations: 0.0,
184        }
185    }
186}
187
188impl EigenvalueSolverMetrics {
189    /// Creates zeroed `EigenvalueSolverMetrics`.
190    pub fn new() -> Self {
191        Self {
192            average_iterations: 0.0,
193            convergence_rate: 0.0,
194            eigenvalue_accuracy: 0.0,
195            eigenvector_orthogonality: 0.0,
196        }
197    }
198}
199
200impl OptimizationSolverMetrics {
201    /// Creates zeroed `OptimizationSolverMetrics`.
202    pub fn new() -> Self {
203        Self {
204            average_iterations: 0.0,
205            convergence_rate: 0.0,
206            objective_value: 0.0,
207            constraint_violation: 0.0,
208        }
209    }
210}
211
212impl MeshMetrics {
213    /// Creates zeroed `MeshMetrics`.
214    pub fn new() -> Self {
215        Self {
216            total_nodes: 0,
217            total_elements: 0,
218            mesh_quality: MeshQualityMetrics::new(),
219            partition_metrics: PartitionMetrics::new(),
220        }
221    }
222}
223
224impl PartitionMetrics {
225    /// Creates zeroed `PartitionMetrics`.
226    pub fn new() -> Self {
227        Self {
228            number_of_partitions: 1,
229            load_balance_factor: 1.0,
230            communication_volume: 0,
231            surface_to_volume_ratio: 0.0,
232        }
233    }
234}
235
236impl DataMetrics {
237    /// Creates zeroed `DataMetrics`.
238    pub fn new() -> Self {
239        Self {
240            total_data_size: 0,
241            data_throughput: 0.0,
242            cache_hit_rate: 0.0,
243            compression_ratio: 0.0,
244            storage_utilization: 0.0,
245        }
246    }
247}