add TOF match checker

Author: noferini

DataFormats/Detectors/GlobalTracking/include/DataFormatsGlobalTracking/RecoContainer.h

@@ -198,7 +198,7 @@ struct DataRequest {
   void requestTPCTOFTracks(bool mc);
   void requestITSTPCTRDTracks(bool mc);
   void requestTPCTRDTracks(bool mc);
-  void requestTOFMatches(bool mc);
+  void requestTOFMatches(o2::dataformats::GlobalTrackID::mask_t src, bool mc);
   void requestFT0RecPoints(bool mc);
   void requestFV0RecPoints(bool mc);
   void requestFDDRecPoints(bool mc);
@@ -315,7 +315,9 @@ struct RecoContainer {
   void addITSTPCTracks(o2::framework::ProcessingContext& pc, bool mc);
   void addGlobalFwdTracks(o2::framework::ProcessingContext& pc, bool mc);
   void addTPCTOFTracks(o2::framework::ProcessingContext& pc, bool mc);
-  void addTOFMatches(o2::framework::ProcessingContext& pc, bool mc);
+  void addTOFMatchesITSTPC(o2::framework::ProcessingContext& pc, bool mc);
+  void addTOFMatchesTPCTRD(o2::framework::ProcessingContext& pc, bool mc);
+  void addTOFMatchesITSTPCTRD(o2::framework::ProcessingContext& pc, bool mc);
 
   void addITSClusters(o2::framework::ProcessingContext& pc, bool mc);
   void addMFTClusters(o2::framework::ProcessingContext& pc, bool mc);

DataFormats/Detectors/GlobalTracking/include/DataFormatsGlobalTracking/RecoContainerCreateTracksVariadic.h

@@ -96,23 +96,70 @@ void o2::globaltracking::RecoContainer::createTracksVariadic(T creator) const
   const auto matchesTPCTOF = getTPCTOFMatches(); // and corresponding matches
   const auto tracksTPCTRD = getTPCTRDTracks<o2::trd::TrackTRD>();
   const auto matchesITSTPCTOF = getITSTPCTOFMatches(); // just matches, no refit done
+  const auto matchesTPCTRDTOF = getTPCTRDTOFMatches(); // just matches, no refit done
+  const auto matchesITSTPCTRDTOF = getITSTPCTRDTOFMatches(); // just matches, no refit done
   const auto tofClusters = getTOFClusters();
   const auto tracksITSTPCTRD = getITSTPCTRDTracks<o2::trd::TrackTRD>();
 
   const auto trigTPCTRD = getTPCTRDTriggers();
 
-  usedData[GTrackID::ITS].resize(tracksITS.size());                   // to flag used ITS tracks
-  usedData[GTrackID::MCH].resize(tracksMCH.size());                   // to flag used MCH tracks
-  usedData[GTrackID::MFT].resize(tracksMFT.size());                   // to flag used MFT tracks
-  usedData[GTrackID::TPC].resize(tracksTPC.size());                   // to flag used TPC tracks
-  usedData[GTrackID::ITSTPC].resize(tracksTPCITS.size());             // to flag used ITSTPC tracks
-  usedData[GTrackID::MFTMCH].resize(tracksMFTMCH.size());             // to flag used MFTMCH tracks
-  usedData[GTrackID::ITSTPCTRD].resize(tracksITSTPCTRD.size());       // to flag used ITSTPCTRD tracks
-  usedData[GTrackID::TPCTRD].resize(tracksTPCTRD.size());             // to flag used TPCTRD tracks
-  usedData[GTrackID::ITSTPCTOF].resize(getITSTPCTOFMatches().size()); // to flag used ITSTPC-TOF matches
+  usedData[GTrackID::ITS].resize(tracksITS.size());                         // to flag used ITS tracks
+  usedData[GTrackID::MCH].resize(tracksMCH.size());                         // to flag used MCH tracks
+  usedData[GTrackID::MFT].resize(tracksMFT.size());                         // to flag used MFT tracks
+  usedData[GTrackID::TPC].resize(tracksTPC.size());                         // to flag used TPC tracks
+  usedData[GTrackID::ITSTPC].resize(tracksTPCITS.size());                   // to flag used ITSTPC tracks
+  usedData[GTrackID::MFTMCH].resize(tracksMFTMCH.size());                   // to flag used MFTMCH tracks
+  usedData[GTrackID::ITSTPCTRD].resize(tracksITSTPCTRD.size());             // to flag used ITSTPCTRD tracks
+  usedData[GTrackID::TPCTRD].resize(tracksTPCTRD.size());                   // to flag used TPCTRD tracks
+  usedData[GTrackID::ITSTPCTRD].resize(tracksITSTPCTRD.size());             // to flag used TPCTRD tracks
+  usedData[GTrackID::ITSTPCTOF].resize(getITSTPCTOFMatches().size());       // to flag used ITSTPC-TOF matches
+  usedData[GTrackID::TPCTRDTOF].resize(getTPCTRDTOFMatches().size());       // to flag used ITSTPC-TOF matches
+  usedData[GTrackID::ITSTPCTRDTOF].resize(getITSTPCTRDTOFMatches().size()); // to flag used ITSTPC-TOF matches
 
   // ITS-TPC-TRD-TOF
-  // TODO, will flag used ITS-TPC-TRD
+  {
+
+    if (matchesITSTPCTRDTOF.size() && (!tofClusters.size() || !tracksITSTPCTRD.size())) {
+      throw std::runtime_error(fmt::format("Global-TOF tracks ({}) require ITS-TPC-TRD tracks ({}) and TOF clusters ({})",
+                                           matchesITSTPCTRDTOF.size(), tracksITSTPCTRD.size(), tofClusters.size()));
+    }
+    for (unsigned i = 0; i < matchesITSTPCTRDTOF.size(); i++) {
+      const auto& match = matchesITSTPCTRDTOF[i];
+      auto gidx = match.getTrackRef(); // this should be corresponding ITS-TPC-TRD track
+      // no need to check isUsed: by construction this ITS-TPC-TRD was not used elsewhere
+      const auto& tofCl = tofClusters[match.getTOFClIndex()];
+      float timeTOFMUS = (tofCl.getTime() - match.getLTIntegralOut().getTOF(o2::track::PID::Pion)) * PS2MUS; // tof time in \mus, FIXME: account for time of flight to R TOF
+      const float timeErr = 0.010f;                                                                          // assume 10 ns error FIXME
+      if (creator(tracksITSTPCTRD[gidx.getIndex()], {i, GTrackID::ITSTPCTRDTOF}, timeTOFMUS, timeErr)) {
+        //flagUsed2(i, GTrackID::TOF); // flag used TOF match // TODO might be not needed
+        flagUsed(gidx); // flag used ITS-TPC-TRD tracks
+      }
+    }
+  }
+
+  // TPC-TRD-TOF
+  {
+
+    if (matchesTPCTRDTOF.size() && (!tofClusters.size() || !tracksTPCTRD.size())) {
+      throw std::runtime_error(fmt::format("Global-TOF tracks ({}) require TPC-TRD tracks ({}) and TOF clusters ({})",
+                                           matchesTPCTRDTOF.size(), tracksTPCTRD.size(), tofClusters.size()));
+    }
+    for (unsigned i = 0; i < matchesTPCTRDTOF.size(); i++) {
+      const auto& match = matchesTPCTRDTOF[i];
+      auto gidx = match.getTrackRef(); // this should be corresponding ITS-TPC-TRD track
+      if (isUsed(gidx)) {              // RS FIXME: THIS IS TEMPORARY, until the TOF matching will use ITS-TPC-TRD as an input
+        continue;
+      }
+      // no need to check isUsed: by construction this ITS-TPC-TRD was not used elsewhere
+      const auto& tofCl = tofClusters[match.getTOFClIndex()];
+      float timeTOFMUS = (tofCl.getTime() - match.getLTIntegralOut().getTOF(o2::track::PID::Pion)) * PS2MUS; // tof time in \mus, FIXME: account for time of flight to R TOF
+      const float timeErr = 0.010f;                                                                          // assume 10 ns error FIXME
+      if (creator(tracksTPCTRD[gidx.getIndex()], {i, GTrackID::TPCTRDTOF}, timeTOFMUS, timeErr)) {
+        //flagUsed2(i, GTrackID::TOF); // flag used TOF match // TODO might be not needed
+        flagUsed(gidx); // flag used ITS-TPC tracks
+      }
+    }
+  }
 
   // ITS-TPC-TRD
   {

DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx

@@ -143,7 +143,7 @@ void DataRequest::requestTPCTOFTracks(bool mc)
   addInput({"matchTPCTOF", "TOF", "MTC_TPC", ss, Lifetime::Timeframe});
   addInput({"trackTPCTOF", "TOF", "TOFTRACKS_TPC", ss, Lifetime::Timeframe});
   if (mc) {
-    addInput({"clsTOF_TPC_MCTR", "TOF", "MCMATCHTOF_TPC", ss, Lifetime::Timeframe});
+    addInput({"clsTOF_TPC_MCTR", "TOF", "MCMTC_TPC", ss, Lifetime::Timeframe});
   }
   requestMap["trackTPCTOF"] = mc;
 }
@@ -171,13 +171,29 @@ void DataRequest::requestTPCTRDTracks(bool mc)
   requestMap["trackTPCTRD"] = mc;
 }
 
-void DataRequest::requestTOFMatches(bool mc)
+void DataRequest::requestTOFMatches(o2::dataformats::GlobalTrackID::mask_t src, bool mc)
 {
-  addInput({"matchITSTPCTOF", "TOF", "MTC_ITSTPC", 0, Lifetime::Timeframe});
-  if (mc) {
-    addInput({"clsTOF_GLO_MCTR", "TOF", "MCMATCHTOF", 0, Lifetime::Timeframe});
+  if (src[GTrackID::ITSTPCTOF]) {
+    addInput({"matchITSTPCTOF", "TOF", "MTC_ITSTPC", 0, Lifetime::Timeframe});
+    if (mc) {
+      addInput({"clsTOF_GLO_MCTR", "TOF", "MCMTC_ITSTPC", 0, Lifetime::Timeframe});
+    }
+    requestMap["matchTOF_ITSTPC"] = mc;
+  }
+  if (src[GTrackID::TPCTRDTOF]) {
+    addInput({"matchTPCTRDTOF", "TOF", "MTC_TPCTRD", 0, Lifetime::Timeframe});
+    if (mc) {
+      addInput({"clsTOF_GLO2_MCTR", "TOF", "MCMTC_TPCTRD", 0, Lifetime::Timeframe});
+    }
+    requestMap["matchTOF_TPCTRD"] = mc;
+  }
+  if (src[GTrackID::ITSTPCTRDTOF]) {
+    addInput({"matchITSTPCTRDTOF", "TOF", "MTC_ITSTPCTRD", 0, Lifetime::Timeframe});
+    if (mc) {
+      addInput({"clsTOF_GLO3_MCTR", "TOF", "MCMTC_ITSTPCTRD", 0, Lifetime::Timeframe});
+    }
+    requestMap["matchTOF_ITSTPCTRD"] = mc;
   }
-  requestMap["matchTOF"] = mc;
 }
 
 void DataRequest::requestITSClusters(bool mc)
@@ -384,18 +400,16 @@ void DataRequest::requestTracks(GTrackID::mask_t src, bool useMC)
   if (src[GTrackID::TPCTOF]) {
     requestTPCTOFTracks(useMC);
   }
-  if (src[GTrackID::ITSTPCTOF]) {
-    requestTOFMatches(useMC);
-    requestTOFClusters(false); // RSTODO Needed just to set the time of ITSTPC track, consider moving to MatchInfoTOF
-                               // NOTE: Getting TOF Clusters is carried over to InputHelper::addInputSpecs. If changed here, please fix there.
+  if (src[GTrackID::TPCTRD] || src[GTrackID::TPCTRDTOF]) {
+    requestTPCTRDTracks(useMC);
   }
-  if (src[GTrackID::ITSTPCTRD]) {
+  if (src[GTrackID::ITSTPCTRD] || src[GTrackID::ITSTPCTRDTOF]) {
     requestITSTPCTRDTracks(useMC);
   }
-  if (src[GTrackID::TPCTRD]) {
-    requestTPCTRDTracks(useMC);
+  if (src[GTrackID::ITSTPCTRDTOF] || src[GTrackID::ITSTPCTOF] || src[GTrackID::TPCTRDTOF]) {
+    requestTOFMatches(src, useMC);
+    requestTOFClusters(false);
   }
-
   if (src[GTrackID::FT0]) {
     requestFT0RecPoints(false); // RS FIXME: at the moment does not support MC
   }
@@ -505,9 +519,19 @@ void RecoContainer::collectData(ProcessingContext& pc, const DataRequest& reques
     addTPCTOFTracks(pc, req->second);
   }
 
-  req = reqMap.find("matchTOF");
+  req = reqMap.find("matchTOF_ITSTPC");
+  if (req != reqMap.end()) {
+    addTOFMatchesITSTPC(pc, req->second);
+  }
+
+  req = reqMap.find("matchTOF_TPCTRD");
+  if (req != reqMap.end()) {
+    addTOFMatchesTPCTRD(pc, req->second);
+  }
+
+  req = reqMap.find("matchTOF_ITSTPCTRD");
   if (req != reqMap.end()) {
-    addTOFMatches(pc, req->second);
+    addTOFMatchesITSTPCTRD(pc, req->second);
   }
 
   req = reqMap.find("clusITS");
@@ -770,14 +794,29 @@ void RecoContainer::addTPCTOFTracks(ProcessingContext& pc, bool mc)
 }
 
 //__________________________________________________________
-void RecoContainer::addTOFMatches(ProcessingContext& pc, bool mc)
+void RecoContainer::addTOFMatchesITSTPC(ProcessingContext& pc, bool mc)
 {
   commonPool[GTrackID::ITSTPCTOF].registerContainer(pc.inputs().get<gsl::span<o2d::MatchInfoTOF>>("matchITSTPCTOF"), MATCHES); //only ITS/TPC : TOF match info, no real tracks
   if (mc) {
     commonPool[GTrackID::ITSTPCTOF].registerContainer(pc.inputs().get<gsl::span<o2::MCCompLabel>>("clsTOF_GLO_MCTR"), MCLABELS);
   }
 }
-
+//__________________________________________________________
+void RecoContainer::addTOFMatchesTPCTRD(ProcessingContext& pc, bool mc)
+{
+  commonPool[GTrackID::TPCTRDTOF].registerContainer(pc.inputs().get<gsl::span<o2d::MatchInfoTOF>>("matchTPCTRDTOF"), MATCHES); //only ITS/TPC : TOF match info, no real tracks
+  if (mc) {
+    commonPool[GTrackID::TPCTRDTOF].registerContainer(pc.inputs().get<gsl::span<o2::MCCompLabel>>("clsTOF_GLO2_MCTR"), MCLABELS);
+  }
+}
+//__________________________________________________________
+void RecoContainer::addTOFMatchesITSTPCTRD(ProcessingContext& pc, bool mc)
+{
+  commonPool[GTrackID::ITSTPCTRDTOF].registerContainer(pc.inputs().get<gsl::span<o2d::MatchInfoTOF>>("matchITSTPCTRDTOF"), MATCHES); //only ITS/TPC : TOF match info, no real tracks
+  if (mc) {
+    commonPool[GTrackID::ITSTPCTRDTOF].registerContainer(pc.inputs().get<gsl::span<o2::MCCompLabel>>("clsTOF_GLO3_MCTR"), MCLABELS);
+  }
+}
 //__________________________________________________________
 void RecoContainer::addITSClusters(ProcessingContext& pc, bool mc)
 {
@@ -965,6 +1004,18 @@ bool RecoContainer::isTrackSourceLoaded(int src) const
     }
     src = GTrackID::ITSTPC;
   }
+  if (src == GTrackID::TPCTRDTOF) {
+    if (!isMatchSourceLoaded(src)) { // the physical tracks are in ITS-TPC, need to get reference from match info
+      return false;
+    }
+    src = GTrackID::TPCTRD;
+  }
+  if (src == GTrackID::ITSTPCTRDTOF) {
+    if (!isMatchSourceLoaded(src)) { // the physical tracks are in ITS-TPC, need to get reference from match info
+      return false;
+    }
+    src = GTrackID::ITSTPCTRD;
+  }
   return commonPool[src].isLoaded(TRACKS);
 }
 
@@ -973,7 +1024,7 @@ const o2::track::TrackParCov& RecoContainer::getTrackParam(GTrackID gidx) const
 {
   // get base track
   auto trSrc = gidx.getSource();
-  if (trSrc == GTrackID::ITSTPCTOF) { // the physical tracks are in ITS-TPC, need to get reference from match info
+  if (trSrc == GTrackID::ITSTPCTOF || trSrc == GTrackID::TPCTRDTOF || trSrc == GTrackID::ITSTPCTRDTOF) { // the physical tracks are in ITS-TPC, need to get reference from match info
     gidx = getTOFMatch(gidx).getTrackRef();
   }
   return getObject<o2::track::TrackParCov>(gidx, TRACKS);
@@ -1031,6 +1082,15 @@ RecoContainer::GlobalIDSet RecoContainer::getSingleDetectorRefs(GTrackID gidx) c
     table[GTrackID::TOF] = {unsigned(parent0.getIdxTOFCl()), GTrackID::TOF};
     table[GTrackID::TPC] = parent1.getRefTPC();
     table[parent1.getRefITS().getSource()] = parent1.getRefITS(); // ITS source might be an ITS track or ITSAB tracklet
+  } else if (src == GTrackID::ITSTPCTRDTOF) {
+    const auto& parent0 = getTOFMatch(gidx); //ITS/TPC : TOF
+    const auto& parent1 = getITSTPCTRDTrack<o2::trd::TrackTRD>(parent0.getTrackRef());
+    const auto& parent2 = getTPCITSTrack(parent1.getRefGlobalTrackId());
+    table[GTrackID::ITSTPCTRD] = parent0.getTrackRef();
+    table[GTrackID::ITSTPC] = parent1.getRefGlobalTrackId();
+    table[GTrackID::TOF] = {unsigned(parent0.getIdxTOFCl()), GTrackID::TOF};
+    table[GTrackID::TPC] = parent2.getRefTPC();
+    table[parent2.getRefITS().getSource()] = parent2.getRefITS(); // ITS source might be an ITS track or ITSAB tracklet
   } else if (src == GTrackID::TPCTOF) {
     const auto& parent0 = getTPCTOFMatch(gidx); //TPC : TOF
     table[GTrackID::TOF] = {unsigned(parent0.getIdxTOFCl()), GTrackID::TOF};
@@ -1057,6 +1117,11 @@ GTrackID RecoContainer::getTPCContributorGID(GTrackID gidx) const
     const auto& parent0 = getTOFMatch(gidx); //ITS/TPC : TOF
     const auto& parent1 = getTPCITSTrack(parent0.getTrackRef());
     return parent1.getRefTPC();
+  } else if (src == GTrackID::ITSTPCTRDTOF) {
+    const auto& parent0 = getTOFMatch(gidx); //ITS/TPC/TRD : TOF
+    const auto& parent1 = getITSTPCTRDTrack<o2::trd::TrackTRD>(parent0.getTrackRef());
+    const auto& parent2 = getTPCITSTrack(parent1.getRefGlobalTrackId());
+    return parent2.getRefTPC();
   } else if (src == GTrackID::TPCTOF) {
     const auto& parent0 = getTPCTOFMatch(gidx); //TPC : TOF
     return parent0.getTrackRef();
@@ -1081,6 +1146,11 @@ GTrackID RecoContainer::getITSContributorGID(GTrackID gidx) const
     const auto& parent0 = getTOFMatch(gidx); //ITS/TPC : TOF
     const auto& parent1 = getTPCITSTrack(parent0.getTrackRef());
     return parent1.getRefITS();
+  } else if (src == GTrackID::ITSTPCTRDTOF) {
+    const auto& parent0 = getTOFMatch(gidx); //ITS/TPC : TOF
+    const auto& parent1 = getITSTPCTRDTrack<o2::trd::TrackTRD>(parent0.getTrackRef());
+    const auto& parent2 = getTPCITSTrack(parent1.getRefGlobalTrackId());
+    return parent2.getRefITS();
   } else if (src == GTrackID::ITSTPC) {
     const auto& parent0 = getTPCITSTrack(gidx);
     return parent0.getRefITS();

Detectors/GlobalTrackingWorkflow/CMakeLists.txt

@@ -23,6 +23,7 @@ o2_add_library(GlobalTrackingWorkflow
                        src/CosmicsMatchingSpec.cxx
                        src/TrackCosmicsWriterSpec.cxx
                        src/TOFMatcherSpec.cxx
+                       src/TOFMatchChecker.cxx
                        src/GlobalFwdTrackWriterSpec.cxx
                PUBLIC_LINK_LIBRARIES O2::GlobalTracking
                                      O2::GlobalTrackingWorkflowReaders
@@ -73,6 +74,10 @@ o2_add_executable(matcher-workflow
                   COMPONENT_NAME tof
                   SOURCES src/tof-matcher-workflow.cxx
                   PUBLIC_LINK_LIBRARIES O2::GlobalTrackingWorkflow O2::TOFWorkflowIO)
+o2_add_executable(match-checker-workflow
+                  COMPONENT_NAME tof
+                  SOURCES src/tof-match-checker-workflow.cxx
+                  PUBLIC_LINK_LIBRARIES O2::GlobalTrackingWorkflow O2::TOFWorkflowIO)
 
 o2_add_executable(matcher-workflow
                   COMPONENT_NAME globalfwd

Detectors/GlobalTrackingWorkflow/helpers/src/InputHelper.cxx

@@ -92,13 +92,19 @@ int InputHelper::addInputSpecs(const ConfigContext& configcontext, WorkflowSpec&
     specs.emplace_back(o2::globaltracking::getTrackTPCITSReaderSpec(maskTracksMC[GID::ITSTPC] || maskTracksMC[GID::ITSTPCTOF]));
   }
   if (maskMatches[GID::ITSTPCTOF] || maskTracks[GID::ITSTPCTOF]) {
-    specs.emplace_back(o2::tof::getTOFMatchedReaderSpec(maskTracksMC[GID::ITSTPCTOF], false, /*maskTracks[GID::ITSTPCTOF]*/ false)); // ITSTPCTOF does not provide tracks, only matchInfo
+    specs.emplace_back(o2::tof::getTOFMatchedReaderSpec(maskTracksMC[GID::ITSTPCTOF], 1, /*maskTracks[GID::ITSTPCTOF]*/ false)); // ITSTPCTOF does not provide tracks, only matchInfo
+  }
+  if (maskMatches[GID::ITSTPCTRDTOF] || maskTracks[GID::ITSTPCTRDTOF]) {
+    specs.emplace_back(o2::tof::getTOFMatchedReaderSpec(maskTracksMC[GID::ITSTPCTRDTOF], 3, /*maskTracks[GID::ITSTPCTOF]*/ false)); // ITSTPCTOF does not provide tracks, only matchInfo
+  }
+  if (maskMatches[GID::TPCTRDTOF] || maskTracks[GID::TPCTRDTOF]) {
+    specs.emplace_back(o2::tof::getTOFMatchedReaderSpec(maskTracksMC[GID::TPCTRDTOF], 2, /*maskTracks[GID::ITSTPCTOF]*/ false)); // ITSTPCTOF does not provide tracks, only matchInfo
   }
   if (maskClusters[GID::TOF] || maskTracks[GID::ITSTPCTOF]) { // Note: maskTracks[GID::ITSTPCTOF] is only here to match the behavior of RecoContainer::requestTracks
     specs.emplace_back(o2::tof::getClusterReaderSpec(maskClustersMC[GID::TOF]));
   }
   if (maskMatches[GID::TPCTOF]) {
-    specs.emplace_back(o2::tof::getTOFMatchedReaderSpec(maskTracksMC[GID::TPCTOF], true, maskTracks[GID::TPCTOF], subSpecStrict));
+    specs.emplace_back(o2::tof::getTOFMatchedReaderSpec(maskTracksMC[GID::TPCTOF], 0, maskTracks[GID::TPCTOF], subSpecStrict));
   }
   if (maskTracks[GID::FT0] || maskClusters[GID::FT0]) {
     specs.emplace_back(o2::ft0::getRecPointReaderSpec(maskTracksMC[GID::FT0] || maskClustersMC[GID::FT0]));
@@ -116,10 +122,10 @@ int InputHelper::addInputSpecs(const ConfigContext& configcontext, WorkflowSpec&
   if (maskClusters[GID::TRD]) {
     specs.emplace_back(o2::trd::getTRDTrackletReaderSpec(maskClustersMC[GID::TRD], true));
   }
-  if (maskTracks[GID::ITSTPCTRD]) {
+  if (maskTracks[GID::ITSTPCTRD] || maskTracks[GID::ITSTPCTRDTOF]) {
     specs.emplace_back(o2::trd::getTRDGlobalTrackReaderSpec(maskTracksMC[GID::ITSTPCTRD]));
   }
-  if (maskTracks[GID::TPCTRD]) {
+  if (maskTracks[GID::TPCTRD] || maskTracks[GID::TPCTRDTOF]) {
     specs.emplace_back(o2::trd::getTRDTPCTrackReaderSpec(maskTracksMC[GID::TPCTRD], subSpecStrict));
   }
   if (maskTracks[GID::MFTMCH]) {

Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatchChecker.h

@@ -0,0 +1,33 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   TOFMatchCheckerSpec.h
+
+#ifndef O2_TOF_MATCHCHECKER_SPEC
+#define O2_TOF_MATCHCHECKER_SPEC
+
+#include "Framework/DataProcessorSpec.h"
+#include "ReconstructionDataFormats/MatchInfoTOF.h"
+
+using namespace o2::framework;
+
+namespace o2
+{
+namespace globaltracking
+{
+
+/// create a processor spec
+framework::DataProcessorSpec getTOFMatchCheckerSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useMC);
+
+} // namespace globaltracking
+} // namespace o2
+
+#endif /* O2_TOF_MATCHER_SPEC */