Add object calibration

data_acq_and_processing/preprocessing/calibration_master/include/channel_bundle_support.hpp

@@ -50,6 +50,18 @@ class S21ReferenceBundle {
     std::unordered_map<ipc::ComboKey, ChannelTrace, ipc::ComboKeyHash> traces_by_combo_{};
 };
 
+// Object-derived MIMO correction, exported on each pair's runtime frequency grid.
+// An empty path disables it; enabled bundles must cover every active pair.
+class S21ObjectCalibrationBundle {
+  public:
+    void load(const std::string& path);
+    void validate_combos(const std::vector<ipc::ComboKey>& combos) const;
+    void apply(ipc::SweepTraceBlock& trace) const;
+
+  private:
+    std::unordered_map<ipc::ComboKey, ChannelTrace, ipc::ComboKeyHash> factors_by_combo_{};
+};
+
 class S11CalibrationBundle {
   public:
     struct Coefficients {

data_acq_and_processing/preprocessing/calibration_master/src/channel_bundle_support.cpp

@@ -8,6 +8,7 @@
 #include <fstream>
 #include <iostream>
 #include <iterator>
+#include <limits>
 #include <span>
 #include <stdexcept>
 #include <string>
@@ -197,11 +198,11 @@ template <typename TValue>
 auto resolve_required(
     const std::unordered_map<ipc::ComboKey, TValue, ipc::ComboKeyHash>& values_by_combo,
     const ipc::ComboKey& combo,
-    const std::string& value_label
+    const char* value_label
 ) -> const TValue& {
     const auto found = values_by_combo.find(combo);
     if (found == values_by_combo.end()) {
-        throw std::runtime_error(value_label + " is missing for combo " + combo_to_string(combo));
+        throw std::runtime_error(std::string(value_label) + " is missing for combo " + combo_to_string(combo));
     }
     return found->second;
 }
@@ -345,6 +346,38 @@ auto S21ReferenceBundle::resolve(const ipc::ComboKey& combo) const -> const Chan
     return resolve_required(traces_by_combo_, combo, "S21 reference trace");
 }
 
+void S21ObjectCalibrationBundle::load(const std::string& path) {
+    if (path.empty()) {
+        factors_by_combo_.clear();
+        return;
+    }
+    factors_by_combo_ = load_channel_traces(path, "S21 object calibration", RawTraceChannel::S21);
+}
+
+void S21ObjectCalibrationBundle::validate_combos(const std::vector<ipc::ComboKey>& combos) const {
+    validate_bundle_combos(factors_by_combo_, combos, "S21 object calibration bundle");
+}
+
+void S21ObjectCalibrationBundle::apply(ipc::SweepTraceBlock& trace) const {
+    if (factors_by_combo_.empty()) { return; }
+    const auto& factors = resolve_required(factors_by_combo_, trace.combo, "S21 object calibration");
+    ensure_frequency_axis_match(factors.frequency_hz, trace.frequency_hz, "S21 object calibration");
+    if (trace.s21.size() != factors.samples.size()) {
+        throw std::runtime_error("S21 object calibration vector size mismatch");
+    }
+    for (std::size_t index = 0; index < trace.s21.size(); ++index) {
+        const auto value = trace.s21[index];
+        const auto factor = factors.samples[index];
+        const auto corrected = std::complex<double>(value.re, value.im) * std::complex<double>(factor.re, factor.im);
+        if (!std::isfinite(corrected.real()) || !std::isfinite(corrected.imag()) ||
+            std::abs(corrected.real()) > std::numeric_limits<float>::max() ||
+            std::abs(corrected.imag()) > std::numeric_limits<float>::max()) {
+            throw std::runtime_error("S21 object calibration result must fit finite float32");
+        }
+        trace.s21[index] = {.re = static_cast<float>(corrected.real()), .im = static_cast<float>(corrected.imag())};
+    }
+}
+
 void S11CalibrationBundle::load(
     const std::string& open_path,
     const std::string& short_path,