improve TOF infos in TPCtimeseries

noferini · shahor02 · commit 20eb9d23bc6c · 2025-01-29T10:00:43.000+01:00
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/MatchInfoTOF.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/MatchInfoTOF.h
@@ -75,6 +75,17 @@ class MatchInfoTOF
   double getT0true() const { return mT0true; }
   void setT0true(double val) { mT0true = val; }
 
+  enum QualityFlags { isMultiHitX = 0x1 << 0,
+                      isMultiHitZ = 0x1 << 1,
+                      badDy = 0x1 << 2,
+                      isMultiStrip = 0x1 << 3,
+                      isNotInPad = 0x1 << 4,
+                      chiGT3 = 0x1 << 5,
+                      chiGT5 = 0x1 << 6,
+                      hasT0sameBC = 0x1 << 7,
+                      hasT0_1BCbefore = 0x1 << 8,
+                      hasT0_2BCbefore = 0x1 << 9 };
+
  private:
   int mIdLocal;                      // track id in sector of the pair track-TOFcluster
   float mChi2;                       // chi2 of the pair track-TOFcluster
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCTimeSeriesSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCTimeSeriesSpec.h
@@ -23,7 +23,7 @@ namespace tpc
 static constexpr header::DataDescription getDataDescriptionTimeSeries() { return header::DataDescription{"TIMESERIES"}; }
 static constexpr header::DataDescription getDataDescriptionTPCTimeSeriesTFId() { return header::DataDescription{"ITPCTSTFID"}; }
 
-o2::framework::DataProcessorSpec getTPCTimeSeriesSpec(const bool disableWriter, const o2::base::Propagator::MatCorrType matType, const bool enableUnbinnedWriter, o2::dataformats::GlobalTrackID::mask_t src);
+o2::framework::DataProcessorSpec getTPCTimeSeriesSpec(const bool disableWriter, const o2::base::Propagator::MatCorrType matType, const bool enableUnbinnedWriter, o2::dataformats::GlobalTrackID::mask_t src, bool useft0 = false);
 
 } // end namespace tpc
 } // end namespace o2
diff --git a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
@@ -45,6 +45,7 @@
 #include "TROOT.h"
 #include "ReconstructionDataFormats/MatchInfoTOF.h"
 #include "DataFormatsTOF/Cluster.h"
+#include "DataFormatsFT0/RecPoints.h"
 
 using namespace o2::globaltracking;
 using GTrackID = o2::dataformats::GlobalTrackID;
@@ -206,25 +207,86 @@ class TPCTimeSeries : public Task
       indicesITSTPC[tracksITSTPC[i].getRefTPC().getIndex()] = {i, idxVtx};
     }
 
