FIT:Fixed application of DeadChannelMap in FV0 and FDD reconstruction task

wpierozak · wpierozak · commit cf66e02aaa22 · 2026-01-21T14:40:39.000+01:00
diff --git a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/Reconstructor.h b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/Reconstructor.h
@@ -33,10 +33,14 @@ class Reconstructor
                std::vector<o2::fdd::ChannelDataFloat>& outChData);
   void finish();
 
-  void setDeadChannelMap(const o2::fit::DeadChannelMap* deadChannelMap) {mDeadChannelMap = deadChannelMap;}
+  void setDeadChannelMap(o2::fit::DeadChannelMap const* deadChannelMap)
+  {
+    LOG(info) << "Updated dead channel map";
+    mDeadChannelMap = deadChannelMap;
+  }
 
  private:
-  const o2::fit::DeadChannelMap* mDeadChannelMap;
+  o2::fit::DeadChannelMap const* mDeadChannelMap = nullptr;
   ClassDefNV(Reconstructor, 3);
 };
 } // namespace fdd
diff --git a/Detectors/FIT/FDD/reconstruction/src/Reconstructor.cxx b/Detectors/FIT/FDD/reconstruction/src/Reconstructor.cxx
@@ -33,8 +33,9 @@ void Reconstructor::process(o2::fdd::Digit const& digitBC, gsl::span<const o2::f
   int firstEntry = outChData.size();
   int nStored = 0;
   int nch = inChData.size();
+
   for (int ich = 0; ich < nch; ich++) {
-    if(mDeadChannelMap && !mDeadChannelMap->isChannelAlive(ich)) {
+    if (mDeadChannelMap && !mDeadChannelMap->isChannelAlive(inChData[ich].mPMNumber)) {
       LOG(debug) << "Channel " << ich << " is dead - discarding data";
       continue;
     }
diff --git a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/ReconstructorSpec.h b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/ReconstructorSpec.h
@@ -19,6 +19,7 @@
 #include "FDDReconstruction/Reconstructor.h"
 #include "DataFormatsFDD/RecPoint.h"
 #include "DataFormatsFIT/DeadChannelMap.h"
+#include "Framework/ConcreteDataMatcher.h"
 
 using namespace o2::framework;
 
@@ -34,15 +35,15 @@ class FDDReconstructorDPL : public Task
   ~FDDReconstructorDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
-
-  void setDeadChannelMap(const o2::fit::DeadChannelMap* deadChannelMap) {mDeadChannelMap = deadChannelMap;}
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final;
 
  private:
   bool mUseMC = true;
   bool mUseDeadChannelMap = true;
+  bool mUpdateDeadChannelMap = true;
   std::vector<o2::fdd::RecPoint> mRecPoints;
   std::vector<o2::fdd::ChannelDataFloat> mRecChData;
-  const o2::fit::DeadChannelMap* mDeadChannelMap;
+  o2::fit::DeadChannelMap const* mDeadChannelMap;
   o2::fdd::Reconstructor mReco;
   o2::header::DataOrigin mOrigin = o2::header::gDataOriginFDD;
 };
diff --git a/Detectors/FIT/FDD/workflow/src/ReconstructorSpec.cxx b/Detectors/FIT/FDD/workflow/src/ReconstructorSpec.cxx
@@ -46,7 +46,8 @@ void FDDReconstructorDPL::run(ProcessingContext& pc)
     // lblPtr = labels.get();
     LOG(info) << "Ignoring MC info";
   }
-  if(mUseDeadChannelMap) {
+  if (mUseDeadChannelMap && mUpdateDeadChannelMap) {
+    LOG(info) << "Populating reconsturctor object with Dead Channel Map object";
     auto deadChannelMap = pc.inputs().get<o2::fit::DeadChannelMap*>("deadChannelMap");
     mReco.setDeadChannelMap(deadChannelMap.get());
   }
@@ -64,6 +65,14 @@ void FDDReconstructorDPL::run(ProcessingContext& pc)
   pc.outputs().snapshot(Output{mOrigin, "RECCHDATA", 0}, mRecChData);
 }
 
+void FDDReconstructorDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+{
+  if (matcher == ConcreteDataMatcher("FDD", "DeadChannelMap", 0)) {
+    mUpdateDeadChannelMap = false;
+    return;
+  }
+}
+
 DataProcessorSpec getFDDReconstructorSpec(bool useMC, bool useDeadChannelMap)
 {
   std::vector<InputSpec> inputSpec;
diff --git a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CollisionTimeRecoTask.h b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CollisionTimeRecoTask.h
@@ -60,7 +60,7 @@ class CollisionTimeRecoTask
   };
   void SetDeadChannelMap(const o2::fit::DeadChannelMap * deadChannelMap) 
   {
-    LOG(debug) << "Updated dead channel map for CollisionTimeRecoTask"; 
+    LOG(info) << "Updated dead channel map for CollisionTimeRecoTask";
     mDeadChannelMap = deadChannelMap; 
   }
   float getTimeInPS(const o2::ft0::ChannelData& channelData);
diff --git a/Detectors/FIT/FT0/workflow/src/ReconstructionSpec.cxx b/Detectors/FIT/FT0/workflow/src/ReconstructionSpec.cxx
@@ -70,12 +70,12 @@ void ReconstructionDPL::run(ProcessingContext& pc)
     mReco.SetSlewingCalibObject(slewingCalibObject.get());
   }
 
