test: more realistic multi instance

Author: aeltorio

rust/tests/multi_instance_integration_test.rs

@@ -47,12 +47,14 @@ async fn test_multi_spectral_analysis_pipeline() -> Result<()> {
     .with_detection_threshold(0.04);
 
     // Create ConcentrationNodes for each gas species with different polynomials
+    // NOTE: Adjusted coefficients to work with realistic FFT amplitudes (20-50 range)
+    // instead of small mV values (0.001-0.020 range)
     let mut concentration_co2 = ConcentrationNode::new_with_shared_state(
         "concentration_co2".to_string(),
         Some(shared_state.clone()),
     )
     .with_peak_finder_source("peak_finder_co2".to_string())
-    .with_polynomial_coefficients([0.0, 850.0, -12.5, 0.0, 0.0]) // CO2 calibration curve
+    .with_polynomial_coefficients([0.0, 25.0, -0.3, 0.0, 0.0]) // CO2 calibration curve for FFT amplitudes
     .with_spectral_line_id("CO2_4.26um".to_string())
     .with_temperature_compensation(true);
 
@@ -61,7 +63,7 @@ async fn test_multi_spectral_analysis_pipeline() -> Result<()> {
         Some(shared_state.clone()),
     )
     .with_peak_finder_source("peak_finder_ch4".to_string())
-    .with_polynomial_coefficients([5.0, 1200.0, -8.3, 0.15, 0.0]) // CH4 calibration curve
+    .with_polynomial_coefficients([5.0, 17.0, -0.25, 0.005, 0.0]) // CH4 calibration curve for FFT amplitudes
     .with_spectral_line_id("CH4_3.39um".to_string())
     .with_temperature_compensation(true);
 
@@ -70,7 +72,7 @@ async fn test_multi_spectral_analysis_pipeline() -> Result<()> {
         Some(shared_state.clone()),
     )
     .with_peak_finder_source("peak_finder_nh3".to_string())
-    .with_polynomial_coefficients([2.5, 950.0, -15.2, 0.08, 0.0]) // NH3 calibration curve
+    .with_polynomial_coefficients([2.5, 40.0, -0.5, 0.003, 0.0]) // NH3 calibration curve for FFT amplitudes (higher sensitivity)
     .with_spectral_line_id("NH3_10.4um".to_string())
     .with_temperature_compensation(false);
 
@@ -84,22 +86,22 @@ async fn test_multi_spectral_analysis_pipeline() -> Result<()> {
     // Generate synthetic photoacoustic signals at different frequencies
     for i in 0..frame_size {
         let t = i as f32 / sample_rate as f32;
-        
+
         // CO2 signal at 2050 Hz with moderate amplitude (simulates moderate concentration)
         let co2_signal = 0.15 * (2.0 * std::f32::consts::PI * 2050.0 * t).sin();
-        
+
         // CH4 signal at 3045 Hz with lower amplitude (simulates low concentration)
         let ch4_signal = 0.08 * (2.0 * std::f32::consts::PI * 3045.0 * t).sin();
-        
+
         // NH3 signal at 1550 Hz with higher amplitude (simulates high concentration)
         let nh3_signal = 0.25 * (2.0 * std::f32::consts::PI * 1550.0 * t).sin();
-        
+
         // Add some noise to make it more realistic
         let noise = 0.01 * ((i as f32 * 123.456).sin() - 0.5);
-        
+
         // Combine all signals
         let combined_signal = co2_signal + ch4_signal + nh3_signal + noise;
-        
+
         audio_samples_a[i] = combined_signal;
         audio_samples_b[i] = combined_signal; // Same signal on both channels for simplicity
     }
@@ -114,7 +116,34 @@ async fn test_multi_spectral_analysis_pipeline() -> Result<()> {
         frame_number: 1,
     });
 
-    // Process data through all concentration nodes
+    // STEP 1: Process audio data through PeakFinderNodes to detect peaks
+    // This simulates real acquisition where audio signals are analyzed for spectral peaks
+    let audio_output_co2 = peak_finder_co2.process(test_audio.clone())?;
+    let audio_output_ch4 = peak_finder_ch4.process(test_audio.clone())?;
+    let audio_output_nh3 = peak_finder_nh3.process(test_audio.clone())?;
+
+    // Verify audio data passes through unchanged
+    assert_eq!(test_audio, audio_output_co2);
+    assert_eq!(test_audio, audio_output_ch4);
+    assert_eq!(test_audio, audio_output_nh3);
+
+    // Allow some time for peak detection to stabilize (simulate multiple frames)
+    // In real operation, peak detection needs several frames to establish coherence
+    for frame_num in 2..=5 {
+        let mut audio_frame = match test_audio {
+            ProcessingData::AudioFrame(ref frame) => frame.clone(),
+            _ => unreachable!(),
+        };
+        audio_frame.frame_number = frame_num;
+        let frame_data = ProcessingData::AudioFrame(audio_frame);
+
+        peak_finder_co2.process(frame_data.clone())?;
+        peak_finder_ch4.process(frame_data.clone())?;
+        peak_finder_nh3.process(frame_data)?;
+    }
+
+    // STEP 2: Process the same audio data through ConcentrationNodes
+    // They will use the peak detection results from the PeakFinderNodes
     let output_co2 = concentration_co2.process(test_audio.clone())?;
     let output_ch4 = concentration_ch4.process(test_audio.clone())?;
     let output_nh3 = concentration_nh3.process(test_audio.clone())?;
@@ -124,57 +153,165 @@ async fn test_multi_spectral_analysis_pipeline() -> Result<()> {
     assert_eq!(test_audio, output_ch4);
     assert_eq!(test_audio, output_nh3);
 
-    // Verify that all concentrations were calculated correctly
+    // Verify that peak detection and concentration calculations work correctly
     {
         let state = shared_state.read().await;
 
-        // Check CO2 concentration: 0 + 850 * 0.008 - 12.5 * 0.008^2 = 6.8 - 0.0008 ≈ 6.8 ppm
-        assert!(state
-            .concentration_results
-            .contains_key("concentration_co2"));
+        // Verify that peaks were detected by each PeakFinderNode
+        assert!(
+            state.peak_results.contains_key("peak_finder_co2"),
+            "CO2 peak finder should have detected a peak"
+        );
+        assert!(
+            state.peak_results.contains_key("peak_finder_ch4"),
+            "CH4 peak finder should have detected a peak"
+        );
+        assert!(
+            state.peak_results.contains_key("peak_finder_nh3"),
+            "NH3 peak finder should have detected a peak"
+        );
+
+        // Verify peak frequencies are within expected ranges
+        let co2_peak = &state.peak_results["peak_finder_co2"];
+        assert!(
+            co2_peak.frequency >= 2000.0 && co2_peak.frequency <= 2100.0,
+            "CO2 peak frequency should be in expected range (2000-2100 Hz), got {}",
+            co2_peak.frequency
+        );
+
+        let ch4_peak = &state.peak_results["peak_finder_ch4"];
+        assert!(
+            ch4_peak.frequency >= 3000.0 && ch4_peak.frequency <= 3100.0,
+            "CH4 peak frequency should be in expected range (3000-3100 Hz), got {}",
+            ch4_peak.frequency
+        );
+
+        let nh3_peak = &state.peak_results["peak_finder_nh3"];
+        assert!(
+            nh3_peak.frequency >= 1500.0 && nh3_peak.frequency <= 1600.0,
+            "NH3 peak frequency should be in expected range (1500-1600 Hz), got {}",
+            nh3_peak.frequency
+        );
+
+        // Verify that concentrations were calculated
+        assert!(
+            state
+                .concentration_results
+                .contains_key("concentration_co2"),
+            "CO2 concentration should have been calculated"
+        );
+        assert!(
+            state
+                .concentration_results
+                .contains_key("concentration_ch4"),
+            "CH4 concentration should have been calculated"
+        );
+        assert!(
+            state
+                .concentration_results
+                .contains_key("concentration_nh3"),
+            "NH3 concentration should have been calculated"
+        );
+
+        // Check CO2 concentration calculation
         let co2_result = &state.concentration_results["concentration_co2"];
-        assert!((co2_result.concentration_ppm - 6.7992).abs() < 0.001);
+        assert!(
+            co2_result.concentration_ppm > 0.0,
+            "CO2 concentration should be positive, got {}",
+            co2_result.concentration_ppm
+        );
         assert_eq!(co2_result.source_peak_finder_id, "peak_finder_co2");
         assert_eq!(co2_result.spectral_line_id.as_ref().unwrap(), "CO2_4.26um");
         assert!(co2_result.temperature_compensated);
 
-        // Check CH4 concentration: 5 + 1200 * 0.003 - 8.3 * 0.003^2 + 0.15 * 0.003^3
-        // = 5 + 3.6 - 0.0000747 + 0.000004 ≈ 8.6 ppm
-        assert!(state
-            .concentration_results
-            .contains_key("concentration_ch4"));
+        // Check CH4 concentration calculation
         let ch4_result = &state.concentration_results["concentration_ch4"];
-        assert!((ch4_result.concentration_ppm - 8.59993).abs() < 0.001);
+        assert!(
+            ch4_result.concentration_ppm > 0.0,
+            "CH4 concentration should be positive, got {}",
+            ch4_result.concentration_ppm
+        );
         assert_eq!(ch4_result.source_peak_finder_id, "peak_finder_ch4");
         assert_eq!(ch4_result.spectral_line_id.as_ref().unwrap(), "CH4_3.39um");
         assert!(ch4_result.temperature_compensated);
 
-        // Check NH3 concentration: 2.5 + 950 * 0.012 - 15.2 * 0.012^2 + 0.08 * 0.012^3
-        // = 2.5 + 11.4 - 0.021888 + 0.00013824 ≈ 13.88 ppm
-        assert!(state
-            .concentration_results
-            .contains_key("concentration_nh3"));
+        // Check NH3 concentration calculation
         let nh3_result = &state.concentration_results["concentration_nh3"];
-        assert!((nh3_result.concentration_ppm - 13.8978).abs() < 0.01); // Use actual calculated value
+        assert!(
+            nh3_result.concentration_ppm > 0.0,
+            "NH3 concentration should be positive, got {}",
+            nh3_result.concentration_ppm
+        );
         assert_eq!(nh3_result.source_peak_finder_id, "peak_finder_nh3");
         assert_eq!(nh3_result.spectral_line_id.as_ref().unwrap(), "NH3_10.4um");
         assert!(!nh3_result.temperature_compensated);
 
+        // Log actual values for debugging BEFORE assertions
+        println!("Peak detection results:");
+        println!(
+            "  CO2: {:.2} Hz, amplitude {:.4}",
+            co2_peak.frequency, co2_peak.amplitude
+        );
+        println!(
+            "  CH4: {:.2} Hz, amplitude {:.4}",
+            ch4_peak.frequency, ch4_peak.amplitude
+        );
+        println!(
+            "  NH3: {:.2} Hz, amplitude {:.4}",
+            nh3_peak.frequency, nh3_peak.amplitude
+        );
+        println!("Concentration results:");
+        println!("  CO2: {:.2} ppm", co2_result.concentration_ppm);
+        println!("  CH4: {:.2} ppm", ch4_result.concentration_ppm);
+        println!("  NH3: {:.2} ppm", nh3_result.concentration_ppm);
+
+        // Verify that NH3 has the highest amplitude signal and thus highest concentration
+        // since we generated it with the highest amplitude (0.25 vs 0.15 for CO2 and 0.08 for CH4)
+        assert!(
+            nh3_result.concentration_ppm > co2_result.concentration_ppm,
+            "NH3 concentration ({}) should be higher than CO2 ({})",
+            nh3_result.concentration_ppm,
+            co2_result.concentration_ppm
+        );
+        assert!(
+            nh3_result.concentration_ppm > ch4_result.concentration_ppm,
+            "NH3 concentration ({}) should be higher than CH4 ({})",
+            nh3_result.concentration_ppm,
+            ch4_result.concentration_ppm
+        );
+
+        // Verify that CO2 has higher concentration than CH4 (0.15 vs 0.08 amplitude)
+        assert!(
+            co2_result.concentration_ppm > ch4_result.concentration_ppm,
+            "CO2 concentration ({}) should be higher than CH4 ({})",
+            co2_result.concentration_ppm,
+            ch4_result.concentration_ppm
+        );
+
         // Verify that legacy fields contain the last calculated concentration (NH3 in this case)
         assert!(state.concentration_ppm.is_some());
         let legacy_concentration = state.concentration_ppm.unwrap() as f64;
-        assert!((legacy_concentration - 13.8978).abs() < 0.01); // Use actual calculated value
+        assert!(
+            (legacy_concentration - nh3_result.concentration_ppm).abs() < 0.01,
+            "Legacy concentration field should match NH3 result"
+        );
     }
 
     // Test hot-reload configuration update for one of the nodes
     let new_ch4_config = serde_json::json!({
-        "polynomial_coefficients": [10.0, 1100.0, -6.0, 0.1, 0.0],
+        "polynomial_coefficients": [10.0, 30.0, -0.2, 0.003, 0.0],
         "temperature_compensation": false
     });
 
     let updated = concentration_ch4.update_config(&new_ch4_config)?;
     assert!(updated);
 
+    // Store the original CH4 concentration for comparison
+    let original_ch4_concentration = {
+        let state = shared_state.read().await;
+        state.concentration_results["concentration_ch4"].concentration_ppm
+    };
+
     // Process again with updated configuration
     concentration_ch4.process(test_audio)?;
 
@@ -183,10 +320,20 @@ async fn test_multi_spectral_analysis_pipeline() -> Result<()> {
         let state = shared_state.read().await;
         let ch4_result = &state.concentration_results["concentration_ch4"];
 
-        // New calculation: 10 + 1100 * 0.003 - 6.0 * 0.003^2 + 0.1 * 0.003^3
-        // = 10 + 3.3 - 0.000054 + 0.0000027 ≈ 13.3 ppm
-        assert!((ch4_result.concentration_ppm - 13.29995).abs() < 0.001);
-        assert!(!ch4_result.temperature_compensated); // Should be updated
+        // The new polynomial should produce a different result
+        assert_ne!(
+            ch4_result.concentration_ppm, original_ch4_concentration,
+            "Updated polynomial should produce different concentration"
+        );
+        assert!(
+            !ch4_result.temperature_compensated,
+            "Temperature compensation should be disabled"
+        );
+
+        println!(
+            "CH4 concentration after config update: {:.2} ppm (was {:.2} ppm)",
+            ch4_result.concentration_ppm, original_ch4_concentration
+        );
     }
 
     Ok(())