-    std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float>> idxTPCTrackToTOFCluster; // store for each tpc track index the index to the TOF cluster
+    std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int>> idxTPCTrackToTOFCluster; // store for each tpc track index the index to the TOF cluster
 
     // get matches to TOF in case skimmed data is produced
     if (mUnbinnedWriter) {
       //   getLTIntegralOut(), ///< L,TOF integral calculated during the propagation
       //  getSignal()  mSignal = 0.0;              ///< TOF time in ps
       o2::track::TrackLTIntegral defLT;
-      idxTPCTrackToTOFCluster = std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float>>(tracksTPC.size(), {-1, -999, -999, defLT, 0, 0});
+      idxTPCTrackToTOFCluster = std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int>>(tracksTPC.size(), {-1, -999, -999, defLT, 0, 0, 0});
       const std::vector<gsl::span<const o2::dataformats::MatchInfoTOF>> tofMatches{recoData.getTPCTOFMatches(), recoData.getTPCTRDTOFMatches(), recoData.getITSTPCTOFMatches(), recoData.getITSTPCTRDTOFMatches()};
 
+      const auto& ft0rec = recoData.getFT0RecPoints();
+      // fill available FT0-AC event times vs BClong
+      std::map<ULong64_t, short> t0array;
+      for (const auto& t0 : ft0rec) {
+        if (!(t0.isValidTime(1) && t0.isValidTime(2))) { // skip if !(A & C)
+          continue;
+        }
+
+        auto bclong = t0.mIntRecord.differenceInBC(recoData.startIR);
+        if (t0array.find(bclong) == t0array.end()) { // add if it doesn't exist
+          t0array.emplace(std::make_pair(bclong, t0.getCollisionTime(0)));
+        }
+      }
+
+      static const double BC_TIME_INPS_INV = 1E-3 / o2::constants::lhc::LHCBunchSpacingNS;
+
       // loop over ITS-TPC-TRD-TOF and ITS-TPC-TOF tracks an store for each ITS-TPC track the TOF track index
       for (const auto& tofMatch : tofMatches) {
         for (const auto& tpctofmatch : tofMatch) {
           auto refTPC = recoData.getTPCContributorGID(tpctofmatch.getTrackRef());
           if (refTPC.isIndexSet()) {
             o2::track::TrackLTIntegral ltIntegral = tpctofmatch.getLTIntegralOut();
-            double signal = tpctofmatch.getSignal();
+            ULong64_t bclongtof = (tpctofmatch.getSignal() - 10000) * BC_TIME_INPS_INV;
+            double t0 = 0; // bclongtof * o2::constants::lhc::LHCBunchSpacingNS * 1E3; // if you want to subtract also the BC uncomment this part (-> tofsignal can be a float)
+            unsigned int mask = 0;
+            if (!(t0array.find(bclongtof) == t0array.end())) { // subtract FT0-AC if it exists in the same BC
+              t0 += t0array.find(bclongtof)->second;
+              mask |= o2::dataformats::MatchInfoTOF::QualityFlags::hasT0sameBC; // 8th bit if FT0-AC in same BC
+            }
+
+            double signal = tpctofmatch.getSignal() - t0;
             float deltaT = tpctofmatch.getDeltaT();
-            idxTPCTrackToTOFCluster[refTPC] = {tpctofmatch.getIdxTOFCl(), tpctofmatch.getDXatTOF(), tpctofmatch.getDZatTOF(), ltIntegral, signal, deltaT};
+
+            float dy = tpctofmatch.getDYatTOF(); // residual orthogonal to the strip (it should be close to zero)
+            bool isMultiHitZ = tpctofmatch.getHitPatternUpDown();
+            bool isMultiHitX = tpctofmatch.getHitPatternLeftRight();
+            bool isMultiStripMatch = tpctofmatch.getChi2() < 1E-9;
+            float chi2 = tpctofmatch.getChi2();
+            bool hasT0_1BCbefore = (t0array.find(bclongtof - 1) != t0array.end());
+            bool hasT0_2BCbefore = (t0array.find(bclongtof - 2) != t0array.end());
+
+            if (isMultiHitX) { // 1nd bit on if multiple hits along X
+              mask |= o2::dataformats::MatchInfoTOF::QualityFlags::isMultiHitX;
+            }
+            if (isMultiHitZ) { // 2nd bit on if multiple hits along Z
+              mask |= o2::dataformats::MatchInfoTOF::QualityFlags::isMultiHitZ;
+            }
+            if (fabs(dy) > 0.5) { // 3rd bit on if Y-residual too large
+              mask |= o2::dataformats::MatchInfoTOF::QualityFlags::badDy;
+            }
+            if (isMultiStripMatch) { // 4th bit on if two strips fired
+              mask |= o2::dataformats::MatchInfoTOF::QualityFlags::isMultiStrip;
+            }
+            if (chi2 > 1E-4) { // 5th bit on if chi2 > 1E-4 -> not inside the pad
+              mask |= o2::dataformats::MatchInfoTOF::QualityFlags::isNotInPad;
+            }
+            if (chi2 > 3) { // 6th bit on if chi2 > 3
+              mask |= o2::dataformats::MatchInfoTOF::QualityFlags::chiGT3;
+            }
+            if (chi2 > 5) { // 7th bit on if chi2 > 5
+              mask |= o2::dataformats::MatchInfoTOF::QualityFlags::chiGT5;
+            }
+            if (hasT0_1BCbefore) { // 9th bit if FT0-AC also BC before
+              mask |= o2::dataformats::MatchInfoTOF::QualityFlags::hasT0_1BCbefore;
+            }
+            if (hasT0_2BCbefore) { // 10th bit if FT0-AC also 2BCs before
+              mask |= o2::dataformats::MatchInfoTOF::QualityFlags::hasT0_1BCbefore;
+            }
+
+            idxTPCTrackToTOFCluster[refTPC] = {tpctofmatch.getIdxTOFCl(), tpctofmatch.getDXatTOF(), tpctofmatch.getDZatTOF(), ltIntegral, signal, deltaT, mask};
           }
         }
       }
@@ -1055,7 +1117,7 @@ class TPCTimeSeries : public Task
     return isGoodTrack;
   }
 
