Implemented coincidence mode; Renamed reco parameters

Author: wpierozak

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

@@ -49,14 +49,22 @@ struct FDDRecoConfig : o2::conf::ConfigurableParamHelper<FDDRecoConfig> {
     return (flags & CollisionTimeValidPmInputFlagMask) == CollisionTimeValidPmInputFlags;
   }
 
-  int16_t SwOrTriggerTimeLowThreshold = -153;
-  int16_t SwOrTriggerTimeHighThreshold = 153;
-  int16_t SwOrTriggerAmplitudeLowThreshold = 10;
-  int16_t SwOrTriggerAmplitudeHighThreshold = 4096;
-  int16_t SwVtxTriggerTimeDiffMin = -100;
-  int16_t SwVtxTriggerTimeDiffMax = 100;
+  int16_t SwOrGate = 153;
+  int16_t SwOrTriggerAmplitudeLowThresholdSideA = 6;
+  int16_t SwOrTriggerAmplitudeLowThresholdSideC = 0;
+  int16_t SwOrTriggerAmplitudeHighThresholdSideA = 4095;
+  int16_t SwOrTriggerAmplitudeHighThresholdSideC = 4095;
+  int16_t SwVtxTriggerTimeWindow = 100;
+  bool SwTriggerCoincidenceMode = true;
   bool SwTriggerEnabled = false;
 
+  uint8_t SwTriggerValidPmInputFlagMask = static_cast<uint8_t>(~(1u << ChannelData::kNumberADC));
+  uint8_t SwTriggerValidPmInputFlags = static_cast<uint8_t>((1u << ChannelData::kIsCFDinADCgate) | (1u << ChannelData::kIsEventInTVDC));
+  bool isChannelDataGoodForSwTrigger(uint8_t flags) const
+  {
+    return (flags & SwTriggerValidPmInputFlagMask) == SwTriggerValidPmInputFlags;
+  }
+
   O2ParamDef(FDDRecoConfig, "FDDRecoConfig");
   ClassDefNV(FDDRecoConfig, 2);
 };

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

@@ -53,17 +53,19 @@ class RecPoint
  public:
   enum TimeTypeIndex : int { TimeA,
                              TimeC };
-  enum ETriggerBits { kSwVtxTrigger = 7 };
+  enum ETriggerBits { kSwOrTrgSideA,
+                      kSwOrTrgSideC,
+                      kSwVtxTrg = 7 };
   RecPoint() = default;
   RecPoint(const std::array<int, 2>& collisiontime, int first, int ne,
-           o2::InteractionRecord iRec, o2::fdd::Triggers triggers, bool swVertexTrigger)
+           o2::InteractionRecord iRec, o2::fdd::Triggers triggers, bool swOrTrgSideA, bool swOrTrgSideC, bool swVtxTrg)
     : mCollisionTimePs(collisiontime)
   {
     mRef.setFirstEntry(first);
     mRef.setEntries(ne);
     mIntRecord = iRec;
     mTriggers = triggers;
-    updateTriggers(swVertexTrigger);
+    updateTriggers(swOrTrgSideA, swOrTrgSideC, swVtxTrg);
   }
   ~RecPoint() = default;
 
@@ -88,10 +90,10 @@ class RecPoint
   bool operator==(const RecPoint&) const = default;
 
  private:
-  void updateTriggers(bool swVertexTrigger)
+  void updateTriggers(bool swOrTrgSideA, bool swOrTrgSideC, bool swVertexTrigger)
   {
     auto [triggerBits, technicalWords] = o2::fit::Triggers::parseDigitTriggerWord(mTriggers.getTriggersignals(), true);
-    triggerBits |= (uint8_t(swVertexTrigger) << kSwVtxTrigger);
+    triggerBits |= (uint8_t(swVertexTrigger) << kSwVtxTrg) | (uint8_t(swOrTrgSideA) << kSwOrTrgSideA) | (uint8_t(swOrTrgSideC) << kSwOrTrgSideC);
     mTriggers.setTriggers(triggerBits);
     mTechnicalWords = technicalWords;
   }

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

@@ -42,29 +42,33 @@ class Reconstructor
   }
 
  private:
