Skip to main content

autoeq_optim/loss/drivers/
drivers_loss_data.rs

1use super::super::flat::flat_loss;
2use super::compute::compute_drivers_combined_response;
3use super::crossover_type::CrossoverType;
4use super::driver_measurement::DriverMeasurement;
5use ndarray::Array1;
6
7/// Data required for multi-driver crossover optimization
8#[derive(Debug, Clone)]
9pub struct DriversLossData {
10    /// Measurements for each driver (sorted by frequency range, lowest first)
11    pub drivers: Vec<DriverMeasurement>,
12    /// Crossover type to use between driver pairs
13    pub crossover_type: CrossoverType,
14    /// Common frequency grid for evaluation
15    pub freq_grid: Array1<f64>,
16}
17
18impl DriversLossData {
19    /// Create a new DriversLossData instance
20    ///
21    /// # Arguments
22    /// * `drivers` - Vector of driver measurements (will be sorted by frequency)
23    /// * `crossover_type` - Type of crossover filter to use
24    pub fn new(mut drivers: Vec<DriverMeasurement>, crossover_type: CrossoverType) -> Self {
25        let max_drivers = if crossover_type == CrossoverType::None {
26            usize::MAX
27        } else {
28            4
29        };
30        assert!(
31            drivers.len() >= 2 && drivers.len() <= max_drivers,
32            "Must have at least 2 drivers and at most 4 when using crossovers, got {}",
33            drivers.len()
34        );
35
36        // Sort drivers by their mean frequency (woofer -> midrange -> tweeter)
37        drivers.sort_by(|a, b| {
38            a.mean_freq()
39                .partial_cmp(&b.mean_freq())
40                .unwrap_or(std::cmp::Ordering::Equal)
41        });
42
43        Self::from_ordered(drivers, crossover_type)
44    }
45
46    /// Create loss data while preserving the caller's explicit acoustic-band order.
47    pub fn new_ordered(drivers: Vec<DriverMeasurement>, crossover_type: CrossoverType) -> Self {
48        let max_drivers = if crossover_type == CrossoverType::None {
49            usize::MAX
50        } else {
51            4
52        };
53        assert!(
54            drivers.len() >= 2 && drivers.len() <= max_drivers,
55            "Must have at least 2 drivers and at most 4 when using crossovers, got {}",
56            drivers.len()
57        );
58        Self::from_ordered(drivers, crossover_type)
59    }
60
61    fn from_ordered(drivers: Vec<DriverMeasurement>, crossover_type: CrossoverType) -> Self {
62        // Create a common frequency grid spanning all drivers
63        // Use logarithmic spacing from lowest to highest frequency
64        let min_freq = drivers
65            .iter()
66            .map(|d| d.freq_range().0)
67            .fold(f64::INFINITY, f64::min);
68        let max_freq = drivers
69            .iter()
70            .map(|d| d.freq_range().1)
71            .fold(f64::NEG_INFINITY, f64::max);
72
73        // Create log-spaced frequency grid (10 points per octave)
74        let freq_grid = crate::read::create_log_frequency_grid(
75            10 * 10, // 10 octaves * 10 points per octave
76            min_freq.max(20.0),
77            max_freq.min(20000.0),
78        );
79
80        Self {
81            drivers,
82            crossover_type,
83            freq_grid,
84        }
85    }
86}
87
88/// Compute the loss for multi-driver crossover optimization
89///
90/// # Arguments
91/// * `data` - DriversLossData containing driver measurements
92/// * `gains` - Gain in dB for each driver
93/// * `crossover_freqs` - Crossover frequencies between successive driver pairs
94/// * `sample_rate` - Sample rate for filter design
95/// * `min_freq` - Minimum frequency for loss evaluation
96/// * `max_freq` - Maximum frequency for loss evaluation
97///
98/// # Returns
99/// * Loss value (lower is better)
100pub fn drivers_flat_loss(
101    data: &DriversLossData,
102    gains: &[f64],
103    crossover_freqs: &[f64],
104    delays: Option<&[f64]>,
105    sample_rate: f64,
106    min_freq: f64,
107    max_freq: f64,
108) -> f64 {
109    // Compute combined response
110    let combined_response =
111        compute_drivers_combined_response(data, gains, crossover_freqs, delays, sample_rate);
112
113    // Normalize the response (subtract the mean in the evaluation range)
114    let mut sum = 0.0;
115    let mut count = 0;
116    for i in 0..data.freq_grid.len() {
117        let freq = data.freq_grid[i];
118        if freq >= min_freq && freq <= max_freq {
119            sum += combined_response[i];
120            count += 1;
121        }
122    }
123    let mean = if count > 0 { sum / count as f64 } else { 0.0 };
124    let normalized = &combined_response - mean;
125
126    // Compute flatness loss (RMS deviation from zero)
127    flat_loss(&data.freq_grid, &normalized, min_freq, max_freq)
128}
129
130#[cfg(test)]
131mod tests {
132    use super::*;
133
134    fn measurement(offset: f64) -> DriverMeasurement {
135        DriverMeasurement {
136            freq: ndarray::Array1::from_vec(vec![20.0, 80.0, 200.0]),
137            spl: ndarray::Array1::from_vec(vec![70.0 + offset; 3]),
138            phase: None,
139        }
140    }
141
142    #[test]
143    fn no_crossover_supports_eight_subwoofers() {
144        let drivers = (0..8).map(|index| measurement(index as f64)).collect();
145        let data = DriversLossData::new(drivers, CrossoverType::None);
146        assert_eq!(data.drivers.len(), 8);
147    }
148
149    #[test]
150    #[should_panic(expected = "at most 4 when using crossovers")]
151    fn crossover_still_rejects_more_than_four_drivers() {
152        let drivers = (0..5).map(|index| measurement(index as f64)).collect();
153        let _ = DriversLossData::new(drivers, CrossoverType::LinkwitzRiley4);
154    }
155}