-  if (mUseDeadChannelMap) {
+  if (mUseDeadChannelMap && mUpdateDeadChannelMap) {
     LOG(debug) << "Applying dead channel map";
     auto deadChannelMap = pc.inputs().get<o2::fit::DeadChannelMap*>("deadChannelMap");
     mReco.SetDeadChannelMap(deadChannelMap.get());
   }
-  
+
   mRecPoints.reserve(digits.size());
   mRecChData.reserve(channels.size());
   mReco.processTF(digits, channels, mRecPoints, mRecChData);
diff --git a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/BaseRecoTask.h b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/BaseRecoTask.h
@@ -34,7 +34,7 @@ class BaseRecoTask
   ~BaseRecoTask() = default;
   o2::fv0::RecPoints process(o2::fv0::Digit const& bcd,
                              gsl::span<const o2::fv0::ChannelData> inChData,
-                             gsl::span<o2::fv0::ChannelDataFloat> outChData);
+                             std::vector<o2::fv0::ChannelDataFloat>& outChData);
   void FinishTask();
   void SetChannelOffset(o2::fv0::FV0ChannelTimeCalibrationObject const* caliboffsets) { mCalibOffset = caliboffsets; };
   void SetDeadChannelMap(o2::fit::DeadChannelMap const* deadChannelMap) { mDeadChannelMap = deadChannelMap; }