-  static const int coincidencePairsSideC[4][2] = {{0, 4}, {1, 5}, {2, 6}, {3, 7}};
-  static const int coincidencePairsSideA[4][2] = {{8, 12}, {9, 13}, {10, 14}, {11, 15}};
+  static constexpr uint8_t coincidencePairsSideC[8] = {4, 5, 6, 7, 0, 1, 2, 3};
+  static constexpr uint8_t coincidencePairsSideA[8] = {12, 13, 14, 15, 8, 9, 10, 11};
 
   bool isInAmplitudeWindow(int16_t amplitude)
   {
-    return amplitude >= FDDRecoConfig::Instance().ChannelAmplitudeLower && amplitude <= FDDRecoConfig::Instance().ChannelAmplitudeUpper;
+    return amplitude > FDDRecoConfig::Instance().ChannelAmplitudeLower && amplitude < FDDRecoConfig::Instance().ChannelAmplitudeUpper;
   }
   bool isInTimeWindow(int16_t time)
   {
-    return time >= FDDRecoConfig::Instance().ChannelTimeLower && time <= FDDRecoConfig::Instance().ChannelTimeUpper;
+    return time > FDDRecoConfig::Instance().ChannelTimeLower && time < FDDRecoConfig::Instance().ChannelTimeUpper;
   }
   bool isChannelDataGood(uint8_t channelBits)
   {
     return FDDRecoConfig::Instance().isChannelDataGood(channelBits);
   }
