Implemented FT0-like collision time calulcation for FDD. Prepared methods and data structure for SW trigger implementation

Author: wpierozak

DataFormats/Detectors/FIT/FDD/include/DataFormatsFDD/FDDRecoConfig.h

@@ -25,7 +25,7 @@ struct FDDRecoConfig : o2::conf::ConfigurableParamHelper<FDDRecoConfig> {
 
   uint8_t ChannelValidPmInputFlagMask = 0;
   uint8_t ChannelValidPmInputFlags = 0;
-  bool isChannelDataGoodForCollisionTime(uint8_t flags) const
+  bool isChannelDataGood(uint8_t flags) const
   {
     return (flags & ChannelValidPmInputFlagMask) == ChannelValidPmInputFlags;
   }
@@ -54,10 +54,12 @@ struct FDDRecoConfig : o2::conf::ConfigurableParamHelper<FDDRecoConfig> {
   float SwTriggerTimeHighThreshold= 1.25;
   float SwTriggerAmplitudeLowThreshold = 0.0;
   float SwTriggerAmplitudeHighThreshold = 4096.0;
+  float SwTriggerTimeDiffMin = -1.25;
+  float SwTriggerTimeDiffMax = 1.25;
   bool SwTriggerEnabled = false;
 
   O2ParamDef(FDDRecoConfig, "FDDRecoConfig");
-  ClassDefNV(FDDRecoConfig, 1);
+  ClassDefNV(FDDRecoConfig, 2);
 };
 } // namespace o2::fdd
 #endif

Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/Reconstructor.h

@@ -44,6 +44,40 @@ class Reconstructor
   bool isInAmplitudeWindow(int16_t amplitude) {
     return amplitude >= FDDRecoConfig::Instance().ChannelAmplitudeLower && amplitude <= FDDRecoConfig::Instance().ChannelAmplitudeUpper;
   }
+  bool isInTimeWindow(int16_t time) {
+    return time >= FDDRecoConfig::Instance().ChannelTimeLower && time <= FDDRecoConfig::Instance().ChannelTimeUpper;
+  }
+  bool isChannelDataGood(uint8_t channelBits) {
+    return FDDRecoConfig::Instance().isChannelDataGood(channelBits);
+  }
+
+  bool isInCollisionTimeAmplitudeWindow(int16_t amplitude) {
+    return amplitude >= FDDRecoConfig::Instance().CollisionTimeAmplitudeLower && amplitude <= FDDRecoConfig::Instance().CollisionTimeAmpltudeUpper;
+  }
+  bool isInCollisionTimeTimeWindow(int16_t time) {
+    return time >= FDDRecoConfig::Instance().CollisionTimeTimeLower && time <= FDDRecoConfig::Instance().CollisionTimeTimeUpper;
+  }
+  bool isChannelDataGoodForCollisionTime(uint8_t channelBits) {
+    return FDDRecoConfig::Instance().isChannelDataGoodForCollisionTime(channelBits);
+  }
+
+  bool checkSwOrGateConditions(const ChannelData& channelData) {
+    bool isAmplitudeInRange = channelData.mChargeADC >= FDDRecoConfig::Instance().SwTriggerAmplitudeLowThreshold 
+      && channelData.mChargeADC <= FDDRecoConfig::Instance().SwTriggerAmplitudeHighThreshold;
+    bool isInTimeWindow = std::abs(channelData.mTime) >= FDDRecoConfig::Instance().SwTriggerTimeLowThreshold
+      && std::abs(channeData.mTime) <= FDDRecoConfig::Instance().SwTriggerTimeHighThreshold;
+    bool isCfdInAdcGate = channelData.getFlag(ChannelData::EEventDataBit::kIsCFDinADCgate);
+    return isAmplitudeInRange && isInTimeWindow && isCfdInAdcGate;
+  }
+
+  bool calculateSwTrigger(float meanTimeSideA, float meanTimeSideC, bool orGateSideA, bool orGateSideC)
+  {
+    return (meanTimeSideC - meanTimeSideA) >= FDDRecoConfig::SwTriggerTimeDiffMin
+      && (meanTimeSideC - meanTimeSideA) <= FDDRecoConfig::SwTriggerTimeDiffMax
+      && orGateSideA
+      && orGateSideC;
+  }
+  static constexpr uint8_t sSideAMaxId = 7;
 
   o2::fit::DeadChannelMap const* mDeadChannelMap = nullptr;
   ClassDefNV(Reconstructor, 3);

Detectors/FIT/FDD/reconstruction/src/Reconstructor.cxx

