autoeq_optim/loss/drivers/
drivers_loss_data.rs1use 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#[derive(Debug, Clone)]
9pub struct DriversLossData {
10 pub drivers: Vec<DriverMeasurement>,
12 pub crossover_type: CrossoverType,
14 pub freq_grid: Array1<f64>,
16}
17
18impl DriversLossData {
19 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 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 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 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 let freq_grid = crate::read::create_log_frequency_grid(
75 10 * 10, 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
88pub 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 let combined_response =
111 compute_drivers_combined_response(data, gains, crossover_freqs, delays, sample_rate);
112
113 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 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}