+  bool isCoincidenceConditionFulFilled(const bool* coincidencePairs, uint8_t channelNumber)
+  {
+    return (!FDDRecoConfig::Instance().SwTriggerCoincidenceMode) || ((channelNumber <= sSideAMaxId) ? coincidencePairs[coincidencePairsSideA[channelNumber]] : coincidencePairs[coincidencePairsSideC[channelNumber]]);
+  }
 
   bool isInCollisionTimeAmplitudeWindow(int16_t amplitude)
   {
-    return amplitude >= FDDRecoConfig::Instance().CollisionTimeAmplitudeLower && amplitude <= FDDRecoConfig::Instance().CollisionTimeAmpltudeUpper;
+    return amplitude > FDDRecoConfig::Instance().CollisionTimeAmplitudeLower && amplitude < FDDRecoConfig::Instance().CollisionTimeAmpltudeUpper;
   }
   bool isInCollisionTimeTimeWindow(int16_t time)
   {
-    return time >= FDDRecoConfig::Instance().CollisionTimeTimeLower && time <= FDDRecoConfig::Instance().CollisionTimeTimeUpper;
+    return time > FDDRecoConfig::Instance().CollisionTimeTimeLower && time < FDDRecoConfig::Instance().CollisionTimeTimeUpper;
   }
   bool isChannelDataGoodForCollisionTime(uint8_t channelBits)
   {
@@ -73,15 +77,20 @@ class Reconstructor
 
   bool checkSwOrGateConditions(const ChannelData& channelData)
   {
-    bool isAmplitudeInRange = channelData.mChargeADC >= FDDRecoConfig::Instance().SwOrTriggerAmplitudeLowThreshold && channelData.mChargeADC <= FDDRecoConfig::Instance().SwOrTriggerAmplitudeHighThreshold;
-    bool isInTimeWindow = std::abs(channelData.mTime) >= o2::fdd::timePerTDC * FDDRecoConfig::Instance().SwOrTriggerTimeLowThreshold && std::abs(channelData.mTime) <= o2::fdd::timePerTDC *  FDDRecoConfig::Instance().SwOrTriggerTimeHighThreshold;
+    bool isAmplitudeInRange = false;
+    if (channelData.mPMNumber <= sSideAMaxId) {
+      isAmplitudeInRange = channelData.mChargeADC > FDDRecoConfig::Instance().SwOrTriggerAmplitudeLowThresholdSideA && channelData.mChargeADC < FDDRecoConfig::Instance().SwOrTriggerAmplitudeHighThresholdSideA;
+    } else {
+      isAmplitudeInRange = channelData.mChargeADC > FDDRecoConfig::Instance().SwOrTriggerAmplitudeLowThresholdSideC && channelData.mChargeADC < FDDRecoConfig::Instance().SwOrTriggerAmplitudeHighThresholdSideC;
+    }
+    bool isInTimeWindow = std::abs(channelData.mTime) <= FDDRecoConfig::Instance().SwOrGate;
     bool isCfdInAdcGate = channelData.getFlag(ChannelData::EEventDataBit::kIsCFDinADCgate);
     return isAmplitudeInRange && isInTimeWindow && isCfdInAdcGate;
   }
 
   bool calculateSwTrigger(float meanTimeSideA, float meanTimeSideC, bool orGateSideA, bool orGateSideC)
   {
-    return (meanTimeSideC - meanTimeSideA) >= o2::fdd::timePerTDC * FDDRecoConfig::Instance().SwVtxTriggerTimeDiffMin && (meanTimeSideC - meanTimeSideA) <= o2::fdd::timePerTDC * FDDRecoConfig::Instance().SwVtxTriggerTimeDiffMax && orGateSideA && orGateSideC;
+    return std::abs(meanTimeSideC - meanTimeSideA) < o2::fdd::timePerTDC * FDDRecoConfig::Instance().SwVtxTriggerTimeWindow && orGateSideA && orGateSideC;
   }
   static constexpr uint8_t sSideAMaxId = 7;
 

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

@@ -41,30 +41,32 @@ void Reconstructor::process(o2::fdd::Digit const& digitBC, gsl::span<const o2::f
   bool swOrGateSideA = false;
   bool swOrGateSideC = false;
 
+  bool coincidencePairs[Nchannels] = {false};
+
   for (const auto& channelData : inChData) {
     if (mDeadChannelMap && !mDeadChannelMap->isChannelAlive(channelData.mPMNumber)) {
       LOG(debug) << "Channel " << channelData.mPMNumber << " is dead - discarding data";
       continue;
     }
-
-    if (isInAmplitudeWindow(channelData.mChargeADC) && isInTimeWindow(channelData.mTime) && isChannelDataGood(channelData.mFEEBits)) {
-      outChData.emplace_back((int)channelData.mPMNumber, (channelData.mTime) * timePerTDC,
-                             (double)channelData.mChargeADC, channelData.mFEEBits);
-      storedEntries++;
+    if (!isInAmplitudeWindow(channelData.mChargeADC) || !isInTimeWindow(channelData.mTime) || !isChannelDataGood(channelData.mFEEBits)) {
+      continue;
     }
+    const auto& chNum = channelData.mPMNumber;
+
+    outChData.emplace_back((int)chNum, (channelData.mTime) * timePerTDC,
+                           (double)channelData.mChargeADC, channelData.mFEEBits);
+    storedEntries++;
 
     if (FDDRecoConfig::Instance().SwTriggerEnabled) {
-      if (channelData.mPMNumber <= sSideAMaxId) {
-        swOrGateSideA |= checkSwOrGateConditions(channelData);
+      if (chNum <= sSideAMaxId) {
+        coincidencePairs[chNum] |= checkSwOrGateConditions(channelData);
+        swOrGateSideA |= coincidencePairs[chNum] && isCoincidenceConditionFulFilled(coincidencePairs, chNum);
       } else {
-        swOrGateSideC |= checkSwOrGateConditions(channelData);
+        coincidencePairs[chNum] |= checkSwOrGateConditions(channelData);
+        swOrGateSideC |= coincidencePairs[chNum] && isCoincidenceConditionFulFilled(coincidencePairs, chNum);
       }
     }
 
-    if (!isInAmplitudeWindow(channelData.mChargeADC) || !isInTimeWindow(channelData.mTime) || !isChannelDataGood(channelData.mFEEBits)) {
-      continue;
-    }
-
     if (channelData.mPMNumber <= sSideAMaxId) {
       timeSideA += channelData.mTime;
       entriesNumSideA++;
@@ -87,7 +89,7 @@ void Reconstructor::process(o2::fdd::Digit const& digitBC, gsl::span<const o2::f
   if (entriesNumSideC > 0) {
     mCollisionTime[o2::fdd::RecPoint::TimeC] = std::round(meanTimeSideC * nsToPs);
   }
-  RecPoints.emplace_back(mCollisionTime, firstEntry, storedEntries, digitBC.getIntRecord(), digitBC.mTriggers, swVertexTrg);
+  RecPoints.emplace_back(mCollisionTime, firstEntry, storedEntries, digitBC.getIntRecord(), digitBC.mTriggers, swVertexTrg, swOrGateSideA, swOrGateSideC);
 }
 //________________________________________________________
 void Reconstructor::finish()