draft multi-roc level pedestals

Author: tomeichlersmith

app/tool/algorithm/level_pedestals.cxx

@@ -7,25 +7,6 @@
 
 namespace pflib::algorithm {
 
-/**
- * Retrieve the ADC sample for the input channel from the input event packet
- */
-static int get_adc(const pflib::packing::MultiSampleECONDEventPacket& p,
-                   int ch) {
-  // Use link specific channel calculation
-  // TODO: 348
-  // Use the "Sample Of Interest" inside the EventPacket
-  // TODO this is only true if we only have one ROC's channels enabled
-  //      in the ECON-D. In the more realistic case, we should get the
-  //      link indices depending on which ROC we are aligning
-  int i_link = ch / 36;  // 0 or 1
-  int i_ch = ch % 36;    // 0 - 35
-
-  // ECONDEventPacket.h defines channel differently to SingleROCEventPacket.h
-  // because it can have more than 2 links readout
-  return p.samples[p.i_soi].channel(i_link, i_ch).adc();
-}
-
 /**
  * get the medians of the channel ADC values
  *
@@ -59,8 +40,8 @@ static std::array<int, 72> get_adc_medians(
   return medians;
 }
 
-std::map<std::string, std::map<std::string, uint64_t>> level_pedestals(
-    Target* tgt, ROC roc) {
+std::map<int, std::map<std::string, std::map<std::string, uint64_t>>>
+level_pedestals(Target* tgt) {
   static auto the_log_{::pflib::logging::get("level_pedestals")};
 
   /// do three runs of 100 samples each to have well defined pedestals
@@ -70,118 +51,166 @@ std::map<std::string, std::map<std::string, uint64_t>> level_pedestals(
   pflib_log(info) << "Using DAQ format mode: "
                   << static_cast<int>(pftool::state.daq_format_mode);
 
-  std::array<int, 2> target;
-  std::array<int, 72> baseline, highend, lowend;
+  // each output stream ("half" of a ROC) has its own target pedestal value
+  std::map<int, std::array<int, 2>> target;
+  // each channel has measurements at different parameter points
+  std::map<int, std::array<int, 72>> baseline, highend, lowend;
 
-  /// TODO for multi-ROC set ups, we could dynamically determine the number
-  //       of ROCs and the number of channels from the Target
-  DecodeAndBuffer buffer{n_events, 2};
+  DecodeAndBuffer buffer{n_events, tgt->nrocs()*2};
 
   {  // baseline run scope
     pflib_log(info) << "100 event baseline run";
-    auto test_handle = roc.testParameters()
-                           .add_all_channels("SIGN_DAC", 0)
-                           .add_all_channels("DACB", 0)
-                           .add_all_channels("TRIM_INV", 0)
-                           .apply();
+
+    std::map<std::string, std::map<std::string, uint64_t>> parameters;
+    for (int ch{0}; ch < 72; ch++) {
+      std::string ch_str{"CH_"+std::to_string(ch)};
+      parameters[ch_str]["SIGN_DAC"] = 0;
+      parameters[ch_str]["DACB"] = 0;
+      parameters[ch_str]["TRIM_INV"] = 0;
+    }
+
+    std::map<int, std::map<int, std::map<int, uint8_t>>> prior_registers;
+    for (int i_roc : tgt->roc_ids()) {
+      prior_registers[i_roc] = tgt->roc(i_roc).applyParameters(parameters);
+    }
+
     daq_run(tgt, "PEDESTAL", buffer, n_events, 100);
     pflib_log(trace) << "baseline run done, getting channel medians";
-    auto medians = get_adc_medians(buffer.get_buffer());
+    std::map<int, std::array<int, 72>> medians;
+    for (int i_roc : tgt->roc_ids()) {
+      medians[i_roc] = get_adc_medians(i_roc, tgt->getRocErxMapping(), buffer.get_buffer());
+    }
     baseline = medians;
     pflib_log(trace) << "got channel medians, getting link medians";
-    for (int i_link{0}; i_link < 2; i_link++) {
-      auto start{medians.begin() + 36 * i_link};
-      auto end{start + 36};
-      auto halfway{start + 18};
-      std::nth_element(start, halfway, end);
-      target[i_link] = *halfway;
+    for (int i_half{0}; i_half < 2; i_half++) {
+      for (int i_roc : tgt->roc_ids()) {
+        auto start{medians.at(i_roc).begin() + 36 * i_half};
+        auto end{start + 36};
+        auto halfway{start + 18};
+        std::nth_element(start, halfway, end);
+        target[i_roc][i_half] = *halfway;
+      }
+    }
+    pflib_log(trace) << "got medians per half";
+
+    for (int i_roc : tgt->roc_ids()) {
+      tgt->roc(i_roc).setRegisters(prior_registers.at(i_roc));
     }
-    pflib_log(trace) << "got link medians";
   }
 
   {  // highend run scope
     pflib_log(info) << "100 event highend run";
-    auto test_handle = roc.testParameters()
-                           .add_all_channels("SIGN_DAC", 0)
-                           .add_all_channels("DACB", 0)
-                           .add_all_channels("TRIM_INV", 63)
-                           .apply();
+
+    std::map<std::string, std::map<std::string, uint64_t>> parameters;
+    for (int ch{0}; ch < 72; ch++) {
+      std::string ch_str{"CH_"+std::to_string(ch)};
+      parameters[ch_str]["SIGN_DAC"] = 0;
+      parameters[ch_str]["DACB"] = 0;
+      parameters[ch_str]["TRIM_INV"] = 63;
+    }
+
+    std::map<int, std::map<int, std::map<int, uint8_t>>> prior_registers;
+    for (int i_roc : tgt->roc_ids()) {
+      prior_registers[i_roc] = tgt->roc(i_roc).applyParameters(parameters);
+    }
+
     daq_run(tgt, "PEDESTAL", buffer, n_events, 100);
-    highend = get_adc_medians(buffer.get_buffer());
+
+    for (int i_roc : tgt->roc_ids()) {
+      highend[i_roc] = get_adc_medians(i_roc, tgt->getRocErxMapping(), buffer.get_buffer());
+    }
+
+    for (int i_roc : tgt->roc_ids()) {
+      tgt->roc(i_roc).setRegisters(prior_registers.at(i_roc));
+    }
   }
 
   {  // lowend run
     pflib_log(info) << "100 event lowend run";
-    auto test_handle = roc.testParameters()
-                           .add_all_channels("SIGN_DAC", 1)
-                           .add_all_channels("DACB", 31)
-                           .add_all_channels("TRIM_INV", 0)
-                           .apply();
+
+    std::map<std::string, std::map<std::string, uint64_t>> parameters;
+    for (int ch{0}; ch < 72; ch++) {
+      std::string ch_str{"CH_"+std::to_string(ch)};
+      parameters[ch_str]["SIGN_DAC"] = 1;
+      parameters[ch_str]["DACB"] = 31;
+      parameters[ch_str]["TRIM_INV"] = 0;
+    }
+
+    std::map<int, std::map<int, std::map<int, uint8_t>>> prior_registers;
+    for (int i_roc : tgt->roc_ids()) {
+      prior_registers[i_roc] = tgt->roc(i_roc).applyParameters(parameters);
+    }
+
     daq_run(tgt, "PEDESTAL", buffer, n_events, 100);
-    lowend = get_adc_medians(buffer.get_buffer());
+
+    for (int i_roc : tgt->roc_ids()) {
+      lowend[i_roc] = get_adc_medians(i_roc, tgt->getRocErxMapping(), buffer.get_buffer());
+    }
   }
 
   pflib_log(info) << "sample collections done, deducing settings";
-  std::map<std::string, std::map<std::string, uint64_t>> settings;
-  for (int ch{0}; ch < 72; ch++) {
-    std::string page{pflib::utility::string_format("CH_%d", ch)};
-    int i_link = ch / 36;
-    if (baseline.at(ch) < target.at(i_link)) {
-      pflib_log(debug) << "Channel " << ch
-                       << " is below target, setting TRIM_INV";
-      double scale = static_cast<double>(target.at(i_link) - baseline.at(ch)) /
-                     (highend.at(ch) - baseline.at(ch));
-      if (scale < 0) {
-        pflib_log(warn) << "Channel " << ch
-                        << " is below target but increasing TRIM_INV made it "
-                           "lower??? Skipping...";
-        continue;
-      }
-      if (scale > 1) {
-        pflib_log(warn) << "Channel " << ch
-                        << " is so far below target that we cannot increase "
-                           "TRIM_INV enough."
-                        << " Setting TRIM_INV to its maximum.";
-        settings[page]["TRIM_INV"] = 63;
-        continue;
-      }
-      // scale is in [0,1]
-      double optim = scale * 63;
-      uint64_t val = static_cast<uint64_t>(optim);
-      pflib_log(trace) << "Scale " << scale << " giving optimal value of "
-                       << optim << " which rounds to " << val;
-      settings[page]["TRIM_INV"] = val;
-    } else {
-      double scale = static_cast<double>(baseline.at(ch) - target.at(i_link)) /
-                     (baseline.at(ch) - lowend.at(ch));
-      if (scale < 0) {
-        pflib_log(warn) << "Channel " << ch
-                        << " is above target but using SIGN_DAC=1 and "
-                           "increasing DACB made it higher??? Skipping...";
-        continue;
-      }
-      if (scale > 1) {
-        pflib_log(warn)
-            << "Channel " << ch
-            << " is so far above target that we cannot lower it enough."
-            << " Setting SIGN_DAC=1 and DACB to its maximum.";
-        settings[page]["SIGN_DAC"] = 1;
-        settings[page]["DACB"] = 31;
-        continue;
-      }
-      double optim = scale * 31;
-      uint64_t val = static_cast<uint64_t>(optim);
-      pflib_log(trace) << "Scale " << scale << " giving optimal value of "
-                       << optim << " which rounds to " << val;
-      if (val == 0) {
-        pflib_log(debug)
-            << "Channel " << ch
-            << " is above target but too close to use DACB to lower, skipping";
-      } else {
+  std::map<int, std::map<std::string, std::map<std::string, uint64_t>>> settings;
+  for (int i_roc : tgt->roc_ids()) {
+    for (int ch{0}; ch < 72; ch++) {
+      std::string page{pflib::utility::string_format("CH_%d", ch)};
+      int i_half = ch / 36;
+      if (baseline[i_roc].at(ch) < target[i_roc].at(i_half)) {
         pflib_log(debug) << "Channel " << ch
-                         << " is above target, setting SIGN_DAC=1 and DACB";
-        settings[page]["SIGN_DAC"] = 1;
-        settings[page]["DACB"] = val;
+                         << " is below target, setting TRIM_INV";
+        double scale = static_cast<double>(target[i_roc].at(i_half) - baseline[i_roc].at(ch)) /
+                       (highend[i_roc].at(ch) - baseline[i_roc].at(ch));
+        if (scale < 0) {
+          pflib_log(warn) << "Channel " << ch
+                          << " is below target but increasing TRIM_INV made it "
+                             "lower??? Skipping...";
+          continue;
+        }
+        if (scale > 1) {
+          pflib_log(warn) << "Channel " << ch
+                          << " is so far below target that we cannot increase "
+                             "TRIM_INV enough."
+                          << " Setting TRIM_INV to its maximum.";
+          settings[i_roc][page]["TRIM_INV"] = 63;
+          continue;
+        }
+        // scale is in [0,1]
+        double optim = scale * 63;
+        uint64_t val = static_cast<uint64_t>(optim);
+        pflib_log(trace) << "Scale " << scale << " giving optimal value of "
+                         << optim << " which rounds to " << val;
+        settings[i_roc][page]["TRIM_INV"] = val;
+      } else {
+        double scale = static_cast<double>(baseline[i_roc].at(ch) - target[i_roc].at(i_half)) /
+                       (baseline[i_roc].at(ch) - lowend[i_roc].at(ch));
+        if (scale < 0) {
+          pflib_log(warn) << "Channel " << ch
+                          << " is above target but using SIGN_DAC=1 and "
+                             "increasing DACB made it higher??? Skipping...";
+          continue;
+        }
+        if (scale > 1) {
+          pflib_log(warn)
+              << "Channel " << ch
+              << " is so far above target that we cannot lower it enough."
+              << " Setting SIGN_DAC=1 and DACB to its maximum.";
+          settings[i_roc][page]["SIGN_DAC"] = 1;
+          settings[i_roc][page]["DACB"] = 31;
+          continue;
+        }
+        double optim = scale * 31;
+        uint64_t val = static_cast<uint64_t>(optim);
+        pflib_log(trace) << "Scale " << scale << " giving optimal value of "
+                         << optim << " which rounds to " << val;
+        if (val == 0) {
+          pflib_log(debug)
+              << "Channel " << ch
+              << " is above target but too close to use DACB to lower, skipping";
+        } else {
+          pflib_log(debug) << "Channel " << ch
+                           << " is above target, setting SIGN_DAC=1 and DACB";
+          settings[i_roc][page]["SIGN_DAC"] = 1;
+          settings[i_roc][page]["DACB"] = val;
+        }
       }
     }
   }

app/tool/algorithm/level_pedestals.h

@@ -15,7 +15,7 @@ namespace pflib::algorithm {
  *
  * @note Only functional for single-ROC targets
  */
-std::map<std::string, std::map<std::string, uint64_t>> level_pedestals(
-    Target* tgt, ROC roc);
+std::map<int, std::map<std::string, std::map<std::string, uint64_t>>>
+level_pedestals(Target* tgt);
 
 }  // namespace pflib::algorithm

