introducing mapping file for channels

app/tool/algorithm/get_toa_efficiencies.cxx

@@ -1,20 +1,34 @@
 #include "get_toa_efficiencies.h"
 
+#include <limits>
+
 #include "pflib/utility/efficiency.h"
 
 namespace pflib::algorithm {
 
+// helper function
+bool is_masked(int ch, const std::vector<int>& masked_channels) {
+  return (count(masked_channels.begin(), masked_channels.end(), ch) > 0);
+}
+
 template <class EventPacket>
 std::array<double, 72> get_toa_efficiencies(
-    const std::vector<EventPacket>& data) {
+    const std::vector<EventPacket>& data,
+    const std::vector<int>& masked_channels) {
   std::array<double, 72> efficiencies;
   /// reserve a vector of the appropriate size to avoid repeating allocation
   /// time for all 72 channels
+  // fill with NANs so that channels can be masked out
+  efficiencies.fill(std::numeric_limits<double>::quiet_NaN());
   std::vector<int> toas(data.size());
   int i_ch = 0;  // 0–35
   int i_link = 0;
 
   for (int ch{0}; ch < 72; ch++) {
+    if (is_masked(ch, masked_channels)) {
+      continue;  // leave NaN
+    }
+
     i_link = (ch / 36);
     i_ch = ch % 36;
     for (std::size_t i{0}; i < toas.size(); i++) {
@@ -46,9 +60,11 @@ std::array<double, 72> get_toa_efficiencies(
 // get toa efficiencies
 template std::array<double, 72>
 pflib::algorithm::get_toa_efficiencies<pflib::packing::SingleROCEventPacket>(
-    const std::vector<pflib::packing::SingleROCEventPacket>& data);
+    const std::vector<pflib::packing::SingleROCEventPacket>& data,
+    const std::vector<int>& masked_channels);
 template std::array<double, 72> pflib::algorithm::get_toa_efficiencies<
     pflib::packing::MultiSampleECONDEventPacket>(
-    const std::vector<pflib::packing::MultiSampleECONDEventPacket>& data);
+    const std::vector<pflib::packing::MultiSampleECONDEventPacket>& data,
+    const std::vector<int>& masked_channels);
 
 }  // namespace pflib::algorithm

app/tool/algorithm/get_toa_efficiencies.h

@@ -16,7 +16,8 @@ namespace pflib::algorithm {
 // templated to match any event packet type
 template <class EventPacket>
 std::array<double, 72> get_toa_efficiencies(
-    const std::vector<EventPacket>& data);
+    const std::vector<EventPacket>& data,
+    const std::vector<int>& masked_channels);
 
 // std::array<double, 72> get_toa_efficiencies(
 //     const std::vector<pflib::packing::SingleROCEventPacket>& data);

app/tool/algorithm/level_pedestals.cxx

@@ -51,17 +51,35 @@ static int get_adc(const EventPacket& p, int ch) {
  * TOT/TOA and the sample Tp/Tc flags are ignored.
  */
 template <class EventPacket>
-static std::array<int, 72> get_adc_medians(
-    const std::vector<EventPacket>& data) {
+static std::array<int, 72> get_adc_medians(const std::vector<EventPacket>& data,
+                                           std::vector<int>& masked_channels) {
   std::array<int, 72> medians;
   /// reserve a vector of the appropriate size to avoid repeating allocation
   /// time for all 72 channels
   std::vector<int> adcs(data.size());
   for (int ch{0}; ch < 72; ch++) {
+    if (count(masked_channels.begin(), masked_channels.end(), ch) > 0) {
+      // Do Not include masked channels in the median calculation
+      medians[ch] = -999;  // to maintain length of medians
+      continue;
+    }
+
     for (std::size_t i{0}; i < adcs.size(); i++) {
       adcs[i] = get_adc(data[i], ch);
+
+      // // print out multi sample event packet p here
+      // if constexpr (std::is_same_v<
+      //                   EventPacket,
+      //                   pflib::packing::MultiSampleECONDEventPacket>) {
+      //   std::cout << "p.soi, ch, ilink, adc: " << data[i].i_soi << ", " << ch
+      //             << ", " << ch / 36 << ", " << adcs[i] << std::endl;
+      // } else {
+      //   std::cout << "NOT MULTI " << std::endl;
+      // }
     }
-    medians[ch] = pflib::utility::median(adcs);
+    // medians[ch] = pflib::utility::median(adcs);
+    // std::cout << "here: ch,  median " << ch << ", " << medians[ch] <<
+    // std::endl;
   }
   return medians;
 }
@@ -72,7 +90,8 @@ template <class EventPacket>  // any use of <EventPacket> is a placeholder for
 static void pedestal_runs(Target* tgt, ROC& roc, std::array<int, 72>& baseline,
                           std::array<int, 72>& highend,
                           std::array<int, 72>& lowend,
-                          std::array<int, 2>& target, size_t n_events) {
+                          std::array<int, 2>& target, size_t n_events,
+                          std::vector<int>& masked_channels) {
   /// TODO for multi-ROC set ups, we could dynamically determine the number
   //       of ROCs and the number of channels from the Target
   DecodeAndBuffer<EventPacket> buffer{n_events, 2};
@@ -87,8 +106,12 @@ static void pedestal_runs(Target* tgt, ROC& roc, std::array<int, 72>& baseline,
                            .apply();
     daq_run(tgt, "PEDESTAL", buffer, n_events, 100);
     pflib_log(trace) << "baseline run done, getting channel medians";
-    auto medians = get_adc_medians<EventPacket>(buffer.get_buffer());
+    auto medians =
+        get_adc_medians<EventPacket>(buffer.get_buffer(), masked_channels);
     baseline = medians;
+    // for (int i = 0; i < 72; i++) {
+    //   pflib_log(info) << "baseline: " << baseline[i];
+    // }
     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};
@@ -108,7 +131,8 @@ static void pedestal_runs(Target* tgt, ROC& roc, std::array<int, 72>& baseline,
                            .add_all_channels("TRIM_INV", 63)
                            .apply();
     daq_run(tgt, "PEDESTAL", buffer, n_events, 100);
-    highend = get_adc_medians<EventPacket>(buffer.get_buffer());
+    highend =
+        get_adc_medians<EventPacket>(buffer.get_buffer(), masked_channels);
   }
 
   {  // lowend run
@@ -119,14 +143,28 @@ static void pedestal_runs(Target* tgt, ROC& roc, std::array<int, 72>& baseline,
                            .add_all_channels("TRIM_INV", 0)
                            .apply();
     daq_run(tgt, "PEDESTAL", buffer, n_events, 100);
-    lowend = get_adc_medians<EventPacket>(buffer.get_buffer());
+    lowend = get_adc_medians<EventPacket>(buffer.get_buffer(), masked_channels);
   }
 }
 
 std::map<std::string, std::map<std::string, uint64_t>> level_pedestals(
     Target* tgt, ROC roc) {
   static auto the_log_{::pflib::logging::get("level_pedestals")};
 
+  // Load CHANNEL MASK file
+  std::string mask_file_path = pftool::readline("Path to maskfile: ", "");
+  bool use_mask = !mask_file_path.empty();
+  std::vector<int> masked_channels;
+  std::string line;
+  if (use_mask) {
+    std::ifstream mask_file(mask_file_path);
+    std::getline(mask_file, line);  // ditch first line
+    while (std::getline(mask_file, line)) {
+      int int_ch = std::atoi(line.c_str());
+      masked_channels.push_back(int_ch);
+    }
+  }
+
   /// do three runs of 100 samples each to have well defined pedestals
   static const std::size_t n_events = 100;
 
@@ -142,12 +180,12 @@ std::map<std::string, std::map<std::string, uint64_t>> level_pedestals(
 
   if (pftool::state.daq_format_mode == Target::DaqFormat::SIMPLEROC) {
     pedestal_runs<pflib::packing::SingleROCEventPacket>(
-        tgt, roc, baseline, highend, lowend, target, n_events);
+        tgt, roc, baseline, highend, lowend, target, n_events, masked_channels);
 
   } else if (pftool::state.daq_format_mode ==
              Target::DaqFormat::ECOND_SW_HEADERS) {
     pedestal_runs<pflib::packing::MultiSampleECONDEventPacket>(
-        tgt, roc, baseline, highend, lowend, target, n_events);
+        tgt, roc, baseline, highend, lowend, target, n_events, masked_channels);
 
   } else {
     pflib_log(warn) << "Unsupported DAQ format ("
@@ -157,9 +195,30 @@ std::map<std::string, std::map<std::string, uint64_t>> level_pedestals(
 
   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)};
+
+    // SKIP IF CHANNEL IS MASKED
+    if (count(masked_channels.begin(), masked_channels.end(), ch) > 0) {
+      pflib_log(info) << "Channel " << ch
+                      << " is masked; skipping pedestal leveling.";
+
+      // Explicitly mark it masked
+      // settings[page]["MASKED"] = 1;
+
+      continue;
+
+      // } else {
+      //   settings[page]["MASKED"] = 0;
+    }
+
     int i_link = ch / 36;
+
+    pflib_log(info) << "Channel, Baseline, Lowend, Highend: " << ch << ", "
+                    << baseline[ch] << ", " << lowend[ch] << ", " << highend[ch]
+                    << std::endl;
+
     if (baseline.at(ch) < target.at(i_link)) {
       pflib_log(debug) << "Channel " << ch
                        << " is below target, setting TRIM_INV";
@@ -216,6 +275,7 @@ std::map<std::string, std::map<std::string, uint64_t>> level_pedestals(
                          << " is above target, setting SIGN_DAC=1 and DACB";
         settings[page]["SIGN_DAC"] = 1;
         settings[page]["DACB"] = val;
+        pflib_log(info) << "Channel " << ch << " has val: " << val << ".";
       }
     }
   }

app/tool/algorithm/toa_vref_scan.cxx

@@ -8,7 +8,7 @@
 
 namespace pflib::algorithm {
 
-// Templated helpder function
+// Templated helper function
 template <class EventPacket>
 static void toa_vref_runs(Target* tgt, ROC& roc, size_t n_events,
                           std::array<int, 2>& target) {
@@ -18,6 +18,20 @@ static void toa_vref_runs(Target* tgt, ROC& roc, size_t n_events,
 
   // loop over runs, from toa_vref = 0 to = 255
   for (int toa_vref{0}; toa_vref < 256; toa_vref++) {
+    // Load CHANNEL MASK file
+    std::string mask_file_path = pftool::readline("Path to maskfile: ", "");
+    bool use_mask = !mask_file_path.empty();
+    std::vector<int> masked_channels;
+    std::string line;
+    if (use_mask) {
+      std::ifstream mask_file(mask_file_path);
+      std::getline(mask_file, line);  // ditch first line
+      while (std::getline(mask_file, line)) {
+        int int_ch = std::atoi(line.c_str());
+        masked_channels.push_back(int_ch);
+      }
+    }
+
     pflib_log(info) << "testing toa_vref = " << toa_vref;
     auto test_handle = roc.testParameters()
                            .add("REFERENCEVOLTAGE_0", "TOA_VREF", toa_vref)
@@ -27,7 +41,8 @@ static void toa_vref_runs(Target* tgt, ROC& roc, size_t n_events,
     daq_run(tgt, "PEDESTAL", buffer, n_events, 100);
     pflib_log(trace) << "finished toa_vref = " << toa_vref
                      << ", getting efficiencies";
-    auto efficiencies = get_toa_efficiencies(buffer.get_buffer());
+    auto efficiencies =
+        get_toa_efficiencies(buffer.get_buffer(), masked_channels);
     pflib_log(trace)
         << "got channel efficiencies, getting max efficiency per link";
     for (int i_link{0}; i_link < 2; i_link++) {

app/tool/algorithm/trim_toa_scan.cxx

@@ -68,7 +68,8 @@ namespace pflib::algorithm {
 template <class EventPacket>
 static void trim_tof_runs(
     Target* tgt, ROC& roc, size_t n_events,
-    std::array<std::array<std::array<double, 72>, 8>, 200>& final_data) {
+    std::array<std::array<std::array<double, 72>, 8>, 200>& final_data,
+    std::vector<int>& masked_channels) {
   // working in buffer, not in writer
   DecodeAndBuffer<EventPacket> buffer{n_events, 2};
   static auto the_log_{::pflib::logging::get("toa_vref_scan")};
@@ -98,7 +99,8 @@ static void trim_tof_runs(
 
       pflib_log(trace) << "finished trim_toa = " << trim_toa
                        << ", and calib = " << calib << ", getting efficiencies";
-      auto efficiencies = get_toa_efficiencies(buffer.get_buffer());
+      auto efficiencies =
+          get_toa_efficiencies(buffer.get_buffer(), masked_channels);
       pflib_log(trace) << "got channel efficiencies, storing now";
       for (int ch{0}; ch < 72; ch++) {
         // need to divide by 4 because index is value/4 from final_data
@@ -124,6 +126,20 @@ std::map<std::string, std::map<std::string, uint64_t>> trim_toa_scan(
 
   static const std::size_t n_events = 100;
 
+  // Load CHANNEL MASK file
+  std::string mask_file_path = pftool::readline("Path to maskfile: ", "");
+  bool use_mask = !mask_file_path.empty();
+  std::vector<int> masked_channels;
+  std::string line;
+  if (use_mask) {
+    std::ifstream mask_file(mask_file_path);
+    std::getline(mask_file, line);  // ditch first line
+    while (std::getline(mask_file, line)) {
+      int int_ch = std::atoi(line.c_str());
+      masked_channels.push_back(int_ch);
+    }
+  }
+
   tgt->setup_run(1, pftool::state.daq_format_mode, 1);
 
   // trim_toa is a channel-wise parameter (1 value per channel)
@@ -134,12 +150,12 @@ std::map<std::string, std::map<std::string, uint64_t>> trim_toa_scan(
   std::array<std::array<std::array<double, 72>, 8>, 200> final_data;
 
   if (pftool::state.daq_format_mode == Target::DaqFormat::SIMPLEROC) {
-    trim_tof_runs<pflib::packing::SingleROCEventPacket>(tgt, roc, n_events,
-                                                        final_data);
+    trim_tof_runs<pflib::packing::SingleROCEventPacket>(
+        tgt, roc, n_events, final_data, masked_channels);
   } else if (pftool::state.daq_format_mode ==
              Target::DaqFormat::ECOND_SW_HEADERS) {
     trim_tof_runs<pflib::packing::MultiSampleECONDEventPacket>(
-        tgt, roc, n_events, final_data);
+        tgt, roc, n_events, final_data, masked_channels);
   } else {
     pflib_log(warn) << "Unsupported DAQ format ("
                     << static_cast<int>(pftool::state.daq_format_mode)

build/hcal_channel_mask.csv

@@ -0,0 +1,25 @@
+Mask
+8
+17
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+44
+53
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71