new functionalities to fill MCH status map (#12945)

pillot · alcaliva · commit a3053ec83e32 · 2025-03-05T09:11:25.000+01:00
diff --git a/Detectors/MUON/MCH/Status/include/MCHStatus/StatusMap.h b/Detectors/MUON/MCH/Status/include/MCHStatus/StatusMap.h
@@ -13,6 +13,8 @@
 #define O2_MCH_CONDITIONS_STATUSMAP_H
 
 #include "MCHGlobalMapping/ChannelCode.h"
+#include "MCHGlobalMapping/DsIndex.h"
+#include "MCHRawElecMap/DsDetId.h"
 #include "DataFormatsMCH/DsChannelId.h"
 #include <cstdint>
 #include <gsl/span>
@@ -29,12 +31,13 @@ namespace o2::mch
  * Each potentially bad channel is ascribed a 32-bits mask that indicate
  * the source of information used to incriminate it.
  *
- * So far only two sources exist :
+ * So far only three sources exist :
  * - kBadPedestal : the list generated at each pedestal run at Pt2
  * - kRejectList : a (manual) list
+ * - kBadHV : the list derived from the DCS HV values
  *
  * In the future (based on our experience during Run1,2), we'll most probably
- * need to add information from the DCS HV (and possibly LV) values as well.
+ * need to add information from the DCS LV values as well.
  *
  */
 class StatusMap
@@ -43,7 +46,8 @@ class StatusMap
   enum Status : uint32_t {
     kOK = 0,
     kBadPedestal = 1 << 0,
-    kRejectList = 1 << 1
+    kRejectList = 1 << 1,
+    kBadHV = 1 << 2
   };
 
   using iterator = std::map<ChannelCode, uint32_t>::iterator;
@@ -67,6 +71,24 @@ class StatusMap
    */
   void add(gsl::span<const ChannelCode> badchannels, uint32_t mask);
 
+  /** add all the channels of the badDS referenced using DsIndex
+   * to this status map, assigning them the corresponding mask.
+   * @throw runtime_error if the mask is invalid
+   */
+  void addDS(DsIndex badDS, uint32_t mask);
+
+  /** add all the channels of the badDS referenced using DsDetId
+   * to this status map, assigning them the corresponding mask.
+   * @throw runtime_error if the mask is invalid
+   */
+  void addDS(raw::DsDetId badDS, uint32_t mask);
+
+  /** add all the channels of the badDE referenced using DE Id
+   * to this status map, assigning them the corresponding mask.
+   * @throw runtime_error if the mask is invalid
+   */
+  void addDE(uint16_t badDE, uint32_t mask);
+
   /** whether or not this statusmap contains no (potentially) bad channels */
   bool empty() const { return mStatus.empty(); }
 
diff --git a/Detectors/MUON/MCH/Status/src/StatusMap.cxx b/Detectors/MUON/MCH/Status/src/StatusMap.cxx
@@ -10,7 +10,12 @@
 // or submit itself to any jurisdiction.
 
 #include "MCHStatus/StatusMap.h"
+
+#include <stdexcept>
+
 #include "Framework/Logger.h"
+#include "MCHConstants/DetectionElements.h"
+#include "MCHMappingInterface/Segmentation.h"
 
 #include <fmt/format.h>
 
@@ -21,7 +26,7 @@ namespace o2::mch
 
 void assertValidMask(uint32_t mask)
 {
-  uint32_t maxMask = StatusMap::kBadPedestal + StatusMap::kRejectList;
+  static constexpr uint32_t maxMask = StatusMap::kBadPedestal | StatusMap::kRejectList | StatusMap::kBadHV;
   if (mask > maxMask) {
     throw std::runtime_error(fmt::format("invalid mask {} (max allowed is {}",
                                          mask, maxMask));
@@ -36,8 +41,8 @@ void StatusMap::add(gsl::span<const DsChannelId> badchannels, uint32_t mask)
       ChannelCode cc(id.getSolarId(), id.getElinkId(), id.getChannel());
       mStatus[cc] |= mask;
     } catch (const std::exception& e) {
-      // Catch exceptions thrown by the ChannelCode constructor
-      LOGP(warning, "Error processing channel - SolarId: {} ElinkId: {} Channel: {}. Error: {}. This channel is skipped.", id.getSolarId(), id.getElinkId(), id.getChannel(), e.what());
+      LOGP(warning, "Error processing channel - SolarId: {} ElinkId: {} Channel: {}. Error: {}. This channel is skipped.",
+           id.getSolarId(), id.getElinkId(), id.getChannel(), e.what());
     }
   }
 }
@@ -50,6 +55,54 @@ void StatusMap::add(gsl::span<const ChannelCode> badchannels, uint32_t mask)
   }
 }
 
