Add channel estimator time-domain interpolation strategy

Author: Xavier Arteaga

+srsMEX/+phy/@srsMultiPortChannelEstimator/srsMultiPortChannelEstimator.m

@@ -63,6 +63,8 @@
         ImplementationType (1, :) char     {mustBeMember(ImplementationType, {'MEX', 'noMEX'})} = 'MEX'
         %Frequency domain smoothing strategy ('filter', 'mean', 'none').
         Smoothing          (1, :) char     {mustBeMember(Smoothing, {'filter', 'mean', 'none'})} = 'filter'
+        %Time domain interpolation strategy ('average', 'interpolate').
+        Interpolation      (1, :) char     {mustBeMember(Interpolation, {'average', 'interpolate'})} = 'average'
         %Boolean flat: compensate CFO if true.
         CompensateCFO      (1, 1) logical      = true
     end % properties (Nontunable)
@@ -80,7 +82,7 @@ function setupImpl(obj)
         %   constructs the channel estimator object inside the MEX function.
             if strcmp(obj.ImplementationType, 'MEX')
                 obj.stepMethod = @stepMEX;
-                obj.multiport_channel_estimator_mex('new', obj.Smoothing, obj.CompensateCFO);
+                obj.multiport_channel_estimator_mex('new', obj.Smoothing, obj.Interpolation, obj.CompensateCFO);
             else
                 obj.stepMethod = @stepPLAIN;
             end

+srsMEX/source/lib/phy/upper/signal_processors/multiport_channel_estimator_mex.cpp

@@ -34,34 +34,43 @@ using namespace srsran_matlab;
 
 void MexFunction::method_new(ArgumentList outputs, ArgumentList inputs)
 {
-  constexpr unsigned NOF_INPUTS = 3;
+  constexpr unsigned NOF_INPUTS = 4;
   if (inputs.size() != NOF_INPUTS) {
     mex_abort("Wrong number of inputs: expected {}, provided {}.", NOF_INPUTS, inputs.size());
   }
 
   if (inputs[1].getType() != ArrayType::CHAR) {
     mex_abort("Input 'smoothing' must be a string.");
   }
-  std::string                                  smoothing_string = static_cast<CharArray>(inputs[1]).toAscii();
-  port_channel_estimator_fd_smoothing_strategy smoothing        = port_channel_estimator_fd_smoothing_strategy::none;
-  if (smoothing_string == "filter") {
-    smoothing = port_channel_estimator_fd_smoothing_strategy::filter;
-  } else if (smoothing_string == "mean") {
-    smoothing = port_channel_estimator_fd_smoothing_strategy::mean;
-  } else if (smoothing_string != "none") {
-    mex_abort("Unknown smoothing strategy {}", smoothing_string);
+  std::string                                  fd_smoothing_string = static_cast<CharArray>(inputs[1]).toAscii();
+  port_channel_estimator_fd_smoothing_strategy fd_smoothing        = port_channel_estimator_fd_smoothing_strategy::none;
+  if (fd_smoothing_string == "filter") {
+    fd_smoothing = port_channel_estimator_fd_smoothing_strategy::filter;
+  } else if (fd_smoothing_string == "mean") {
+    fd_smoothing = port_channel_estimator_fd_smoothing_strategy::mean;
+  } else if (fd_smoothing_string != "none") {
+    mex_abort("Unknown FD smoothing strategy {}", fd_smoothing_string);
   }
 
-  if ((inputs[2].getType() != ArrayType::LOGICAL) && (inputs[2].getNumberOfElements() > 1)) {
+  std::string td_interpolation_string = static_cast<CharArray>(inputs[2]).toAscii();
+  port_channel_estimator_td_interpolation_strategy td_interpolation =
+      port_channel_estimator_td_interpolation_strategy::average;
+  if (td_interpolation_string == "interpolate") {
+    td_interpolation = port_channel_estimator_td_interpolation_strategy::interpolate;
+  } else if (td_interpolation_string != "average") {
+    mex_abort("Unknown TD interpolation strategy {}", td_interpolation_string);
+  }
+
+  if ((inputs[3].getType() != ArrayType::LOGICAL) && (inputs[3].getNumberOfElements() > 1)) {
     mex_abort("Input 'compensateCFO' should be a scalar logical.");
   }
-  bool compensate_cfo = static_cast<TypedArray<bool>>(inputs[2])[0];
+  bool compensate_cfo = static_cast<TypedArray<bool>>(inputs[3])[0];
 
   if (!outputs.empty()) {
     mex_abort("Wrong number of outputs: expected 0, provided {}.", outputs.size());
   }
 
-  estimator = create_port_channel_estimator(smoothing, compensate_cfo);
+  estimator = create_port_channel_estimator(fd_smoothing, td_interpolation, compensate_cfo);
 
   // Ensure the estimator was created properly.
   if (!estimator) {

+srsMEX/source/lib/phy/upper/signal_processors/multiport_channel_estimator_mex.h

@@ -103,13 +103,15 @@ class MexFunction : public srsran_mex_dispatcher
 };
 
 std::unique_ptr<srsran::port_channel_estimator>
-create_port_channel_estimator(srsran::port_channel_estimator_fd_smoothing_strategy smoothing, bool compensate_cfo)
+create_port_channel_estimator(srsran::port_channel_estimator_fd_smoothing_strategy     fd_smoothing,
+                              srsran::port_channel_estimator_td_interpolation_strategy td_interpolation,
+                              bool                                                     compensate_cfo)
 {
   using namespace srsran;
   std::shared_ptr<dft_processor_factory>            dft_factory = create_dft_processor_factory_fftw_slow();
   std::shared_ptr<time_alignment_estimator_factory> ta_est_factory =
       create_time_alignment_estimator_dft_factory(dft_factory);
   std::shared_ptr<port_channel_estimator_factory> estimator_factory =
       create_port_channel_estimator_factory_sw(ta_est_factory);
-  return estimator_factory->create(smoothing, compensate_cfo);
+  return estimator_factory->create(fd_smoothing, td_interpolation, compensate_cfo);
 }

apps/simulators/PUSCHBLER/PUSCHBLER.m

@@ -201,6 +201,9 @@
         %Bit-width of the compressed IQ samples.
         %   Only applies if ApplyOFHCompression is set to true.
         CompIQwidth (1, 1) double {mustBeInteger, mustBeInRange(CompIQwidth, 1, 16)} = 9
+        %Time-domain interpolation strategy ('average', 'interpolate').
+        %   Valid only for SRS estimator.
+        Interpolation (1, :) char {mustBeMember(Interpolation, {'average', 'interpolate'})} = 'average'
     end % of properties (Nontunable)
 
     properties % Tunable
@@ -638,7 +641,7 @@ function stepImpl(obj, SNRIn, nFrames)
             if useSRSDecoder
                 srsDemodulatePUSCH = srsMEX.phy.srsPUSCHDemodulator;
                 srsChannelEstimate = srsMEX.phy.srsMultiPortChannelEstimator(ImplementationType = obj.SRSEstimatorType, ...
-                    Smoothing = 'filter', CompensateCFO = true);
+                    Smoothing = 'filter', Interpolation = obj.Interpolation, CompensateCFO = true);
             end
 
             % %%% Simulation loop.