@@ -42,69 +42,61 @@ void Reconstructor::process(o2::fdd::Digit const& digitBC, gsl::span<const o2::f
   int64_t timeSideC = 0;
   int64_t entriesNumSideA = 0;
   int64_t entriesNumSideC = 0;
+  uint32_t storedEntries = 0;
+
+  bool swOrGateSideA = false;
+  bool swOrGateSideC = false;
 
   for (const auto& channelData: inChData) {
     if (mDeadChannelMap && !mDeadChannelMap->isChannelAlive(channelData.mPMNumber)) {
       LOG(debug) << "Channel " << channelData.mPMNumber << " is dead - discarding data";
       continue;
     }
-    
-  }
 
-  for (int ich = 0; ich < nch; ich++) {
-    if (mDeadChannelMap && !mDeadChannelMap->isChannelAlive(inChData[ich].mPMNumber)) {
-      LOG(debug) << "Channel " << ich << " is dead - discarding data";
-      continue;
-    }
-    bool inTime = inChData[ich].getFlag(ChannelData::EEventDataBit::kIsEventInTVDC);
-    bool inAdcGate = inChData[ich].getFlag(ChannelData::EEventDataBit::kIsCFDinADCgate);
-    if (inAdcGate) {
+    if (isInAmplitudeWindow(channelData.mChargeADC) 
+      && isInTimeWindow(channelData.mTime) 
+      && isChannelDataGood(channelData.mFEEBits))
+    {
       outChData.emplace_back((int)inChData[ich].mPMNumber, (inChData[ich].mTime) * timePerTDC,
                              (double)inChData[ich].mChargeADC, inChData[ich].mFEEBits);
-      nStored++;
+      storedEntries++;
     }
-
-    float adc = inChData[ich].mChargeADC;
-    float time = (inChData[ich].mTime) * timePerTDC;
-
-    float timeWeight = 1;
-    if (adc > FDDRecoConfig::Instance().AmplitudeCutOnCollisionTimeWeights) {
-      timeWeight = adc * adc;
+    
+    if (FDDRecoConfig::Instance().SwTriggerEnabled) {
+      if(channelData.mPMNumber <= sSideAMaxId) {
+        swOrGateSideA |= checkSwOrGateConditions(channelData);
+      } else {
+        swOrGateSideC |= checkSwOrGateConditions(channelData);
+      }
     }
-    if ((int)inChData[ich].mPMNumber < 8) {
-      nInTimeC += inTime;
-      timeFDC += time * timeWeight;
-      weightFDC += timeWeight;
+
+    if (!isInAmplitudeWindow(channelData.mChargeADC) 
+      || !isInTimeWindow(channelData.mTime) 
+      || !isChannelDataGood(channelData.mFEEBits)) {
+        continue;
+      }
+    
+    if(channelData.mPMNumber <= sSideAMaxId) {
+      timeSideA += channelData.mTime;
+      entriesNumSideA++;
     } else {
-      nInTimeA += inTime;
-      timeFDA += time * timeWeight;
-      weightFDA += timeWeight;
+      timeSideC += channelData.mTime;
+      entriesNumSideC++;
     }
-
-    atLeastOneVertexChannel = FDDRecoConfig::areChannelDataFlagsGood(inChData[ich].mFEEBits);
-    atLeastOneChannelInSwAmplitudeRange = (adc >= FDDRecoConfig::SwTriggerAmplitudeLowThreshold && adc <= FDDRecoConfig::SwTriggerAmplitudeHighThreshold);
   }
-  const int nsToPs = 1e3;
-  std::array<int, 2> mCollisionTime = {o2::fdd::RecPoint::sDummyCollissionTime, o2::fdd::RecPoint::sDummyCollissionTime};
 
-  float meanTimeSideA = round(timeFDA / weightFDA * nsToPs);
-  float meanTimeSideC = round(timeFDC / weightFDC * nsToPs);
-  float sideTimeDifference = fabs(meanTimeSideC - meanTimeSideA);
-  bool swTriggerBit = false;
-  swTriggerBit = (
-    FDDRecoConfig::SwTriggerEnabled && 
-    (sideTimeDifference => FDDRecoConfig::SwTriggerTimeLowThreshold 
-      && sideTimeDifference <= FDDRecoConfig::SwTriggerTimeHighThreshold
-      && atLeastOneVertexChannel 
-      && atLeastOneChannelInSwAmplitudeRange
-    )
-  );
+  constexpr float nsToPs = 1e3;
+  float meanTimeSideA = std::round(float(timeSideA) * timePerTDC / float(entriesNumSideA));
+  float meanTimeSideC = std::round(float(timeSideC) * timePerTDC / float(entriesNumSideC));
+
+  bool swVertexTrg = FDDRecoConfig::Instance().SwTriggerEnabled ? calculateSwTrigger(meanTimeSideA, meanTimeSideC, swOrGateSideA, swOrGateSideC) : false;
 
-  if (nInTimeA > 0 && weightFDA > FDDRecoConfig::Instance().AmplitudeCollisionTimeCutSideA) {
-    mCollisionTime[o2::fdd::RecPoint::TimeA] = round(timeFDA / weightFDA * nsToPs);
+  std::array<int, 2> mCollisionTime = {o2::fdd::RecPoint::sDummyCollissionTime, o2::fdd::RecPoint::sDummyCollissionTime};
+  if (entriesSideA > 0) {
+    mCollisionTime[o2::fdd::RecPoint::TimeA] = meanTimeSideA * nsToPs;
   }
-  if (nInTimeC > 0 && weightFDC > FDDRecoConfig::Instance().AmplitudeCollisionTimeCutSideC) {
-    mCollisionTime[o2::fdd::RecPoint::TimeC] = round(timeFDC / weightFDC * nsToPs);
+  if (entriesSideC > 0) {
+    mCollisionTime[o2::fdd::RecPoint::TimeC] = meanTimeSideC * nsToPs;
   }
   RecPoints.emplace_back(mCollisionTime, firstEntry, nStored, digitBC.getIntRecord(), digitBC.mTriggers);
 }