TOF/FT0: merge event time tasks

njacazio · njacazio · commit 8ebbbd93ce15 · 2025-09-08T16:29:16.000+02:00
- Cleanup FT0 override process function
diff --git a/Common/TableProducer/PID/pidTOFMerge.cxx b/Common/TableProducer/PID/pidTOFMerge.cxx
@@ -24,6 +24,7 @@
 #include "Common/DataModel/FT0Corrected.h"
 #include "Common/DataModel/PIDResponseTOF.h"
 
+#include <DataFormatsFIT/Triggers.h>
 #include <CCDB/BasicCCDBManager.h>
 #include <DataFormatsParameters/GRPLHCIFData.h>
 #include <DataFormatsTOF/ParameterContainers.h>
@@ -536,6 +537,7 @@ struct tofEventTime {
   Produces<o2::aod::TOFEvTime> tableEvTime;
   Produces<o2::aod::EvTimeTOFOnly> tableEvTimeTOFOnly;
   Produces<o2::aod::pidEvTimeFlags> tableFlags;
+  Produces<o2::aod::FT0sCorrected> tableFt0;
   static constexpr bool kRemoveTOFEvTimeBias = true; // Flag to subtract the Ev. Time bias for low multiplicity events with TOF
   static constexpr float kDiamond = 6.0;             // Collision diamond used in the estimation of the TOF event time
   static constexpr float kErrDiamond = kDiamond * 33.356409f;
@@ -658,14 +660,42 @@ struct tofEventTime {
   using ResponseImplementationEvTime = o2::pid::tof::ExpTimes<Run3TrksWtof::iterator, pid>;
   void processRun3(Run3TrksWtof const& tracks,
                    aod::FT0s const&,
-                   EvTimeCollisionsFT0 const&,
+                   EvTimeCollisions const& collisions,
                    aod::BCsWithTimestamps const& bcs)
   {
     if (!enableTableTOFEvTime) {
       return;
     }
     LOG(debug) << "Processing Run3 data for TOF event time";
 
+    std::map<uint64_t, std::pair<float, float>> collisionFt0Map;
+    tableFt0.reserve(collisions.size());
+    for (const auto& collision : collisions) {
+      static constexpr float DefaultValue = 1e10f;
+      float t0A = DefaultValue;
+      float t0C = DefaultValue;
+      const float vertexPV = collision.posZ();
+      static constexpr float kInvLightSpeedCm2NS = 1.f / o2::constants::physics::LightSpeedCm2NS;
+      const float vertexCorr = vertexPV * kInvLightSpeedCm2NS;
+      constexpr float DummyTime = 30.f; // Due to HW limitations time can be only within range (-25,25) ns, dummy time is around 32 ns
+      if (collision.has_foundFT0()) {
+        const auto& ft0 = collision.foundFT0();
+        const std::bitset<8>& triggers = ft0.triggerMask();
+        const bool ora = triggers[o2::fit::Triggers::bitA];
+        const bool orc = triggers[o2::fit::Triggers::bitC];
+        LOGF(debug, "triggers OrA %i OrC %i ", ora, orc);
+        LOGF(debug, " T0A = %f, T0C %f, vertexCorr %f", ft0.timeA(), ft0.timeC(), vertexCorr);
+        if (ora && ft0.timeA() < DummyTime) {
+          t0A = ft0.timeA() + vertexCorr;
+        }
+        if (orc && ft0.timeC() < DummyTime) {
+          t0C = ft0.timeC() - vertexCorr;
+        }
+      }
+      LOGF(debug, " T0 collision time T0A = %f, T0C = %f", t0A, t0C);
+      tableFt0(t0A, t0C);
+      collisionFt0Map[collision.globalIndex()] = std::make_pair(t0A, t0C); // Store the T0A and T0C for the collision
+    }
     tableEvTime.reserve(tracks.size());
     tableFlags.reserve(tracks.size());
     if (enableTableEvTimeTOFOnly) {
@@ -692,7 +722,8 @@ struct tofEventTime {
     }
     LOG(debug) << "Running on " << CollisionSystemType::getCollisionSystemName(mTOFCalibConfig.collisionSystem()) << " mComputeEvTimeWithTOF " << mComputeEvTimeWithTOF.value << " mComputeEvTimeWithFT0 " << mComputeEvTimeWithFT0.value;
 
-    if (mComputeEvTimeWithTOF == 1 && mComputeEvTimeWithFT0 == 1) {
+    if (mComputeEvTimeWithTOF == 1 && mComputeEvTimeWithFT0 == 1) { // Use both FT0 and TOF event times
+
       int lastCollisionId = -1;                                                                                       // Last collision ID analysed
       for (auto const& t : tracks) {                                                                                  // Loop on collisions
         if (!t.has_collision() || ((sel8TOFEvTime.value == true) && !t.collision_as<EvTimeCollisionsFT0>().sel8())) { // Track was not assigned, cannot compute event time or event did not pass the event selection
@@ -710,7 +741,7 @@ struct tofEventTime {
         lastCollisionId = t.collisionId(); /// Cache last collision ID
 
         const auto& tracksInCollision = tracks.sliceBy(perCollision, lastCollisionId);
-        const auto& collision = t.collision_as<EvTimeCollisionsFT0>();
+        // const auto& collision = t.collision_as<EvTimeCollisions>();
 
         // Compute the TOF event time
         const auto evTimeMakerTOF = evTimeMakerForTracks<Run3TrksWtof::iterator, filterForTOFEventTime, o2::pid::tof::ExpTimes>(tracksInCollision, mRespParamsV3, kDiamond);
@@ -743,13 +774,14 @@ struct tofEventTime {
             sumOfWeights += weight;
           }
 
-          if (collision.has_foundFT0()) { // T0 measurement is available
-            // const auto& ft0 = collision.foundFT0();
-            if (collision.t0ACValid()) {
-              t0AC[0] = collision.t0AC() * 1000.f;
-              t0AC[1] = collision.t0resolution() * 1000.f;
-              flags |= o2::aod::pidflags::enums::PIDFlags::EvTimeT0AC;
-            }
+          float t0A = collisionFt0Map[t.collisionId()].first;  // T0A for the collision
+          float t0C = collisionFt0Map[t.collisionId()].second; // T0C for the collision
+
+          static constexpr float ThresholdValue = 1e9f; // I the value of the FT0s are defined, the values are lower than 10e9
+          if ((t0A < ThresholdValue) && (t0C < ThresholdValue)) {
+            t0AC[0] = 0.5 * (t0A + t0C) * 1000.f;
+            t0AC[1] = 0.5 * std::abs(t0A - t0C) * 1000.f;
+            flags |= o2::aod::pidflags::enums::PIDFlags::EvTimeT0AC;
 
             weight = 1.f / (t0AC[1] * t0AC[1]);
             eventTime += t0AC[0] * weight;
@@ -769,7 +801,8 @@ struct tofEventTime {
           }
         }
       }
-    } else if (mComputeEvTimeWithTOF == 1 && mComputeEvTimeWithFT0 == 0) {
+    } else if (mComputeEvTimeWithTOF == 1 && mComputeEvTimeWithFT0 == 0) { // Use TOF event time only
+
       int lastCollisionId = -1;                                                                                    // Last collision ID analysed
       for (auto const& t : tracks) {                                                                               // Loop on collisions
         if (!t.has_collision() || ((sel8TOFEvTime.value == true) && !t.collision_as<EvTimeCollisions>().sel8())) { // Track was not assigned, cannot compute event time or event did not pass the event selection
@@ -812,7 +845,8 @@ struct tofEventTime {
           }
         }
       }
-    } else if (mComputeEvTimeWithTOF == 0 && mComputeEvTimeWithFT0 == 1) {
+    } else if (mComputeEvTimeWithTOF == 0 && mComputeEvTimeWithFT0 == 1) { // Use FT0 event time only
+
       for (auto const& t : tracks) { // Loop on collisions
         if (enableTableEvTimeTOFOnly) {
           tableEvTimeTOFOnly((uint8_t)0, 0.f, 0.f, -1);
@@ -822,20 +856,22 @@ struct tofEventTime {
           tableEvTime(0.f, 999.f);
           continue;
         }
-        const auto& collision = t.collision_as<EvTimeCollisionsFT0>();
-
-        if (collision.has_foundFT0()) { // T0 measurement is available
-          // const auto& ft0 = collision.foundFT0();
-          if (collision.t0ACValid()) {
-            tableFlags(o2::aod::pidflags::enums::PIDFlags::EvTimeT0AC);
-            tableEvTime(collision.t0AC() * 1000.f, collision.t0resolution() * 1000.f);
-            continue;
-          }
+
+        float t0A = collisionFt0Map[t.collisionId()].first;  // T0A for the collision
+        float t0C = collisionFt0Map[t.collisionId()].second; // T0C for the collision
+
+        static constexpr float ThresholdValue = 1e9f; // I the value of the FT0s are defined, the values are lower than 10e9
+        float t0AC[2] = {.0f, 999.f};
+        uint8_t flags = 0;
+        if ((t0A < ThresholdValue) && (t0C < ThresholdValue)) {
+          t0AC[0] = 0.5 * (t0A + t0C) * 1000.f;
+          t0AC[1] = 0.5 * std::abs(t0A - t0C) * 1000.f;
+          flags = o2::aod::pidflags::enums::PIDFlags::EvTimeT0AC;
         }
-        tableFlags(0);
-        tableEvTime(0.f, 999.f);
+        tableFlags(flags);
+        tableEvTime(t0AC[0], t0AC[1]);
       }
-    } else {
+    } else { // Error
       LOG(fatal) << "Invalid configuration for TOF event time computation";
     }
   }
@@ -942,7 +978,7 @@ struct tofPidMerge {
       doprocessRun2.value = false;
     } else {
       if (mTOFCalibConfig.autoSetProcessFunctions()) {
-        LOG(info) << "Autodetecting process functions";
+        LOG(info) << "Autodetecting process functions for mass and beta";
         if (metadataInfo.isFullyDefined()) {
           if (metadataInfo.isRun3()) {
             doprocessRun3.value = true;
diff --git a/Common/TableProducer/ft0CorrectedTable.cxx b/Common/TableProducer/ft0CorrectedTable.cxx
@@ -34,6 +34,9 @@
 #include <cstdint>
 #include <string>
 
+#include <bitset>
+#include <string>
+
 using namespace o2;
 using namespace o2::framework;
 using namespace o2::aod;
@@ -58,24 +61,13 @@ struct ft0CorrectedTable {
   HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject};
   void init(o2::framework::InitContext&)
   {
-    if (doprocessStandard && doprocessWithBypassFT0timeInMC) {
-      LOG(fatal) << "Both processStandard and processWithBypassFT0timeInMC are enabled. Pick one of the two";
-    }
-    if (!doprocessStandard && !doprocessWithBypassFT0timeInMC) {
-      LOG(fatal) << "No process is enabled. Pick one";
-    }
     ccdb->setURL(cfgUrl);
     ccdb->setTimestamp(cfgTimestamp);
     ccdb->setCaching(true);
     ccdb->setLocalObjectValidityChecking();
     // Not later than now objects
     ccdb->setCreatedNotAfter(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
 
-    if (doprocessWithBypassFT0timeInMC) {
-      // From ps to ns
-      resoFT0A.value = resoFT0A.value / 1000.f;
-      resoFT0C.value = resoFT0C.value / 1000.f;
-    }
     if (!addHistograms) {
       return;
     }
@@ -84,16 +76,11 @@ struct ft0CorrectedTable {
     histos.add("t0AC", "t0AC", kTH1D, {{1000, -1000, 1000, "t0AC (ns)"}});
     histos.add("deltat0AC", "deltat0AC", kTH1D, {{1000, -1, 1, "#Deltat0AC (ns)"}});
     histos.add("deltat0ACps", "deltat0ACps", kTH1D, {{1000, -1000, 1000, "#Deltat0AC (ps)"}});
-    if (doprocessWithBypassFT0timeInMC) {
-      histos.add("MC/deltat0A", "t0A", kTH1D, {{1000, -50, 50, "t0A (ps)"}});
-      histos.add("MC/deltat0C", "t0C", kTH1D, {{1000, -50, 50, "t0C (ps)"}});
-      histos.add("MC/deltat0AC", "t0AC", kTH1D, {{1000, -50, 50, "t0AC (ps)"}});
-    }
   }
 
-  void processStandard(soa::Join<aod::Collisions, aod::EvSels> const& collisions,
-                       BCsWithMatchings const&,
-                       aod::FT0s const&)
+  void process(soa::Join<aod::Collisions, aod::EvSels> const& collisions,
+               BCsWithMatchings const&,
+               aod::FT0s const&)
   {
     table.reserve(collisions.size());
     float t0A = 1e10f;
@@ -131,94 +118,6 @@ struct ft0CorrectedTable {
       table(t0A, t0C);
     }
   }
-  PROCESS_SWITCH(ft0CorrectedTable, processStandard, "Process standard table (default)", true);
-
-  void processWithBypassFT0timeInMC(soa::Join<aod::Collisions, aod::EvSels, aod::McCollisionLabels> const& collisions,
-                                    soa::Join<BCsWithMatchings, aod::Timestamps> const& bcs,
-                                    aod::FT0s const&,
-                                    aod::McCollisions const&)
-  {
-    if (cfgCollisionSystem.value == -1) {
-      o2::parameters::GRPLHCIFData* grpo = ccdb->template getForTimeStamp<o2::parameters::GRPLHCIFData>(cfgPathGrpLhcIf,
-                                                                                                        bcs.iteratorAt(0).timestamp());
-      cfgCollisionSystem.value = CollisionSystemType::getCollisionTypeFromGrp(grpo);
-      switch (cfgCollisionSystem.value) {
-        case CollisionSystemType::kCollSyspp:
-          resoFT0A.value = 24.f;
-          resoFT0C.value = 24.f;
-          break;
-        case CollisionSystemType::kCollSysPbPb:
-          resoFT0A.value = 5.65f;
-          resoFT0C.value = 5.65f;
-          break;
-        default:
-          break;
-      }
-      // Resolution is given in ps
-      resoFT0A.value = resoFT0A.value / 1000.f;
-      resoFT0C.value = resoFT0C.value / 1000.f;
-    }
-    table.reserve(collisions.size());
-    float t0A = 1e10f;
-    float t0C = 1e10f;
-    float eventtimeMC = 1e10f;
-    float posZMC = 0;
-    bool hasMCcoll = false;
-
-    for (const auto& collision : collisions) {
-      hasMCcoll = false;
-      eventtimeMC = 1e10f;
-      t0A = 1e10f;
-      t0C = 1e10f;
-      posZMC = 0;
-      const float vertexPV = collision.posZ();
-      const float vertex_corr = vertexPV * invLightSpeedCm2NS;
-      constexpr float dummyTime = 30.; // Due to HW limitations time can be only within range (-25,25) ns, dummy time is around 32 ns
-      if (collision.has_mcCollision()) {
-        hasMCcoll = true;
-        const auto& collisionMC = collision.mcCollision();
-        eventtimeMC = collisionMC.t();
-        posZMC = collisionMC.posZ();
-      }
-      if (collision.has_foundFT0()) {
-        const auto& ft0 = collision.foundFT0();
-        const std::bitset<8>& triggers = ft0.triggerMask();
-        const bool ora = triggers[o2::ft0::Triggers::bitA];
-        const bool orc = triggers[o2::ft0::Triggers::bitC];
-
-        if (ora && ft0.timeA() < dummyTime) {
-          t0A = ft0.timeA();
-          if (hasMCcoll) {
-            const float diff = eventtimeMC - posZMC * invLightSpeedCm2NS + gRandom->Gaus(0.f, resoFT0A);
-            t0A = diff;
-          }
-          t0A += vertex_corr;
-        }
-        if (orc && ft0.timeC() < dummyTime) {
-          t0C = ft0.timeC();
-          if (hasMCcoll) {
-            const float diff = eventtimeMC + posZMC * invLightSpeedCm2NS + gRandom->Gaus(0.f, resoFT0C);
-            t0C = diff;
-          }
-          t0C -= vertex_corr;
-        }
-      }
-      LOGF(debug, " T0 collision time T0A = %f, T0C = %f", t0A, t0C);
-      if (addHistograms) {
-        histos.fill(HIST("t0A"), t0A);
-        histos.fill(HIST("t0C"), t0C);
-        histos.fill(HIST("t0AC"), (t0A + t0C) * 0.5f);
-        histos.fill(HIST("deltat0AC"), t0A - t0C);
-        if (hasMCcoll) {
-          histos.fill(HIST("MC/deltat0A"), (t0A - eventtimeMC) * 1000.f);
-          histos.fill(HIST("MC/deltat0C"), (t0C - eventtimeMC) * 1000.f);
-          histos.fill(HIST("MC/deltat0AC"), ((t0A + t0C) * 0.5f - eventtimeMC) * 1000.f);
-        }
-      }
-      table(t0A, t0C);
-    }
-  }
-  PROCESS_SWITCH(ft0CorrectedTable, processWithBypassFT0timeInMC, "Process MC with bypass of the AO2D information. Use with care!", false);
 };
 
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask<ft0CorrectedTable>(cfgc)}; }