+void StatusMap::addDS(DsIndex badDS, uint32_t mask)
+{
+  if (badDS >= NumberOfDualSampas) {
+    LOGP(warning, "Error processing Dual Sampa - index: {}. This DS is skipped.", badDS);
+    return;
+  }
+  addDS(getDsDetId(badDS), mask);
+}
+
+void StatusMap::addDS(raw::DsDetId badDS, uint32_t mask)
+{
+  assertValidMask(mask);
+  auto deId = badDS.deId();
+  if (!constants::isValidDetElemId(deId)) {
+    LOGP(warning, "Error processing Dual Sampa - {}. This DS is skipped.", raw::asString(badDS));
+    return;
+  }
+  const auto& seg = mapping::segmentation(deId);
+  seg.forEachPadInDualSampa(badDS.dsId(), [&](int dePadIndex) {
+    try {
+      ChannelCode cc(deId, dePadIndex);
+      mStatus[cc] |= mask;
+    } catch (const std::exception& e) {
+      LOGP(warning, "Error processing channel - {} padIndex: {}. Error: {}. This channel is skipped.",
+           raw::asString(badDS), dePadIndex, e.what());
+    }
+  });
+}
+
+void StatusMap::addDE(uint16_t badDE, uint32_t mask)
+{
+  assertValidMask(mask);
+  if (!constants::isValidDetElemId(badDE)) {
+    LOGP(warning, "Error processing DE - Id: {}. This DE is skipped.", badDE);
+    return;
+  }
+  const auto& seg = mapping::segmentation(badDE);
+  seg.forEachPad([&](int dePadIndex) {
+    try {
+      ChannelCode cc(badDE, dePadIndex);
+      mStatus[cc] |= mask;
+    } catch (const std::exception& e) {
+      LOGP(warning, "Error processing channel - deId: {} padIndex: {}. Error: {}. This channel is skipped.",
+           badDE, dePadIndex, e.what());
+    }
+  });
+}
+
 uint32_t StatusMap::status(const ChannelCode& id) const
 {
   auto s = mStatus.find(id);
diff --git a/Detectors/MUON/MCH/Status/src/testStatusMap.cxx b/Detectors/MUON/MCH/Status/src/testStatusMap.cxx
@@ -18,6 +18,7 @@
 #include <boost/test/data/monomorphic.hpp>
 
 #include "MCHGlobalMapping/ChannelCode.h"
+#include "MCHGlobalMapping/DsIndex.h"
 #include "MCHStatus/StatusMap.h"
 #include <fmt/format.h>
 
@@ -39,6 +40,12 @@ std::vector<o2::mch::ChannelCode> cc{
   {1025, 8},
   {515, 1863}};
 
+o2::mch::DsIndex ds = 246; // 56 pads, contains chid[1]
+
+uint16_t de = 1025; // 6976 pads, contains cc[2]
+
+uint32_t badMask = 1 << 3;
+
 BOOST_AUTO_TEST_CASE(ClearShouldGiveEmptyMap)
 {
   o2::mch::StatusMap statusMap;
@@ -50,21 +57,35 @@ BOOST_AUTO_TEST_CASE(ClearShouldGiveEmptyMap)
 BOOST_AUTO_TEST_CASE(AddChannelIdWithInvalidMaskShouldThrow)
 {
   o2::mch::StatusMap statusMap;
-  BOOST_CHECK_THROW(statusMap.add(chid, 4), std::runtime_error);
+  BOOST_CHECK_THROW(statusMap.add(chid, badMask), std::runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(AddChannelCodeWithInvalidMaskShouldThrow)
 {
   o2::mch::StatusMap statusMap;
-  BOOST_CHECK_THROW(statusMap.add(cc, 4), std::runtime_error);
+  BOOST_CHECK_THROW(statusMap.add(cc, badMask), std::runtime_error);
 }
 
-std::array<uint32_t, 3> maskList = {
+BOOST_AUTO_TEST_CASE(AddDSWithInvalidMaskShouldThrow)
+{
+  o2::mch::StatusMap statusMap;
+  BOOST_CHECK_THROW(statusMap.addDS(0, badMask), std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(AddDEWithInvalidMaskShouldThrow)
+{
+  o2::mch::StatusMap statusMap;
+  BOOST_CHECK_THROW(statusMap.addDE(100, badMask), std::runtime_error);
+}
+
+std::array<uint32_t, 5> maskList = {
   o2::mch::StatusMap::kBadPedestal,
   o2::mch::StatusMap::kRejectList,
-  o2::mch::StatusMap::kRejectList + o2::mch::StatusMap::kBadPedestal};
+  o2::mch::StatusMap::kBadHV,
+  o2::mch::StatusMap::kBadPedestal | o2::mch::StatusMap::kBadHV,
+  o2::mch::StatusMap::kRejectList | o2::mch::StatusMap::kBadPedestal | o2::mch::StatusMap::kBadHV};
 
-BOOST_DATA_TEST_CASE(CheckAddedChannelsGetTheRightMask, bdata::xrange(maskList.size() + 1), maskIndex)
+BOOST_DATA_TEST_CASE(CheckAddedChannelsGetTheRightMask, bdata::xrange(maskList.size()), maskIndex)
 {
   o2::mch::StatusMap statusMap;
   auto mask = maskList[maskIndex];
@@ -74,15 +95,62 @@ BOOST_DATA_TEST_CASE(CheckAddedChannelsGetTheRightMask, bdata::xrange(maskList.s
   }
 }
 
+BOOST_AUTO_TEST_CASE(CheckChannelStatusCombination)
+{
+  auto size = [](const o2::mch::StatusMap& statusMap) {
+    int n = 0;
+    for (const auto& status : statusMap) {
+      ++n;
+    }
+    return n;
+  };
+  o2::mch::StatusMap statusMap;
+  statusMap.add(cc, o2::mch::StatusMap::kBadPedestal);
+  BOOST_CHECK_EQUAL(size(statusMap), 4);
+  statusMap.add(chid, o2::mch::StatusMap::kRejectList);
+  BOOST_CHECK_EQUAL(size(statusMap), 4);
+  statusMap.addDS(ds, o2::mch::StatusMap::kBadHV);
+  BOOST_CHECK_EQUAL(size(statusMap), 59);
+  statusMap.addDE(de, o2::mch::StatusMap::kBadHV);
+  BOOST_CHECK_EQUAL(size(statusMap), 7034);
+  BOOST_CHECK_EQUAL(statusMap.status(cc[0]), o2::mch::StatusMap::kBadPedestal | o2::mch::StatusMap::kRejectList);
+  BOOST_CHECK_EQUAL(statusMap.status(cc[1]), o2::mch::StatusMap::kBadPedestal | o2::mch::StatusMap::kRejectList | o2::mch::StatusMap::kBadHV);
+  BOOST_CHECK_EQUAL(statusMap.status(cc[2]), o2::mch::StatusMap::kBadPedestal | o2::mch::StatusMap::kBadHV);
+  BOOST_CHECK_EQUAL(statusMap.status(cc[3]), o2::mch::StatusMap::kBadPedestal);
+}
+
 BOOST_AUTO_TEST_CASE(ApplyMaskShouldReturnASubsetDependingOnMask)
 {
+  auto size = [](const std::map<int, std::vector<int>>& badChannels) {
+    int n = 0;
+    for (const auto& channels : badChannels) {
+      n += channels.second.size();
+    }
+    return n;
+  };
   o2::mch::StatusMap statusMap;
   statusMap.add(cc, o2::mch::StatusMap::kBadPedestal);
   statusMap.add(chid, o2::mch::StatusMap::kRejectList);
+  statusMap.addDS(ds, o2::mch::StatusMap::kBadHV);
+  statusMap.addDE(de, o2::mch::StatusMap::kBadHV);
   auto badPed = applyMask(statusMap, o2::mch::StatusMap::kBadPedestal);
   auto rejectList = applyMask(statusMap, o2::mch::StatusMap::kRejectList);
-  auto all = applyMask(statusMap, o2::mch::StatusMap::kBadPedestal | o2::mch::StatusMap::kRejectList);
-  BOOST_CHECK_EQUAL(badPed.size(), cc.size());
-  BOOST_CHECK_EQUAL(rejectList.size(), chid.size());
-  BOOST_CHECK_EQUAL(all.size(), 4);
+  auto badHV = applyMask(statusMap, o2::mch::StatusMap::kBadHV);
+  auto badHVOrRL = applyMask(statusMap, o2::mch::StatusMap::kBadHV | o2::mch::StatusMap::kRejectList);
+  auto any = applyMask(statusMap, o2::mch::StatusMap::kBadPedestal | o2::mch::StatusMap::kRejectList | o2::mch::StatusMap::kBadHV);
+  BOOST_CHECK_EQUAL(badPed.size(), 4);
+  BOOST_CHECK_EQUAL(size(badPed), 4);
+  BOOST_CHECK_EQUAL(badPed[1025][0], 8);
+  BOOST_CHECK_EQUAL(rejectList.size(), 2);
+  BOOST_CHECK_EQUAL(size(rejectList), 2);
+  BOOST_CHECK_EQUAL(rejectList[100][0], 15665);
+  BOOST_CHECK_EQUAL(badHV.size(), 2);
+  BOOST_CHECK_EQUAL(size(badHV), 7032);
+  BOOST_CHECK_EQUAL(badHV[1025].size(), 6976);
+  BOOST_CHECK_EQUAL(badHVOrRL.size(), 3);
+  BOOST_CHECK_EQUAL(size(badHVOrRL), 7033);
+  BOOST_CHECK_EQUAL(badHVOrRL[515].size(), 0);
+  BOOST_CHECK_EQUAL(any.size(), 4);
+  BOOST_CHECK_EQUAL(size(any), 7034);
+  BOOST_CHECK_EQUAL(any[302][0], 20117);
 }
