added s11!

data_acq_and_processing/processing/processors/src/bscan_processor.cpp

@@ -6,6 +6,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <limits>
+#include <span>
 #include <string_view>
 #include <utility>
 #include <vector>
@@ -92,15 +93,28 @@ void fft_inplace(std::vector<std::complex<double>>& values, bool inverse) {
     return std::abs(sample);
 }
 
-[[nodiscard]] auto fallback_profile(const ipc::SweepTraceBlock& trace) -> BScanProfile {
-    const std::size_t point_count = std::min(trace.frequency_hz.size(), trace.s21.size());
+[[nodiscard]] auto selected_trace_samples(
+    const ipc::SweepTraceBlock& trace,
+    const ProcessingLiveConfig& live_config
+) -> std::span<const ipc::Complex32> {
+    if (live_config.bscan_channel == "s11") {
+        return trace.s11;
+    }
+    return trace.s21;
+}
+
+[[nodiscard]] auto fallback_profile(
+    const ipc::SweepTraceBlock& trace,
+    std::span<const ipc::Complex32> selected_samples
+) -> BScanProfile {
+    const std::size_t point_count = std::min(trace.frequency_hz.size(), selected_samples.size());
     BScanProfile fallback{};
     fallback.depth_m.reserve(point_count);
     fallback.response.reserve(point_count);
 
     const float denominator = point_count > 1U ? static_cast<float>(point_count - 1U) : 1.0F;
     for (std::size_t index = 0U; index < point_count; ++index) {
-        const auto& sample = trace.s21[index];
+        const auto& sample = selected_samples[index];
         fallback.depth_m.push_back(static_cast<float>(static_cast<float>(index) / denominator));
         fallback.response.push_back(std::sqrt(sample.re * sample.re + sample.im * sample.im));
     }
@@ -111,9 +125,10 @@ void fft_inplace(std::vector<std::complex<double>>& values, bool inverse) {
     const ipc::SweepTraceBlock& trace,
     const ProcessingLiveConfig& live_config
 ) -> BScanProfile {
-    const std::size_t point_count = std::min(trace.frequency_hz.size(), trace.s21.size());
+    const auto selected_samples = selected_trace_samples(trace, live_config);
+    const std::size_t point_count = std::min(trace.frequency_hz.size(), selected_samples.size());
     if (point_count < 2U) {
-        return fallback_profile(trace);
+        return fallback_profile(trace, selected_samples);
     }
 
     const double configured_start_hz = static_cast<double>(live_config.bscan_start_freq_mhz) * 1'000'000.0;
@@ -122,55 +137,55 @@ void fft_inplace(std::vector<std::complex<double>>& values, bool inverse) {
     const double stop_hz = std::max(configured_start_hz, configured_stop_hz);
 
     std::vector<double> filtered_freq_hz{};
-    std::vector<std::complex<double>> filtered_s21{};
+    std::vector<std::complex<double>> filtered_samples{};
     filtered_freq_hz.reserve(point_count);
-    filtered_s21.reserve(point_count);
+    filtered_samples.reserve(point_count);
 
     for (std::size_t index = 0U; index < point_count; ++index) {
         const double frequency_hz = static_cast<double>(trace.frequency_hz[index]);
         if (frequency_hz < start_hz || frequency_hz > stop_hz) {
             continue;
         }
-        const auto& sample = trace.s21[index];
+        const auto& sample = selected_samples[index];
         filtered_freq_hz.push_back(frequency_hz);
-        filtered_s21.emplace_back(static_cast<double>(sample.re), static_cast<double>(sample.im));
+        filtered_samples.emplace_back(static_cast<double>(sample.re), static_cast<double>(sample.im));
     }
 
     if (filtered_freq_hz.size() < 2U) {
-        return fallback_profile(trace);
+        return fallback_profile(trace, selected_samples);
     }
 
     const std::size_t filtered_count = filtered_freq_hz.size();
     const double df = (filtered_freq_hz.back() - filtered_freq_hz.front()) / static_cast<double>(filtered_count - 1U);
     if (df <= 0.0) {
-        return fallback_profile(trace);
+        return fallback_profile(trace, selected_samples);
     }
 
     const auto start_bin = static_cast<std::int64_t>(std::llround(filtered_freq_hz.front() / df));
     if (start_bin < 0) {
-        return fallback_profile(trace);
+        return fallback_profile(trace, selected_samples);
     }
 
     const auto start_index = static_cast<std::size_t>(start_bin);
     if (start_index > (std::numeric_limits<std::size_t>::max() / 2U)) {
-        return fallback_profile(trace);
+        return fallback_profile(trace, selected_samples);
     }
     if (start_index > (std::numeric_limits<std::size_t>::max() - filtered_count + 1U)) {
-        return fallback_profile(trace);
+        return fallback_profile(trace, selected_samples);
     }
 
     const std::size_t min_fft_len = 2U * (start_index + filtered_count - 1U);
     const std::size_t fft_len = next_power_of_two(min_fft_len);
     if (fft_len < min_fft_len || (fft_len & (fft_len - 1U)) != 0U) {
-        return fallback_profile(trace);
+        return fallback_profile(trace, selected_samples);
     }
     if (start_index > fft_len || filtered_count > (fft_len - start_index)) {
-        return fallback_profile(trace);
+        return fallback_profile(trace, selected_samples);
     }
 
     std::vector<std::complex<double>> spectrum(fft_len, std::complex<double>(0.0, 0.0));
     for (std::size_t index = 0U; index < filtered_count; ++index) {
-        spectrum[start_index + index] = filtered_s21[index];
+        spectrum[start_index + index] = filtered_samples[index];
     }
 
     fft_inplace(spectrum, true);