diff --git a/Detectors/FIT/FV0/reconstruction/src/BaseRecoTask.cxx b/Detectors/FIT/FV0/reconstruction/src/BaseRecoTask.cxx
@@ -27,7 +27,7 @@ using RP = o2::fv0::RecPoints;
 
 RP BaseRecoTask::process(o2::fv0::Digit const& bcd,
                          gsl::span<const o2::fv0::ChannelData> inChData,
-                         gsl::span<o2::fv0::ChannelDataFloat> outChData)
+                         std::vector<o2::fv0::ChannelDataFloat>& outChData)
 {
   LOG(debug) << "Running reconstruction on new event";
 
@@ -44,27 +44,27 @@ RP BaseRecoTask::process(o2::fv0::Digit const& bcd,
   int nch = inChData.size();
   for (int ich = 0; ich < nch; ich++) {
     LOG(debug) << "  channel " << ich << " / " << nch;
-    int offsetChannel = getOffset(int(inChData[ich].ChId));
-    if(mDeadChannelMap && !mDeadChannelMap->isChannelAlive(ich)) {
+    if (mDeadChannelMap && !mDeadChannelMap->isChannelAlive(inChData[ich].ChId)) {
       LOG(debug) << "Channel " << ich << " is dead - discarding data";
-      outChData[ich] = o2::fv0::ChannelDataFloat{inChData[ich].ChId, 0.0, 0.0, 0};
       continue;
     }
-    outChData[ich] = o2::fv0::ChannelDataFloat{inChData[ich].ChId,
-                                               (inChData[ich].CFDTime - offsetChannel) * DigitizationConstant::TIME_PER_TDCCHANNEL,
-                                               (float)inChData[ich].QTCAmpl,
-                                               inChData[ich].ChainQTC};
+    int offsetChannel = getOffset(int(inChData[ich].ChId));
+    outChData.emplace_back(o2::fv0::ChannelDataFloat{inChData[ich].ChId,
+                                                     (inChData[ich].CFDTime - offsetChannel) * DigitizationConstant::TIME_PER_TDCCHANNEL,
+                                                     (float)inChData[ich].QTCAmpl,
+                                                     inChData[ich].ChainQTC});
+    const auto& currentOutCh = outChData.back();
 
     // Conditions for reconstructing collision time (3 variants: first, average-relaxed and average-tight)
-    if (outChData[ich].charge > FV0DigParam::Instance().chargeThrForMeanTime) {
-      sideAtimeFirst = std::min(static_cast<Double_t>(sideAtimeFirst), outChData[ich].time);
+    if (currentOutCh.charge > FV0DigParam::Instance().chargeThrForMeanTime) {
+      sideAtimeFirst = std::min(static_cast<Double_t>(sideAtimeFirst), currentOutCh.time);
       if (inChData[ich].areAllFlagsGood()) {
-        if (std::abs(outChData[ich].time) < FV0DigParam::Instance().mTimeThresholdForReco) {
-          sideAtimeAvg += outChData[ich].time;
+        if (std::abs(currentOutCh.time) < FV0DigParam::Instance().mTimeThresholdForReco) {
+          sideAtimeAvg += currentOutCh.time;
           ndigitsA++;
         }
-        if (outChData[ich].charge > FV0DigParam::Instance().mAmpThresholdForReco && std::abs(outChData[ich].time) < FV0DigParam::Instance().mTimeThresholdForReco) {
-          sideAtimeAvgSelected += outChData[ich].time;
+        if (currentOutCh.charge > FV0DigParam::Instance().mAmpThresholdForReco && std::abs(currentOutCh.time) < FV0DigParam::Instance().mTimeThresholdForReco) {
+          sideAtimeAvgSelected += currentOutCh.time;
           ndigitsASelected++;
         }
       }
diff --git a/Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx b/Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx
@@ -62,14 +62,11 @@ void ReconstructionDPL::run(ProcessingContext& pc)
   int nDig = digits.size();
   LOG(debug) << " nDig " << nDig << " | ndigch " << digch.size();
   mRecPoints.reserve(nDig);
-  mRecChData.resize(digch.size());
   for (int id = 0; id < nDig; id++) {
     const auto& digit = digits[id];
     LOG(debug) << " ndig " << id << " bc " << digit.getBC() << " orbit " << digit.getOrbit();
     auto channels = digit.getBunchChannelData(digch);
-    gsl::span<o2::fv0::ChannelDataFloat> out_ch(mRecChData);
-    out_ch = out_ch.subspan(digit.ref.getFirstEntry(), digit.ref.getEntries());
-    mRecPoints.emplace_back(mReco.process(digit, channels, out_ch));
+    mRecPoints.emplace_back(mReco.process(digit, channels, mRecChData));
   }
 
   LOG(debug) << "FV0 reconstruction pushes " << mRecPoints.size() << " RecPoints";

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,8 @@ void FDDReconstructorDPL::run(ProcessingContext& pc)`
`46`	`46`	`// lblPtr = labels.get();`
`47`	`47`	`LOG(info) << "Ignoring MC info";`
`48`	`48`	`}`
`49`		`- if(mUseDeadChannelMap) {`
	`49`	`+ if (mUseDeadChannelMap && mUpdateDeadChannelMap) {`
	`50`	`+ LOG(info) << "Populating reconsturctor object with Dead Channel Map object";`
`50`	`51`	`auto deadChannelMap = pc.inputs().get<o2::fit::DeadChannelMap*>("deadChannelMap");`
`51`	`52`	`mReco.setDeadChannelMap(deadChannelMap.get());`
`52`	`53`	`}`
`@@ -64,6 +65,14 @@ void FDDReconstructorDPL::run(ProcessingContext& pc)`
`64`	`65`	`pc.outputs().snapshot(Output{mOrigin, "RECCHDATA", 0}, mRecChData);`
`65`	`66`	`}`
`66`	`67`
	`68`	`+void FDDReconstructorDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)`
	`69`	`+{`
	`70`	`+ if (matcher == ConcreteDataMatcher("FDD", "DeadChannelMap", 0)) {`
	`71`	`+ mUpdateDeadChannelMap = false;`
	`72`	`+ return;`
	`73`	`+ }`
	`74`	`+}`
	`75`	`+`
`67`	`76`	`DataProcessorSpec getFDDReconstructorSpec(bool useMC, bool useDeadChannelMap)`
`68`	`77`	`{`
`69`	`78`	`std::vector<InputSpec> inputSpec;`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ class CollisionTimeRecoTask`
`60`	`60`	`};`
`61`	`61`	`void SetDeadChannelMap(const o2::fit::DeadChannelMap * deadChannelMap)`
`62`	`62`	`{`
`63`		`- LOG(debug) << "Updated dead channel map for CollisionTimeRecoTask";`
	`63`	`+ LOG(info) << "Updated dead channel map for CollisionTimeRecoTask";`
`64`	`64`	`mDeadChannelMap = deadChannelMap;`
`65`	`65`	`}`
`66`	`66`	`float getTimeInPS(const o2::ft0::ChannelData& channelData);`
Original file line number	Diff line number	Diff line change
`@@ -70,12 +70,12 @@ void ReconstructionDPL::run(ProcessingContext& pc)`
`70`	`70`	`mReco.SetSlewingCalibObject(slewingCalibObject.get());`
`71`	`71`	`}`
`72`	`72`
`73`		`- if (mUseDeadChannelMap) {`
	`73`	`+ if (mUseDeadChannelMap && mUpdateDeadChannelMap) {`
`74`	`74`	`LOG(debug) << "Applying dead channel map";`
`75`	`75`	`auto deadChannelMap = pc.inputs().get<o2::fit::DeadChannelMap*>("deadChannelMap");`
`76`	`76`	`mReco.SetDeadChannelMap(deadChannelMap.get());`
`77`	`77`	`}`
`78`		`-`
	`78`	`+`
`79`	`79`	`mRecPoints.reserve(digits.size());`
`80`	`80`	`mRecChData.reserve(channels.size());`
`81`	`81`	`mReco.processTF(digits, channels, mRecPoints, mRecChData);`