ru_ofh: set subcarrier_rms_backoff_dB default behaviour

Author: ddries

apps/units/flexible_o_du/split_7_2/helpers/ru_ofh_config.h

@@ -49,8 +49,11 @@ struct ru_ofh_scaling_config {
   ///
   /// \f$ $$P_{BW2}\text{ [dBFS]}=P_{BW1}\text{ [dBFS]} - 10\log_{10}{\bigg(\frac{BW2}{BW1}\bigg)}\f$
   ///
+  /// If no value is specified, then the bandwidth is normalized based on the number of subcarriers, i.e.,
+  /// the back-off is set to \f$10\log_{10}(12 N_{RB})}\f$.
+  ///
   /// \warning Check the RU documentation before settings this parameter, as incorrect values may damage the RU.
-  float subcarrier_rms_backoff_dB = 30.0f;
+  std::optional<float> subcarrier_rms_backoff_dB;
 };
 
 /// Configuration parameters related to the scaling of the IQ symbols in the DL OFH resource grid (legacy version).

apps/units/flexible_o_du/split_7_2/helpers/ru_ofh_config_cli11_schema.cpp

@@ -194,16 +194,22 @@ static void configure_cli11_ru_ofh_base_cell_args(CLI::App& app, ru_ofh_unit_bas
         return "";
       });
 
-  app.add_option_function<float>(
+  app.add_option_function<std::string>(
          "--subcarrier_rms_backoff_dB",
-         [&config](float value) {
+         [&config](std::string value) {
            if (!std::holds_alternative<ru_ofh_scaling_config>(config.iq_scaling_config)) {
              config.iq_scaling_config.emplace<ru_ofh_scaling_config>();
            }
-           std::get<ru_ofh_scaling_config>(config.iq_scaling_config).subcarrier_rms_backoff_dB = value;
+           // By default, subcarrier backoff is set to 'auto', i.e., normalize bandwidth based on number of
+           // subcarriers. If another value is specified, it is parsed.
+           if (value != "auto") {
+             // It is safe to convert the value without try-catch because it has been already checked.
+             float backoff                                                                       = std::stof(value);
+             std::get<ru_ofh_scaling_config>(config.iq_scaling_config).subcarrier_rms_backoff_dB = backoff;
+           }
          },
          "Power back-off attenuation applied to all subcarriers with respect to the RU reference level")
-      ->check(CLI::Range(0.0f, std::numeric_limits<float>::infinity()))
+      ->check(CLI::Range(0.0f, std::numeric_limits<float>::infinity()) | CLI::IsMember({"auto"}))
       ->check([&config](const std::string& value) -> std::string {
         if (std::holds_alternative<ru_ofh_legacy_scaling_config>(config.iq_scaling_config)) {
           return "IQ scaling and RU subcarrier back-off cannot be set at the same time";
@@ -282,8 +288,8 @@ static void configure_cli11_ru_ofh_base_cell_args(CLI::App& app, ru_ofh_unit_bas
           "RU IQ scaling parameter cannot be used if RU reference level and subcarrier RMS back-off are set\n");
     }
 
-    if (ref_level_count != backoff_count) {
-      report_error("RU reference level and subcarrier RMS back-off must be set together\n");
+    if (backoff_count > 0 && ref_level_count == 0) {
+      report_error("RU reference level is required if subcarrier RMS back-off is set\n");
     }
   };
 

apps/units/flexible_o_du/split_7_2/helpers/ru_ofh_config_translator.cpp

@@ -147,9 +147,16 @@ static void generate_config(ru_ofh_configuration&                            out
           legacy_scaling_config->iq_scaling / std::sqrt(static_cast<float>(nof_prbs * NOF_SUBCARRIERS_PER_RB));
     } else if (const auto* scaling_config = std::get_if<ru_ofh_scaling_config>(&ofh_cell_cfg.cell.iq_scaling_config)) {
       // Take the RU reference level, apply the configured subcarrier back-off and convert the result into a linear
-      // scaling factor. Do not apply any bandwidth normalization.
+      // scaling factor. If no subcarrier back-off is configured, apply a bandwidth power normalization factor.
+      unsigned nof_prbs =
+          get_max_Nprb(bs_channel_bandwidth_to_MHz(sector_cfg.bw), sector_cfg.scs, frequency_range::FR1);
+      float subcarrier_rms_backoff_dB = convert_power_to_dB(nof_prbs * NOF_SUBCARRIERS_PER_RB);
+      // If no value of subcarrier backoff is defined, the default bandwidth normalization is used.
+      if (scaling_config->subcarrier_rms_backoff_dB) {
+        subcarrier_rms_backoff_dB = *scaling_config->subcarrier_rms_backoff_dB;
+      }
       sector_cfg.iq_scaling =
-          convert_dB_to_amplitude(scaling_config->ru_reference_level_dBFS - scaling_config->subcarrier_rms_backoff_dB);
+          convert_dB_to_amplitude(scaling_config->ru_reference_level_dBFS - subcarrier_rms_backoff_dB);
     } else {
       report_fatal_error(
           "Either the iq_scaling or the RU reference level and subarrier RMS backoff must be configured.");

apps/units/flexible_o_du/split_7_2/helpers/ru_ofh_config_validator.cpp

@@ -43,9 +43,10 @@ static bool validate_scaling_params(
       return false;
     }
 
-    if (!backoff_range.contains(scaling_params->subcarrier_rms_backoff_dB)) {
+    if (scaling_params->subcarrier_rms_backoff_dB &&
+        !backoff_range.contains(*scaling_params->subcarrier_rms_backoff_dB)) {
       fmt::print("Subcarrier back-off, i.e., {} dB lies outside of the valid range {}\n",
-                 scaling_params->subcarrier_rms_backoff_dB,
+                 *scaling_params->subcarrier_rms_backoff_dB,
                  backoff_range);
       return false;
     }

apps/units/flexible_o_du/split_7_2/helpers/ru_ofh_config_yaml_writer.cpp

@@ -99,8 +99,13 @@ static YAML::Node build_ru_ofh_cell_section(const ru_ofh_unit_cell_config& confi
   node["enable_ul_static_compr_hdr"] = config.cell.is_uplink_static_comp_hdr_enabled;
   node["enable_dl_static_compr_hdr"] = config.cell.is_downlink_static_comp_hdr_enabled;
   if (const auto* scaling_params = std::get_if<ru_ofh_scaling_config>(&config.cell.iq_scaling_config)) {
-    node["ru_reference_level_dBFS"]   = scaling_params->ru_reference_level_dBFS;
-    node["subcarrier_rms_backoff_dB"] = scaling_params->subcarrier_rms_backoff_dB;
+    node["ru_reference_level_dBFS"] = scaling_params->ru_reference_level_dBFS;
+
+    if (scaling_params->subcarrier_rms_backoff_dB) {
+      node["subcarrier_rms_backoff_dB"] = *scaling_params->subcarrier_rms_backoff_dB;
+    } else {
+      node["subcarrier_rms_backoff_dB"] = "auto";
+    }
   } else if (const auto* legacy_scaling_params =
                  std::get_if<ru_ofh_legacy_scaling_config>(&config.cell.iq_scaling_config)) {
     node["iq_scaling"] = legacy_scaling_params->iq_scaling;