app/tool/tasks/level_pedestals.cxx

@@ -7,15 +7,19 @@
 #include "../algorithm/level_pedestals.h"
 
 void level_pedestals(Target* tgt) {
-  auto roc{tgt->roc(pftool::state.iroc)};
-  auto settings = pflib::algorithm::level_pedestals(tgt, roc);
+  auto settings = pflib::algorithm::level_pedestals(tgt);
   YAML::Emitter out;
   out << YAML::BeginMap;
-  for (const auto& page : settings) {
-    out << YAML::Key << page.first;
+  for (const auto& roc : settings) {
+    out << YAML::Key << roc.first;
     out << YAML::Value << YAML::BeginMap;
-    for (const auto& param : page.second) {
-      out << YAML::Key << param.first << YAML::Value << param.second;
+    for (const auto& page : roc.second) {
+      out << YAML::Key << page.first;
+      out << YAML::Value << YAML::BeginMap;
+      for (const auto& param : page.second) {
+        out << YAML::Key << param.first << YAML::Value << param.second;
+      }
+      out << YAML::EndMap;
     }
     out << YAML::EndMap;
   }
@@ -26,7 +30,9 @@ void level_pedestals(Target* tgt) {
   }
 
   if (pftool::readline_bool("Apply settings to the chip? ", false)) {
-    roc.applyParameters(settings);
+    for (int i_roc : tgt->roc_ids()) {
+      tgt->roc(i_roc).applyParameters(settings.at(i_roc));
+    }
   }
 
   if (pftool::readline_bool("Save settings to a file? ", false)) {

app/tool/tasks/setup/align_phase_word.cxx

@@ -325,7 +325,9 @@ void align_phase_word(Target* tgt) {
    */
   auto roc_ids = tgt->roc_ids();
   // Get channels dynamically from ROC to eRx object channel mapping
-  auto& mapping = tgt->getRocErxMapping();
+  // we need to use the lower-level hardware mapping since we want the
+  // eRx ID number and not just the index it would produce after decoding
+  auto& mapping = tgt->getHardwareRocErxMapping();
   // Dynamic channels. 2 eRx per ROC
   std::vector<int> channels;
   for (int i_roc : roc_ids) {

include/pflib/Ecal.h

@@ -68,7 +68,7 @@ class EcalModule {
   void softResetECON();
 
   /** Get the mapping of ROC channels to ERX channels */
-  static const std::vector<std::pair<int, int>>& getRocErxMapping();
+  static const std::vector<std::pair<int, int>>& getHardwareRocErxMapping();
 
   /// mapping of ROC halves to ECON-D eRx channels
   static const std::vector<std::pair<int, int>> ROC_ERX_MAPPING;

include/pflib/HcalBackplane.h

@@ -67,7 +67,7 @@ class HcalBackplane : public Target {
   virtual DAQ& daq() = 0;
 
   /** Get the ROC to eRx mapping */
-  const std::vector<std::pair<int, int>>& getRocErxMapping() override;
+  const std::vector<std::pair<int, int>>& getHardwareRocErxMapping() override;
 
   /// the ROC to eRx mapping for this hardware
   static const std::vector<std::pair<int, int>> ROC_ERX_MAPPING;