Draft of FDD reco refactor

Author: Wiktor Pierozak

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

@@ -13,11 +13,28 @@
 #define ALICEO2_FDD_RECO_PARAM
 
 #include "CommonUtils/ConfigurableParamHelper.h"
+#include "DataFormatsFDD/ChannelData.h"
 
 namespace o2::fdd
 {
 struct FDDRecoConfig : o2::conf::ConfigurableParamHelper<FDDRecoConfig> {
   float AmplitudeCutOnCollisionTimeWeights = 3;
+  float AmplitudeCollisionTimeCutSideA = 1.0;
+  float AmplitudeCollisionTimeCutSideC = 0.0;
+  
+  float SwTriggerTimeLowThreshold= -1.25;
+  float SwTriggerTimeHighThreshold= 1.25;
+  float SwTriggerAmplitudeLowThreshold = 0.0;
+  float SwTriggerAmplitudeHighThreshold = 4096.0;
+  bool SwTriggerEnabled = false;
+
+  uint8_t ValidPmInputFlagMask = static_cast<uint8_t>(~(1u << ChannelData::kNumberADC));
+  uint8_t ValidPmInputFlags = static_cast<uint8_t>((1u << ChannelData::kIsCFDinADCgate) | (1u << ChannelData::kIsEventInTVDC));
+  bool areChannelDataFlagsGood(uint8_t flags) const
+  {
+    return (flags & mValidPmInputFlagMask) == mValidPmInputFlags;
+  }
+
   O2ParamDef(FDDRecoConfig, "FDDRecoConfig");
   ClassDefNV(FDDRecoConfig, 1);
 };

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

@@ -53,6 +53,7 @@ class RecPoint
  public:
   enum TimeTypeIndex : int { TimeA,
                              TimeC };
+  enum ETriggerBits { kSwTrigger = 7 };
   RecPoint() = default;
   RecPoint(const std::array<int, 2>& collisiontime, int first, int ne,
            o2::InteractionRecord iRec, o2::fdd::Triggers triggers)

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

@@ -35,6 +35,9 @@ void Reconstructor::process(o2::fdd::Digit const& digitBC, gsl::span<const o2::f
   int nStored = 0;
   int nch = inChData.size();
 
+  bool atLeastOneVertexChannel = false;
+  bool atLeastOneChannelInSwAmplitudeRange = false;
+
   for (int ich = 0; ich < nch; ich++) {
     if (mDeadChannelMap && !mDeadChannelMap->isChannelAlive(inChData[ich].mPMNumber)) {
       LOG(debug) << "Channel " << ich << " is dead - discarding data";
@@ -48,43 +51,47 @@ void Reconstructor::process(o2::fdd::Digit const& digitBC, gsl::span<const o2::f
       nStored++;
     }
 
-    Float_t adc = inChData[ich].mChargeADC;
-    Float_t time = (inChData[ich].mTime) * timePerTDC;
-    if (time == o2::InteractionRecord::DummyTime) {
-      continue;
-    }
-    Float_t timeErr = 1;
+    float adc = inChData[ich].mChargeADC;
+    float time = (inChData[ich].mTime) * timePerTDC;
+
+    float timeWeight = 1;
     if (adc > FDDRecoConfig::Instance().AmplitudeCutOnCollisionTimeWeights) {
-      timeErr = 1. / adc;
+      timeWeight = adc * adc;
     }
     if ((int)inChData[ich].mPMNumber < 8) {
       nInTimeC += inTime;
-      timeFDC += time / (timeErr * timeErr);
-      weightFDC += 1. / (timeErr * timeErr);
+      timeFDC += time * timeWeight;
+      weightFDC += timeWeight;
     } else {
       nInTimeA += inTime;
-      timeFDA += time / (timeErr * timeErr);
-      weightFDA += 1. / (timeErr * timeErr);
+      timeFDA += time * timeWeight;
+      weightFDA += timeWeight;
     }
+
+    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};
-  /// Avg time for each side, only if one channel satisfy the TVDC condition (if not, also avg time is propagated for background study using AO2D)
-  if (nInTimeA > 0) {
-    mCollisionTime[o2::fdd::RecPoint::TimeA] = (weightFDA > 1) ? round(timeFDA / weightFDA * nsToPs)
-                                                               : o2::fdd::RecPoint::sDummyCollissionTime;
-  } else {
-    if (weightFDA > 0) {
-      mCollisionTime[o2::fdd::RecPoint::TimeA] = round(timeFDA / weightFDA * nsToPs);
-    }
+
+  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
+    )
+  );
+
+  if (nInTimeA > 0 && weightFDA > FDDRecoConfig::Instance().AmplitudeCollisionTimeCutSideA) {
+    mCollisionTime[o2::fdd::RecPoint::TimeA] = round(timeFDA / weightFDA * nsToPs);
   }
-  if (nInTimeC > 0) {
-    mCollisionTime[o2::fdd::RecPoint::TimeC] = (weightFDC > 1) ? round(timeFDC / weightFDC * nsToPs)
-                                                               : o2::fdd::RecPoint::sDummyCollissionTime;
-  } else {
-    if (weightFDC > 0) {
-      mCollisionTime[o2::fdd::RecPoint::TimeC] = round(timeFDC / weightFDC * nsToPs);
-    }
+  if (nInTimeC > 0 && weightFDC > FDDRecoConfig::Instance().AmplitudeCollisionTimeCutSideC) {
+    mCollisionTime[o2::fdd::RecPoint::TimeC] = round(timeFDC / weightFDC * nsToPs);
   }
   RecPoints.emplace_back(mCollisionTime, firstEntry, nStored, digitBC.getIntRecord(), digitBC.mTriggers);
 }