added pass through s11

data_acq_and_processing/preprocessing/calibration_master/include/calibration_master.hpp

@@ -1,32 +1,51 @@
 #pragma once
 
 #include <memory>
+#include <span>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 #include "calibrator_interface.hpp"
+#include "channel_bundle_support.hpp"
 #include "shared_types.hpp"
 
 namespace radar::preprocessing {
 
 class CalibrationMaster {
   public:
-    // `calibrator` encapsulates the actual calibration algorithm (v1: through).
-    explicit CalibrationMaster(std::unique_ptr<CalibratorInterface> calibrator);
+    // `s21_calibrator` encapsulates the S21 calibration algorithm.
+    explicit CalibrationMaster(std::unique_ptr<CalibratorInterface> s21_calibrator);
 
-    // Loads a serialized raw sweep bundle with one calibration standard per combo.
-    void load_bundle(const std::string& path);
+    // Loads a serialized raw sweep bundle with one S21 calibration standard per combo.
+    void load_s21_calibration_bundle(const std::string& path);
+    // Loads optional one-port OSL calibration data for S11 from raw sweep bundles.
+    void load_s11_calibration_bundle(
+        const std::string& open_path,
+        const std::string& short_path,
+        const std::string& load_path
+    );
     // Ensures all runtime combos are present in loaded standards.
     void validate_combos(const std::vector<ipc::ComboKey>& combos) const;
-    // Applies calibration standard corresponding to measured trace combo.
-    [[nodiscard]] auto apply(const ipc::SweepTraceBlock& measured_trace) const -> ipc::SweepTraceBlock;
+    // Applies both channel calibrations to one measured trace.
+    [[nodiscard]] auto apply_to_trace(const ipc::SweepTraceBlock& measured_trace) const -> ipc::SweepTraceBlock;
+    [[nodiscard]] auto apply_s21(
+        const ipc::ComboKey& combo,
+        std::span<const float> frequency_hz,
+        const std::vector<ipc::Complex32>& measured_s21
+    ) const -> std::vector<ipc::Complex32>;
+    [[nodiscard]] auto apply_s11(
+        const ipc::ComboKey& combo,
+        std::span<const float> frequency_hz,
+        const std::vector<ipc::Complex32>& measured_s11
+    ) const -> std::vector<ipc::Complex32>;
+    [[nodiscard]] auto has_s11_calibration() const noexcept -> bool;
 
   private:
-    std::unique_ptr<CalibratorInterface> calibrator_impl_;
-    std::unordered_map<ipc::ComboKey, ipc::SweepTraceBlock, ipc::ComboKeyHash> standards_by_combo_{};
+    std::unique_ptr<CalibratorInterface> s21_calibrator_;
+    S21CalibrationBundle s21_calibration_bundle_{};
+    S11CalibrationBundle s11_calibration_bundle_{};
 };
 
-[[nodiscard]] auto make_through_calibrator() -> std::unique_ptr<CalibratorInterface>;
+[[nodiscard]] auto make_s21_through_calibrator() -> std::unique_ptr<CalibratorInterface>;
 
 }  // namespace radar::preprocessing

data_acq_and_processing/preprocessing/calibration_master/include/channel_bundle_support.hpp

@@ -0,0 +1,91 @@
+#pragma once
+
+#include <span>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "shared_types.hpp"
+
+namespace radar::preprocessing {
+
+class CalibratorInterface;
+
+struct ChannelTrace {
+    std::vector<float> frequency_hz{};
+    std::vector<ipc::Complex32> samples{};
+};
+
+class S21CalibrationBundle {
+  public:
+    void load(const std::string& path);
+
+    [[nodiscard]] auto is_enabled() const noexcept -> bool;
+    void validate_combos(const std::vector<ipc::ComboKey>& combos) const;
+    [[nodiscard]] auto apply(
+        const ipc::ComboKey& combo,
+        std::span<const float> frequency_hz,
+        const std::vector<ipc::Complex32>& measured,
+        const CalibratorInterface& calibrator
+    ) const -> std::vector<ipc::Complex32>;
+
+  private:
+    [[nodiscard]] auto resolve(const ipc::ComboKey& combo) const -> const ChannelTrace&;
+
+    std::unordered_map<ipc::ComboKey, ChannelTrace, ipc::ComboKeyHash> traces_by_combo_{};
+};
+
+class S21ReferenceBundle {
+  public:
+    void load(const std::string& path);
+
+    [[nodiscard]] auto is_enabled() const noexcept -> bool;
+    void validate_combos(const std::vector<ipc::ComboKey>& combos) const;
+    [[nodiscard]] auto resolve(const ipc::ComboKey& combo) const -> const ChannelTrace&;
+
+  private:
+    std::unordered_map<ipc::ComboKey, ChannelTrace, ipc::ComboKeyHash> traces_by_combo_{};
+};
+
+class S11CalibrationBundle {
+  public:
+    struct Coefficients {
+        std::vector<float> frequency_hz{};
+        std::vector<ipc::Complex32> directivity{};
+        std::vector<ipc::Complex32> source_match{};
+        std::vector<ipc::Complex32> reflection_tracking{};
+    };
+
+    void load(
+        const std::string& open_path,
+        const std::string& short_path,
+        const std::string& load_path
+    );
+
+    [[nodiscard]] auto is_enabled() const noexcept -> bool;
+    void validate_combos(const std::vector<ipc::ComboKey>& combos) const;
+    [[nodiscard]] auto apply(
+        const ipc::ComboKey& combo,
+        std::span<const float> frequency_hz,
+        const std::vector<ipc::Complex32>& measured
+    ) const -> std::vector<ipc::Complex32>;
+
+  private:
+    [[nodiscard]] auto resolve(const ipc::ComboKey& combo) const -> const Coefficients&;
+
+    std::unordered_map<ipc::ComboKey, Coefficients, ipc::ComboKeyHash> coefficients_by_combo_{};
+};
+
+class S11ReferenceBundle {
+  public:
+    void load(const std::string& path);
+
+    [[nodiscard]] auto is_enabled() const noexcept -> bool;
+    void validate_combos(const std::vector<ipc::ComboKey>& combos) const;
+    [[nodiscard]] auto resolve(const ipc::ComboKey& combo) const -> const ChannelTrace&;
+
+  private:
+    std::unordered_map<ipc::ComboKey, ChannelTrace, ipc::ComboKeyHash> traces_by_combo_{};
+};
+
+}  // namespace radar::preprocessing