ch_estimator: make cfo compensation optional

In some cases (e.g., PUCCH Format 1), the CFO estimation is not good
enough and compensation is likely to be detrimental. This commit makes
CFO compensation optional.

Author: dvdgrgrtt

include/srsran/phy/upper/signal_processors/signal_processor_factories.h

@@ -94,7 +94,8 @@ class port_channel_estimator_factory
   virtual ~port_channel_estimator_factory() = default;
   virtual std::unique_ptr<port_channel_estimator>
   create(port_channel_estimator_fd_smoothing_strategy fd_smoothing_strategy =
-             port_channel_estimator_fd_smoothing_strategy::filter) = 0;
+             port_channel_estimator_fd_smoothing_strategy::filter,
+         bool complensate_cfo = true) = 0;
 };
 
 std::shared_ptr<port_channel_estimator_factory>

lib/phy/upper/signal_processors/port_channel_estimator_average_impl.cpp

@@ -156,6 +156,7 @@ static unsigned extract_layer_hop_rx_pilots(dmrs_symbol_list&
 /// \param[in]  dmrs_mask         Boolean mask identifying the OFDM symbols carrying DM-RS within the slot.
 /// \param[in]  scs               Subcarrier spacing.
 /// \param[in]  cp_cum_duration   Cumulative duration of all CPs in the slot.
+/// \param[in]  compensate_cfo    Boolean flag to activate the CFO compensation.
 /// \param[in]  first_hop_symbol  Index of the first OFDM symbol of the current hop, within the slot.
 /// \param[in]  last_hop_symbol   Index of the last OFDM symbol of the current hop (not included), within the slot.
 /// \param[in]  hop_offset        Number of OFDM symbols carrying DM-RS in the previous hop.
@@ -169,6 +170,7 @@ static std::pair<float, optional<float>> preprocess_pilots_and_cfo(span<cf_t>
                                                                    const bounded_bitset<MAX_NSYMB_PER_SLOT>& dmrs_mask,
                                                                    const subcarrier_spacing&                 scs,
                                                                    span<const float> cp_cum_duration,
+                                                                   bool              compensate_cfo,
                                                                    unsigned          first_hop_symbol,
                                                                    unsigned          last_hop_symbol,
                                                                    unsigned          hop_offset,
@@ -183,6 +185,7 @@ static std::pair<float, optional<float>> preprocess_pilots_and_cfo(span<cf_t>
 /// \param[in] scs               Subcarrier spacing.
 /// \param[in] cfo               Carrier frequency offset.
 /// \param[in] cp_cum_duration   Cumulative duration of all CPs in the slot.
+/// \param[in] compensate_cfo    Boolean flag to activate the CFO compensation.
 /// \param[in] first_hop_symbol  Index of the first OFDM symbol of the current hop, within the slot.
 /// \param[in] last_hop_symbol   Index of the last OFDM symbol of the current hop (not included), within the slot.
 /// \param[in] hop_symbols       Number of OFDM symbols containing DM-RS pilots in the current hop.
@@ -198,6 +201,7 @@ static float estimate_noise(const dmrs_symbol_list&                   pilots,
                             const subcarrier_spacing&                 scs,
                             optional<float>                           cfo,
                             span<const float>                         cp_cum_duration,
+                            bool                                      compensate_cfo,
                             unsigned                                  first_hop_symbol,
                             unsigned                                  last_hop_symbol,
                             unsigned                                  hop_symbols,
@@ -261,7 +265,7 @@ void port_channel_estimator_average_impl::compute(channel_estimate&           es
       time_alignment_s /= 2.0F;
     }
 
-    if (cfo_normalized.has_value()) {
+    if (compensate_cfo && cfo_normalized.has_value()) {
       // Apply CFO to the estimated channel.
       float cfo = cfo_normalized.value();
       for (unsigned i_symbol = cfg.first_symbol, last_symbol = cfg.first_symbol + cfg.nof_symbols;
@@ -344,6 +348,7 @@ void port_channel_estimator_average_impl::compute_layer_hop(srsran::channel_esti
                                                                                              pattern.symbols,
                                                                                              cfg.scs,
                                                                                              cp_cum_duration,
+                                                                                             compensate_cfo,
                                                                                              first_symbol,
                                                                                              last_symbol,
                                                                                              hop_offset,
@@ -393,6 +398,7 @@ void port_channel_estimator_average_impl::compute_layer_hop(srsran::channel_esti
                               cfg.scs,
                               cfo_hop,
                               cp_cum_duration,
+                              compensate_cfo,
                               first_symbol,
                               last_symbol,
                               nof_dmrs_symbols,
@@ -480,6 +486,7 @@ static std::pair<float, optional<float>> preprocess_pilots_and_cfo(span<cf_t>
                                                                    const bounded_bitset<MAX_NSYMB_PER_SLOT>& dmrs_mask,
                                                                    const subcarrier_spacing&                 scs,
                                                                    span<const float> cp_cum_duration,
+                                                                   bool              compensate_cfo,
                                                                    unsigned          first_hop_symbol,
                                                                    unsigned          last_hop_symbol,
                                                                    unsigned          hop_offset,
@@ -510,9 +517,11 @@ static std::pair<float, optional<float>> preprocess_pilots_and_cfo(span<cf_t>
       std::arg(noisy_phase) / TWOPI / (i_dmrs_1 - i_dmrs_0 + cp_cum_duration[i_dmrs_1] - cp_cum_duration[i_dmrs_0]);
 
   // Compensate the CFO in the first two DM-RS symbols and combine them.
-  srsvec::sc_prod(pilots_lse, std::polar(1.0f, -TWOPI * (i_dmrs_0 + cp_cum_duration[i_dmrs_0]) * cfo), pilots_lse);
-  srsvec::sc_prod(
-      pilot_products, std::polar(1.0f, -TWOPI * (i_dmrs_1 + cp_cum_duration[i_dmrs_1]) * cfo), pilot_products);
+  if (compensate_cfo) {
+    srsvec::sc_prod(pilots_lse, std::polar(1.0f, -TWOPI * (i_dmrs_0 + cp_cum_duration[i_dmrs_0]) * cfo), pilots_lse);
+    srsvec::sc_prod(
+        pilot_products, std::polar(1.0f, -TWOPI * (i_dmrs_1 + cp_cum_duration[i_dmrs_1]) * cfo), pilot_products);
+  }
   srsvec::add(pilots_lse, pilot_products, pilots_lse);
 
   // If there are other DM-RS symbols in the hop, match them with the corresponding transmitted symbols, compensate the
@@ -521,8 +530,10 @@ static std::pair<float, optional<float>> preprocess_pilots_and_cfo(span<cf_t>
     auto combine_pilots = [&, i_dmrs = 2](size_t i_symbol) mutable {
       srsvec::prod_conj(
           rx_pilots.get_symbol(i_dmrs, i_layer), pilots.get_symbol(hop_offset + i_dmrs, i_layer), pilot_products);
-      srsvec::sc_prod(
-          pilot_products, std::polar(1.0f, -TWOPI * (i_symbol + cp_cum_duration[i_symbol]) * cfo), pilot_products);
+      if (compensate_cfo) {
+        srsvec::sc_prod(
+            pilot_products, std::polar(1.0f, -TWOPI * (i_symbol + cp_cum_duration[i_symbol]) * cfo), pilot_products);
+      }
       srsvec::add(pilots_lse, pilot_products, pilots_lse);
       epre += std::real(srsvec::dot_prod(rx_pilots.get_symbol(i_dmrs, i_layer), rx_pilots.get_symbol(i_dmrs, i_layer)));
       ++i_dmrs;
@@ -542,6 +553,7 @@ static float estimate_noise(const dmrs_symbol_list&                   pilots,
                             const subcarrier_spacing&                 scs,
                             optional<float>                           cfo,
                             span<const float>                         cp_cum_duration,
+                            bool                                      compensate_cfo,
                             unsigned                                  first_hop_symbol,
                             unsigned                                  last_hop_symbol,
                             unsigned                                  hop_symbols,
@@ -558,7 +570,7 @@ static float estimate_noise(const dmrs_symbol_list&                   pilots,
   span<cf_t> predicted_obs = span<cf_t>(predicted_obs_buffer).first(estimates.size());
   float      noise_energy  = 0.0F;
 
-  if (cfo.has_value()) {
+  if (compensate_cfo && cfo.has_value()) {
     auto noise_cfo = [&, i_dmrs = 0](size_t i_symbol) mutable {
       span<const cf_t> symbol_pilots    = pilots.get_symbol(hop_offset + i_dmrs, i_layer);
       span<const cf_t> symbol_rx_pilots = rx_pilots.get_symbol(i_dmrs, i_layer);

lib/phy/upper/signal_processors/port_channel_estimator_average_impl.h

@@ -39,8 +39,10 @@ class port_channel_estimator_average_impl : public port_channel_estimator
   /// Constructor - Sets the internal interpolator and inverse DFT processor of size \c DFT_SIZE.
   port_channel_estimator_average_impl(std::unique_ptr<interpolator>                interp,
                                       std::unique_ptr<time_alignment_estimator>    ta_estimator_,
-                                      port_channel_estimator_fd_smoothing_strategy fd_smoothing_strategy_) :
+                                      port_channel_estimator_fd_smoothing_strategy fd_smoothing_strategy_,
+                                      bool                                         compensate_cfo_ = true) :
     fd_smoothing_strategy(fd_smoothing_strategy_),
+    compensate_cfo(compensate_cfo_),
     freq_interpolator(std::move(interp)),
     ta_estimator(std::move(ta_estimator_))
   {
@@ -72,6 +74,9 @@ class port_channel_estimator_average_impl : public port_channel_estimator
   /// Frequency domain smoothing strategy.
   port_channel_estimator_fd_smoothing_strategy fd_smoothing_strategy;
 
+  /// Boolean flag for activating CFO compensation (active when true).
+  bool compensate_cfo;
+
   /// \brief Interpolator.
   ///
   /// When DM-RS pilots do not occupy all REs in an OFDM symbol, the interpolator is used to estimate the channel of the

lib/phy/upper/signal_processors/signal_processor_factories.cpp

@@ -111,7 +111,7 @@ class dmrs_pucch_estimator_sw_factory : public dmrs_pucch_estimator_factory
     return std::make_unique<dmrs_pucch_processor_format1_impl>(
         prg_factory->create(),
         lpc_factory->create(m, delta, alphas),
-        ch_estimator_factory->create(port_channel_estimator_fd_smoothing_strategy::mean));
+        ch_estimator_factory->create(port_channel_estimator_fd_smoothing_strategy::mean, /*compensate_cfo =*/false));
   }
 
   std::unique_ptr<dmrs_pucch_processor> create_format2() override
@@ -230,13 +230,13 @@ class port_channel_estimator_factory_sw : public port_channel_estimator_factory
     srsran_assert(ta_estimator_factory, "Invalid TA estimator factory.");
   }
 
-  std::unique_ptr<port_channel_estimator>
-  create(port_channel_estimator_fd_smoothing_strategy fd_smoothing_strategy) override
+  std::unique_ptr<port_channel_estimator> create(port_channel_estimator_fd_smoothing_strategy fd_smoothing_strategy,
+                                                 bool                                         compensate_cfo) override
   {
     std::unique_ptr<interpolator> interp = create_interpolator();
 
     return std::make_unique<port_channel_estimator_average_impl>(
-        std::move(interp), ta_estimator_factory->create(), fd_smoothing_strategy);
+        std::move(interp), ta_estimator_factory->create(), fd_smoothing_strategy, compensate_cfo);
   }
 
 private:
@@ -366,4 +366,4 @@ class logging_nzp_csi_rs_generator_decorator : public nzp_csi_rs_generator
 std::unique_ptr<nzp_csi_rs_generator> nzp_csi_rs_generator_factory::create(srslog::basic_logger& logger)
 {
   return std::make_unique<logging_nzp_csi_rs_generator_decorator>(logger, create());
-}
+}