some fixes

data_acq_and_processing/preprocessing/calibration_master/src/channel_bundle_support.cpp

@@ -6,6 +6,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <fstream>
+#include <iostream>
 #include <iterator>
 #include <span>
 #include <stdexcept>
@@ -26,6 +27,10 @@ enum class RawTraceChannel {
 constexpr float kFrequencyRelativeTolerance = 1e-5F;
 constexpr float kFrequencyAbsoluteTolerance = 1e-3F;
 constexpr float kComplexMagnitudeSquaredEpsilon = 1e-12F;
+// #30: OSL denominator must be well conditioned relative to the magnitudes of the terms forming it.
+constexpr float kOslRelativeConditioning = 1e-6F;
+// #30: maximum fraction of degenerate (fallback) OSL points tolerated per combo before load fails.
+constexpr float kOslMaxDegenerateFraction = 0.05F;
 
 [[nodiscard]] auto combo_to_string(const ipc::ComboKey& combo) -> std::string {
     return "input=" + std::to_string(combo.input_pos) + " output=" + std::to_string(combo.output_pos);
@@ -139,7 +144,14 @@ void ensure_frequency_axis_match(
     std::unordered_map<ipc::ComboKey, ChannelTrace, ipc::ComboKeyHash> traces_by_combo{};
     traces_by_combo.reserve(collection.traces.size());
     for (const auto& trace : collection.traces) {
-        traces_by_combo.insert_or_assign(trace.combo, to_channel_trace(trace, channel, bundle_label));
+        // #47: reject duplicate combos instead of silently overwriting an earlier trace.
+        const auto inserted =
+            traces_by_combo.insert({trace.combo, to_channel_trace(trace, channel, bundle_label)});
+        if (!inserted.second) {
+            throw std::runtime_error(
+                bundle_label + " bundle contains duplicate combo " + combo_to_string(trace.combo) + ": " + path
+            );
+        }
     }
 
     if (traces_by_combo.empty()) {
@@ -212,17 +224,30 @@ void ensure_combo_coverage(
     coefficients.source_match.resize(open_trace.frequency_hz.size());
     coefficients.reflection_tracking.resize(open_trace.frequency_hz.size());
 
+    // #30: track degenerate points so silently-substituted fallback coefficients cannot pass unnoticed.
+    std::size_t degenerate_points = 0;
     for (std::size_t index = 0; index < open_trace.frequency_hz.size(); ++index) {
         const auto load = to_std_complex(load_trace.samples[index]);
         const auto open_delta = to_std_complex(open_trace.samples[index]) - load;
         const auto short_delta = to_std_complex(short_trace.samples[index]) - load;
         const auto denominator = open_delta - short_delta;
 
+        // #30: require the denominator to be well conditioned both absolutely and relative to the
+        // magnitudes of the open/short deltas it is formed from, so near-cancellations are rejected.
+        const auto denominator_norm = std::norm(denominator);
+        const auto relative_scale = std::max(std::norm(open_delta), std::norm(short_delta));
+        const auto relative_threshold = relative_scale * (kOslRelativeConditioning * kOslRelativeConditioning);
+
         std::complex<float> source_match = std::complex<float>(0.0F, 0.0F);
         std::complex<float> reflection_tracking = std::complex<float>(1.0F, 0.0F);
-        if (std::norm(denominator) > kComplexMagnitudeSquaredEpsilon) {
+        if (denominator_norm > kComplexMagnitudeSquaredEpsilon && denominator_norm > relative_threshold) {
             source_match = (open_delta + short_delta) / denominator;
             reflection_tracking = open_delta * (std::complex<float>(1.0F, 0.0F) - source_match);
+        } else {
+            // #30: degenerate point — log the offending combo/frequency and fall back to a pass-through.
+            ++degenerate_points;
+            std::cerr << "S11 calibration: degenerate OSL point for combo " << combo_to_string(combo)
+                      << " at " << open_trace.frequency_hz[index] << " Hz (ill-conditioned denominator)\n";
         }
 
         coefficients.directivity[index] = load_trace.samples[index];
@@ -230,6 +255,20 @@ void ensure_combo_coverage(
         coefficients.reflection_tracking[index] = from_std_complex(reflection_tracking);
     }
 
+    // #30: refuse to load a calibration whose per-combo fallback fraction exceeds the tolerated threshold.
+    if (!open_trace.frequency_hz.empty()) {
+        const auto degenerate_fraction =
+            static_cast<float>(degenerate_points) / static_cast<float>(open_trace.frequency_hz.size());
+        if (degenerate_fraction > kOslMaxDegenerateFraction) {
+            throw std::runtime_error(
+                "S11 calibration for combo " + combo_to_string(combo) + " has " +
+                std::to_string(degenerate_points) + " of " +
+                std::to_string(open_trace.frequency_hz.size()) +
+                " degenerate OSL points (fraction exceeds tolerance)"
+            );
+        }
+    }
+
     return coefficients;
 }
 
@@ -301,6 +340,8 @@ void S11CalibrationBundle::load(
     coefficients_by_combo_.clear();
 
     if (open_path.empty() && short_path.empty() && load_path.empty()) {
+        // #38: S11 calibration disabled because no OSL paths were provided; surface it instead of silently skipping.
+        std::cerr << "S11 calibration: no open/short/load bundle paths provided; reflection correction disabled\n";
         return;
     }
     if (open_path.empty() || short_path.empty() || load_path.empty()) {
@@ -384,6 +425,8 @@ void S11ReferenceBundle::load(const std::string& path) {
     traces_by_combo_.clear();
 
     if (path.empty()) {
+        // #38: S11 reference disabled because no path was provided; surface it instead of silently skipping.
+        std::cerr << "S11 reference: no bundle path provided; reference normalization disabled\n";
         return;
     }