-  void fillDCA(const gsl::span<const TrackTPC> tracksTPC, const gsl::span<const o2::dataformats::TrackTPCITS> tracksITSTPC, const gsl::span<const o2::dataformats::PrimaryVertex> vertices, const int iTrk, const int iThread, const std::unordered_map<unsigned int, std::array<int, 2>>& indicesITSTPC, const gsl::span<const o2::its::TrackITS> tracksITS, const std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float>>& idxTPCTrackToTOFCluster, const gsl::span<const o2::tof::Cluster> tofClusters)
+  void fillDCA(const gsl::span<const TrackTPC> tracksTPC, const gsl::span<const o2::dataformats::TrackTPCITS> tracksITSTPC, const gsl::span<const o2::dataformats::PrimaryVertex> vertices, const int iTrk, const int iThread, const std::unordered_map<unsigned int, std::array<int, 2>>& indicesITSTPC, const gsl::span<const o2::its::TrackITS> tracksITS, const std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int>>& idxTPCTrackToTOFCluster, const gsl::span<const o2::tof::Cluster> tofClusters)
   {
     const auto& trackFull = tracksTPC[iTrk];
     const bool isGoodTrack = checkTrack(trackFull);
@@ -1444,6 +1506,7 @@ class TPCTimeSeries : public Task
                             << "mDeltaTTOFTPC=" << std::get<5>(idxTPCTrackToTOFCluster[iTrk]) /// delta T- TPC TOF
                             << "vertexTime=" << vertexTime                                    /// time stamp assigned to the vertex
                             << "trackTime0=" << trackTime0                                    /// time stamp assigned to the track
+                            << "TOFmask=" << std::get<6>(idxTPCTrackToTOFCluster[iTrk])       /// delta T- TPC TOF
                             // TPC delta param
                             << "deltaTPCParamInOutTgl=" << deltaTPCParamInOutTgl
                             << "deltaTPCParamInOutQPt=" << deltaTPCParamInOutQPt
@@ -1751,14 +1814,19 @@ class TPCTimeSeries : public Task
   }
 };
 
-o2::framework::DataProcessorSpec getTPCTimeSeriesSpec(const bool disableWriter, const o2::base::Propagator::MatCorrType matType, const bool enableUnbinnedWriter, GTrackID::mask_t src)
+o2::framework::DataProcessorSpec getTPCTimeSeriesSpec(const bool disableWriter, const o2::base::Propagator::MatCorrType matType, const bool enableUnbinnedWriter, GTrackID::mask_t src, bool useft0)
 {
   auto dataRequest = std::make_shared<DataRequest>();
   bool useMC = false;
   GTrackID::mask_t srcTracks = GTrackID::getSourcesMask("TPC,ITS,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF") & src;
   srcTracks.set(GTrackID::TPC); // TPC must be always there
   dataRequest->requestTracks(srcTracks, useMC);
   dataRequest->requestClusters(GTrackID::getSourcesMask("TPC"), useMC);
+
+  if (useft0) {
+    dataRequest->requestFT0RecPoints(false);
+  }
+
   bool tpcOnly = srcTracks == GTrackID::getSourcesMask("TPC");
   if (!tpcOnly) {
     dataRequest->requestPrimaryVertices(useMC);
diff --git a/Detectors/TPC/workflow/src/tpc-time-series.cxx b/Detectors/TPC/workflow/src/tpc-time-series.cxx
@@ -29,6 +29,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"disable-root-output", VariantType::Bool, false, {"disable root-files output writers"}},
     {"enable-unbinned-root-output", VariantType::Bool, false, {"writing out unbinned track data"}},
     {"track-sources", VariantType::String, std::string{o2::dataformats::GlobalTrackID::ALL}, {"comma-separated list of sources to use"}},
+    {"use-ft0", VariantType::Bool, false, {"enable FT0 rec-points"}},
     {"material-type", VariantType::Int, 2, {"Type for the material budget during track propagation: 0=None, 1=Geo, 2=LUT"}}};
   std::swap(workflowOptions, options);
 }
@@ -43,7 +44,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
   const bool enableUnbinnedWriter = config.options().get<bool>("enable-unbinned-root-output");
   auto src = o2::dataformats::GlobalTrackID::getSourcesMask(config.options().get<std::string>("track-sources"));
   auto materialType = static_cast<o2::base::Propagator::MatCorrType>(config.options().get<int>("material-type"));
-  workflow.emplace_back(o2::tpc::getTPCTimeSeriesSpec(disableWriter, materialType, enableUnbinnedWriter, src));
+  const bool useft0 = config.options().get<bool>("use-ft0");
+  workflow.emplace_back(o2::tpc::getTPCTimeSeriesSpec(disableWriter, materialType, enableUnbinnedWriter, src, useft0));
   if (!disableWriter) {
     workflow.emplace_back(o2::tpc::getTPCTimeSeriesWriterSpec());
   }
diff --git a/prodtests/full-system-test/calib-workflow.sh b/prodtests/full-system-test/calib-workflow.sh
@@ -54,7 +54,7 @@ if [[ $CALIB_ASYNC_EXTRACTTPCCURRENTS == 1 ]]; then
   add_W o2-tpc-integrate-cluster-workflow "${CONFIG_CTPTPC}"
 fi
 if [[ $CALIB_ASYNC_EXTRACTTIMESERIES == 1 ]] ; then
-  CONFIG_TPCTIMESERIES=
+  CONFIG_TPCTIMESERIES=" --use-ft0"
   : ${CALIB_ASYNC_SAMPLINGFACTORTIMESERIES:=0.001}
   if [[ ! -z ${CALIB_ASYNC_ENABLEUNBINNEDTIMESERIES:-} ]]; then
     CONFIG_TPCTIMESERIES+=" --enable-unbinned-root-output --sample-unbinned-tsallis --threads ${TPCTIMESERIES_THREADS:-1}"
