Different DataDescriptions for TOF-TPC and TOF-Global match outputs

shahor02 · shahor02 · commit d76a6517e3ad · 2021-01-31T22:50:17.000+01:00
diff --git a/Detectors/GlobalTrackingWorkflow/tofworkflow/include/TOFWorkflow/CalibInfoReaderSpec.h b/Detectors/GlobalTrackingWorkflow/tofworkflow/include/TOFWorkflow/CalibInfoReaderSpec.h
@@ -31,7 +31,7 @@ namespace tof
 class CalibInfoReader : public Task
 {
  public:
-  CalibInfoReader(int instance, int ninstances, const char* filename) : mInstance(instance), mNinstances(ninstances), mFileName(filename) {}
+  CalibInfoReader(int instance, int ninstances, const char* filename, bool toftpc = false) : mInstance(instance), mNinstances(ninstances), mFileName(filename), mTOFTPC(toftpc) {}
   ~CalibInfoReader() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -43,14 +43,15 @@ class CalibInfoReader : public Task
   const char* mFileName = nullptr;
   FILE* mFile = nullptr;
   TTree* mTree = nullptr;
+  bool mTOFTPC = false;
   int mCurrentEntry = 0;
   int mGlobalEntry = 0;
   std::vector<o2::dataformats::CalibInfoTOF> mVect, *mPvect = &mVect;
 };
 
 /// create a processor spec
 /// read simulated TOF digits from a root file
-framework::DataProcessorSpec getCalibInfoReaderSpec(int instance, int ninstances, const char* filename);
+framework::DataProcessorSpec getCalibInfoReaderSpec(int instance, int ninstances, const char* filename, bool toftpc = false);
 
 } // namespace tof
 } // namespace o2
diff --git a/Detectors/GlobalTrackingWorkflow/tofworkflow/include/TOFWorkflow/TOFCalibWriterSpec.h b/Detectors/GlobalTrackingWorkflow/tofworkflow/include/TOFWorkflow/TOFCalibWriterSpec.h
@@ -24,7 +24,7 @@ namespace tof
 
 /// create a processor spec
 /// write TOF calbi info in a root file
-o2::framework::DataProcessorSpec getTOFCalibWriterSpec(const char* outdef = "o2calib_tof.root");
+o2::framework::DataProcessorSpec getTOFCalibWriterSpec(const char* outdef = "o2calib_tof.root", bool toftpc = false);
 
 } // namespace tof
 } // namespace o2
diff --git a/Detectors/GlobalTrackingWorkflow/tofworkflow/src/CalibInfoReaderSpec.cxx b/Detectors/GlobalTrackingWorkflow/tofworkflow/src/CalibInfoReaderSpec.cxx
@@ -29,6 +29,8 @@ namespace o2
 namespace tof
 {
 
+constexpr o2::header::DataDescription ddCalib{"CALIBDATA"}, ddCalib_tpc{"CALIBDATA_TPC"};
+
 void CalibInfoReader::init(InitContext& ic)
 {
   LOG(INFO) << "Init CalibInfo reader!";
@@ -59,7 +61,7 @@ void CalibInfoReader::run(ProcessingContext& pc)
     if ((mGlobalEntry % mNinstances) == mInstance) {
       mTree->GetEvent(mCurrentEntry);
       LOG(INFO) << "Send " << mVect.size() << " calib infos";
-      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "CALIBDATA", 0, Lifetime::Timeframe}, mVect);
+      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, mTOFTPC ? ddCalib_tpc : ddCalib, 0, Lifetime::Timeframe}, mVect);
       usleep(10000);
     }
     mGlobalEntry++;
@@ -71,16 +73,17 @@ void CalibInfoReader::run(ProcessingContext& pc)
   return;
 }
 
-DataProcessorSpec getCalibInfoReaderSpec(int instance, int ninstances, const char* filename)
+DataProcessorSpec getCalibInfoReaderSpec(int instance, int ninstances, const char* filename, bool toftpc)
 {
   std::vector<OutputSpec> outputs;
-  outputs.emplace_back(o2::header::gDataOriginTOF, "CALIBDATA", 0, Lifetime::Timeframe);
+  outputs.emplace_back(o2::header::gDataOriginTOF, toftpc ? ddCalib_tpc : ddCalib, 0, Lifetime::Timeframe);
 
-  const char* nameSpec;
-  if (ninstances == 1) {
-    nameSpec = "tof-calibinfo-reader";
-  } else {
-    nameSpec = Form("tof-calibinfo-reader-%d", instance);
+  std::string nameSpec = "tof-calibinfo-reader";
+  if (toftpc) {
+    nameSpec += "-tpc";
+  }
+  if (ninstances > 1) {
+    nameSpec += fmt::format("-{:d}", instance);
   }
 
   return DataProcessorSpec{
diff --git a/Detectors/GlobalTrackingWorkflow/tofworkflow/src/RecoWorkflowSpec.cxx b/Detectors/GlobalTrackingWorkflow/tofworkflow/src/RecoWorkflowSpec.cxx
@@ -123,9 +123,9 @@ class TOFDPLRecoWorkflowTask
     // send matching-info
     pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHINFOS", 0, Lifetime::Timeframe}, mMatcher.getMatchedTrackVector());
     if (mUseMC) {
-      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHTOFINFOSMC", 0, Lifetime::Timeframe}, mMatcher.getMatchedTOFLabelsVector());
-      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHTPCINFOSMC", 0, Lifetime::Timeframe}, mMatcher.getMatchedTPCLabelsVector());
-      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHITSINFOSMC", 0, Lifetime::Timeframe}, mMatcher.getMatchedITSLabelsVector());
+      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MCMATCHTOF", 0, Lifetime::Timeframe}, mMatcher.getMatchedTOFLabelsVector());
+      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MCMATCHTPC", 0, Lifetime::Timeframe}, mMatcher.getMatchedTPCLabelsVector());
+      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MCMATCHITS", 0, Lifetime::Timeframe}, mMatcher.getMatchedITSLabelsVector());
     }
     pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "CALIBDATA", 0, Lifetime::Timeframe}, mMatcher.getCalibVector());
     mTimer.Stop();
@@ -160,9 +160,9 @@ o2::framework::DataProcessorSpec getTOFRecoWorkflowSpec(bool useMC, bool useFIT)
 
   outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHINFOS", 0, Lifetime::Timeframe);
   if (useMC) {
-    outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHTOFINFOSMC", 0, Lifetime::Timeframe);
-    outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHTPCINFOSMC", 0, Lifetime::Timeframe);
-    outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHITSINFOSMC", 0, Lifetime::Timeframe);
+    outputs.emplace_back(o2::header::gDataOriginTOF, "MCMATCHTOF", 0, Lifetime::Timeframe);
+    outputs.emplace_back(o2::header::gDataOriginTOF, "MCMATCHTPC", 0, Lifetime::Timeframe);
+    outputs.emplace_back(o2::header::gDataOriginTOF, "MCMATCHITS", 0, Lifetime::Timeframe);
   }
   outputs.emplace_back(o2::header::gDataOriginTOF, "CALIBDATA", 0, Lifetime::Timeframe);
 
diff --git a/Detectors/GlobalTrackingWorkflow/tofworkflow/src/RecoWorkflowWithTPCSpec.cxx b/Detectors/GlobalTrackingWorkflow/tofworkflow/src/RecoWorkflowWithTPCSpec.cxx
@@ -123,13 +123,13 @@ class TOFDPLRecoWorkflowWithTPCTask
     //           << " DIGITS TO " << mClustersArray.size() << " CLUSTERS";
 
     // send matching-info
-    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHINFOS", 0, Lifetime::Timeframe}, mMatcher.getMatchedTrackVector());
+    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHINFOS_TPC", 0, Lifetime::Timeframe}, mMatcher.getMatchedTrackVector());
     if (mUseMC) {
-      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHTOFINFOSMC", 0, Lifetime::Timeframe}, mMatcher.getMatchedTOFLabelsVector());
-      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHTPCINFOSMC", 0, Lifetime::Timeframe}, mMatcher.getMatchedTPCLabelsVector());
-      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHITSINFOSMC", 0, Lifetime::Timeframe}, mMatcher.getMatchedITSLabelsVector());
+      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MCMATCHTOF_TPC", 0, Lifetime::Timeframe}, mMatcher.getMatchedTOFLabelsVector());
+      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MCMATCHTPC_TPC", 0, Lifetime::Timeframe}, mMatcher.getMatchedTPCLabelsVector());
+      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MCMATCHITS_TPC", 0, Lifetime::Timeframe}, mMatcher.getMatchedITSLabelsVector());
     }
-    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "CALIBDATA", 0, Lifetime::Timeframe}, mMatcher.getCalibVector());
+    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "CALIBDATA_TPC", 0, Lifetime::Timeframe}, mMatcher.getCalibVector());
     mTimer.Stop();
   }
 
@@ -164,15 +164,15 @@ o2::framework::DataProcessorSpec getTOFRecoWorkflowWithTPCSpec(bool useMC, bool
     inputs.emplace_back("fitrecpoints", o2::header::gDataOriginFT0, "RECPOINTS", 0, Lifetime::Timeframe);
   }
 
-  outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHINFOS", 0, Lifetime::Timeframe);
-  outputs.emplace_back(OutputLabel{"tpctofTracks"}, o2::header::gDataOriginTOF, "TPCTOFTRACKS", 0, Lifetime::Timeframe);
+  outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHINFOS_TPC", 0, Lifetime::Timeframe);
+  outputs.emplace_back(OutputLabel{"tpctofTracks"}, o2::header::gDataOriginTOF, "TOFTRACKS_TPC", 0, Lifetime::Timeframe);
 
   if (useMC) {
-    outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHTOFINFOSMC", 0, Lifetime::Timeframe);
-    outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHTPCINFOSMC", 0, Lifetime::Timeframe);
-    outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHITSINFOSMC", 0, Lifetime::Timeframe);
+    outputs.emplace_back(o2::header::gDataOriginTOF, "MCMATCHTOF_TPC", 0, Lifetime::Timeframe);
+    outputs.emplace_back(o2::header::gDataOriginTOF, "MCMATCHTPC_TPC", 0, Lifetime::Timeframe);
+    outputs.emplace_back(o2::header::gDataOriginTOF, "MCMATCHITS_TPC", 0, Lifetime::Timeframe);
   }
-  outputs.emplace_back(o2::header::gDataOriginTOF, "CALIBDATA", 0, Lifetime::Timeframe);
+  outputs.emplace_back(o2::header::gDataOriginTOF, "CALIBDATA_TPC", 0, Lifetime::Timeframe);
 
   return DataProcessorSpec{
     "TOFRecoWorkflowWithTPC",
diff --git a/Detectors/GlobalTrackingWorkflow/tofworkflow/src/TOFCalibWriterSpec.cxx b/Detectors/GlobalTrackingWorkflow/tofworkflow/src/TOFCalibWriterSpec.cxx
@@ -34,16 +34,17 @@ namespace tof
 template <typename T>
 using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
 using CalibInfosType = std::vector<o2::dataformats::CalibInfoTOF>;
-DataProcessorSpec getTOFCalibWriterSpec(const char* outdef)
+DataProcessorSpec getTOFCalibWriterSpec(const char* outdef, bool toftpc)
 {
   // A spectator for logging
   auto logger = [](CalibInfosType const& indata) {
     LOG(INFO) << "RECEIVED MATCHED SIZE " << indata.size();
   };
+  o2::header::DataDescription ddCalib{"CALIBDATA"}, ddCalib_tpc{"CALIBDATA_TPC"};
   return MakeRootTreeWriterSpec("TOFCalibWriter",
                                 outdef,
                                 "calibTOF",
-                                BranchDefinition<CalibInfosType>{InputSpec{"input", o2::header::gDataOriginTOF, "CALIBDATA", 0},
+                                BranchDefinition<CalibInfosType>{InputSpec{"input", o2::header::gDataOriginTOF, toftpc ? ddCalib_tpc : ddCalib, 0},
                                                                  "TOFCalibInfo",
                                                                  "calibinfo-branch-name",
                                                                  1,
diff --git a/Detectors/GlobalTrackingWorkflow/tofworkflow/src/TOFMatchedReaderSpec.cxx b/Detectors/GlobalTrackingWorkflow/tofworkflow/src/TOFMatchedReaderSpec.cxx
@@ -22,13 +22,18 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "ReconstructionDataFormats/MatchInfoTOF.h"
+#include "CommonUtils/StringUtils.h"
 
 using namespace o2::framework;
 
 namespace o2
 {
 namespace tof
 {
+o2::header::DataDescription ddMatchInfo{"MATCHINFOS"}, ddMatchInfo_tpc{"MATCHINFOS_TPC"},
+  ddMCMatchTOF{"MCMATCHTOF"}, ddMCMatchTOF_tpc{"MCMATCHTOF_TPC"},
+  ddMCMatchTPC{"MCMATCHTPC"}, ddMCMatchTPC_tpc{"MCMATCHTPC_TPC"},
+  ddMCMatchITS{"MCMATCHITS"}, ddMCMatchITS_tpc{"MCMATCHITS_TPC"};
 
 void TOFMatchedReader::init(InitContext& ic)
 {
@@ -51,7 +56,7 @@ void TOFMatchedReader::connectTree(const std::string& filename)
     if (!mTree->GetBranch("TPCTOFTracks")) {
       throw std::runtime_error("TPC-TOF tracks are requested but not found in the tree");
     }
-    mTree->SetBranchAddress("TPCTOFTracks", &mMatchesPtr);
+    mTree->SetBranchAddress("TPCTOFTracks", &mTracksPtr);
   }
   if (mUseMC) {
     mTree->SetBranchAddress("MatchTOFMCTruth", &mLabelTOFPtr);
@@ -68,14 +73,14 @@ void TOFMatchedReader::run(ProcessingContext& pc)
   mTree->GetEntry(currEntry);
   LOG(INFO) << "Pushing " << mMatches.size() << " TOF matchings at entry " << currEntry;
 
-  pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHINFOS", 0, Lifetime::Timeframe}, mMatches);
-  if (mReadTracks) {
-    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "TPCTOFTRACKS", 0, Lifetime::Timeframe}, mTracks);
+  pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, mTPCMatch ? ddMatchInfo_tpc : ddMatchInfo, 0, Lifetime::Timeframe}, mMatches);
+  if (mReadTracks && mTPCMatch) {
+    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "TOFTRACKS_TPC", 0, Lifetime::Timeframe}, mTracks);
   }
   if (mUseMC) {
-    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHTOFINFOSMC", 0, Lifetime::Timeframe}, mLabelTOF);
-    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHTPCINFOSMC", 0, Lifetime::Timeframe}, mLabelTPC);
-    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHITSINFOSMC", 0, Lifetime::Timeframe}, mLabelITS);
+    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, mTPCMatch ? ddMCMatchTOF_tpc : ddMCMatchTOF, 0, Lifetime::Timeframe}, mLabelTOF);
+    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, mTPCMatch ? ddMCMatchTPC_tpc : ddMCMatchTPC, 0, Lifetime::Timeframe}, mLabelTPC);
+    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, mTPCMatch ? ddMCMatchITS_tpc : ddMCMatchITS, 0, Lifetime::Timeframe}, mLabelITS);
   }
 
   if (mTree->GetReadEntry() + 1 >= mTree->GetEntries()) {
@@ -84,26 +89,27 @@ void TOFMatchedReader::run(ProcessingContext& pc)
   }
 }
 
-DataProcessorSpec getTOFMatchedReaderSpec(bool useMC, bool readTracks)
+DataProcessorSpec getTOFMatchedReaderSpec(bool useMC, bool tpcmatch, bool readTracks)
 {
   std::vector<OutputSpec> outputs;
-  outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHINFOS", 0, Lifetime::Timeframe);
-  if (readTracks) {
-    outputs.emplace_back(o2::header::gDataOriginTOF, "TPCTOFTRACKS", 0, Lifetime::Timeframe);
+
+  outputs.emplace_back(o2::header::gDataOriginTOF, tpcmatch ? ddMatchInfo_tpc : ddMatchInfo, 0, Lifetime::Timeframe);
+  if (tpcmatch && readTracks) {
+    outputs.emplace_back(o2::header::gDataOriginTOF, "TOFTRACKS_TPC", 0, Lifetime::Timeframe);
   }
   if (useMC) {
-    outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHTOFINFOSMC", 0, Lifetime::Timeframe);
-    outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHTPCINFOSMC", 0, Lifetime::Timeframe);
-    outputs.emplace_back(o2::header::gDataOriginTOF, "MATCHITSINFOSMC", 0, Lifetime::Timeframe);
+    outputs.emplace_back(o2::header::gDataOriginTOF, tpcmatch ? ddMCMatchTOF_tpc : ddMCMatchTOF, 0, Lifetime::Timeframe);
+    outputs.emplace_back(o2::header::gDataOriginTOF, tpcmatch ? ddMCMatchTPC_tpc : ddMCMatchTPC, 0, Lifetime::Timeframe);
+    outputs.emplace_back(o2::header::gDataOriginTOF, tpcmatch ? ddMCMatchITS_tpc : ddMCMatchITS, 0, Lifetime::Timeframe);
   }
 
   return DataProcessorSpec{
-    "TOFMatchedReader",
+    o2::utils::concat_string("TOFMatchedReader_", tpcmatch ? "tpc" : "glo"),
     Inputs{},
     outputs,
-    AlgorithmSpec{adaptFromTask<TOFMatchedReader>(useMC, readTracks)},
+    AlgorithmSpec{adaptFromTask<TOFMatchedReader>(useMC, tpcmatch, readTracks)},
     Options{
-      {"tof-matched-infile", VariantType::String, "o2match_tof.root", {"Name of the input file"}},
+      {"tof-matched-infile", VariantType::String, tpcmatch ? "o2match_toftpc.root" : "o2match_tof.root", {"Name of the input file"}},
       {"treename", VariantType::String, "matchTOF", {"Name of top-level TTree"}},
     }};
 }
diff --git a/Detectors/GlobalTrackingWorkflow/tofworkflow/src/TOFMatchedWriterSpec.cxx b/Detectors/GlobalTrackingWorkflow/tofworkflow/src/TOFMatchedWriterSpec.cxx
@@ -37,7 +37,7 @@ using TrackInfo = std::vector<o2::dataformats::TrackTPCTOF>;
 using LabelsType = std::vector<o2::MCCompLabel>;
 using namespace o2::header;
 
-DataProcessorSpec getTOFMatchedWriterSpec(bool useMC, const char* outdef, bool writeTracks)
+DataProcessorSpec getTOFMatchedWriterSpec(bool useMC, const char* outdef, bool writeTOFTPC)
 {
   // spectators for logging
   auto loggerMatched = [](MatchInfo const& indata) {
@@ -55,30 +55,34 @@ DataProcessorSpec getTOFMatchedWriterSpec(bool useMC, const char* outdef, bool w
   // TODO: there was a comment in the original implementation:
   // RS why do we need to repeat ITS/TPC labels ?
   // They can be extracted from TPC-ITS matches
+  o2::header::DataDescription ddMatchInfo{"MATCHINFOS"}, ddMatchInfo_tpc{"MATCHINFOS_TPC"},
+    ddMCMatchTOF{"MCMATCHTOF"}, ddMCMatchTOF_tpc{"MCMATCHTOF_TPC"},
+    ddMCMatchTPC{"MCMATCHTPC"}, ddMCMatchTPC_tpc{"MCMATCHTPC_TPC"},
+    ddMCMatchITS{"MCMATCHITS"}, ddMCMatchITS_tpc{"MCMATCHITS_TPC"};
 
-  return MakeRootTreeWriterSpec("TOFMatchedWriter",
+  return MakeRootTreeWriterSpec(writeTOFTPC ? "TOFMatchedWriter_TPC" : "TOFMatchedWriter",
                                 outdef,
                                 "matchTOF",
-                                BranchDefinition<MatchInfo>{InputSpec{"tofmatching", gDataOriginTOF, "MATCHINFOS", 0},
+                                BranchDefinition<MatchInfo>{InputSpec{"tofmatching", gDataOriginTOF, writeTOFTPC ? ddMatchInfo_tpc : ddMatchInfo, 0},
                                                             "TOFMatchInfo",
                                                             "TOFMatchInfo-branch-name",
                                                             1,
                                                             loggerMatched},
-                                BranchDefinition<TrackInfo>{InputSpec{"tpctofTracks", gDataOriginTOF, "TPCTOFTRACKS", 0},
+                                BranchDefinition<TrackInfo>{InputSpec{"tpctofTracks", gDataOriginTOF, "TOFTRACKS_TPC", 0},
                                                             "TPCTOFTracks",
                                                             "TPCTOFTracks-branch-name",
-                                                            writeTracks},
-                                BranchDefinition<LabelsType>{InputSpec{"matchtoflabels", gDataOriginTOF, "MATCHTOFINFOSMC", 0},
+                                                            writeTOFTPC},
+                                BranchDefinition<LabelsType>{InputSpec{"matchtoflabels", gDataOriginTOF, writeTOFTPC ? ddMCMatchTOF_tpc : ddMCMatchTOF, 0},
                                                              "MatchTOFMCTruth",
                                                              "MatchTOFMCTruth-branch-name",
                                                              (useMC ? 1 : 0), // one branch if mc labels enabled
                                                              loggerTofLabels},
-                                BranchDefinition<LabelsType>{InputSpec{"matchtpclabels", gDataOriginTOF, "MATCHTPCINFOSMC", 0},
+                                BranchDefinition<LabelsType>{InputSpec{"matchtpclabels", gDataOriginTOF, writeTOFTPC ? ddMCMatchTPC_tpc : ddMCMatchTPC, 0},
                                                              "MatchTPCMCTruth",
                                                              "MatchTPCMCTruth-branch-name",
                                                              (useMC ? 1 : 0), // one branch if mc labels enabled
                                                              loggerTpcLabels},
-                                BranchDefinition<LabelsType>{InputSpec{"matchitslabels", gDataOriginTOF, "MATCHITSINFOSMC", 0},
+                                BranchDefinition<LabelsType>{InputSpec{"matchitslabels", gDataOriginTOF, writeTOFTPC ? ddMCMatchITS_tpc : ddMCMatchITS, 0},
                                                              "MatchITSMCTruth",
                                                              "MatchITSMCTruth-branch-name",
                                                              (useMC ? 1 : 0), // one branch if mc labels enabled
diff --git a/Detectors/GlobalTrackingWorkflow/tofworkflow/src/tof-calibinfo-reader.cxx b/Detectors/GlobalTrackingWorkflow/tofworkflow/src/tof-calibinfo-reader.cxx
@@ -34,6 +34,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
 {
   workflowOptions.push_back(ConfigParamSpec{"collection-infile", o2::framework::VariantType::String, "list-calibfile", {"Name of the collection input file"}});
   workflowOptions.push_back(ConfigParamSpec{"ninstances", o2::framework::VariantType::Int, 1, {"Number of reader instances"}});
+  workflowOptions.push_back(ConfigParamSpec{"tpc-matches", o2::framework::VariantType::Bool, false, {"Made from TOF-TPC matches"}});
   workflowOptions.push_back(ConfigParamSpec{"configKeyValues", o2::framework::VariantType::String, "", {"Semicolon separated key=value strings ..."}});
 }
 
@@ -65,6 +66,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 
   int ninstances = cfgc.options().get<int>("ninstances");
   auto listname = cfgc.options().get<std::string>("collection-infile");
+  auto toftpc = cfgc.options().get<bool>("tpc-matches");
 
   char* stringTBP = new char[listname.size()];
   sprintf(stringTBP, "%s", listname.c_str());
@@ -74,7 +76,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   // std::vector<int> laneConfiguration = tofSectors;
 
   for (int i = 0; i < ninstances; i++) {
-    specs.emplace_back(o2::tof::getCalibInfoReaderSpec(i, ninstances, stringTBP));
+    specs.emplace_back(o2::tof::getCalibInfoReaderSpec(i, ninstances, stringTBP, toftpc));
   }
 
   LOG(INFO) << "Number of active devices = " << specs.size();
diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx

Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)`
`34`	`34`	`{`
`35`	`35`	`workflowOptions.push_back(ConfigParamSpec{"collection-infile", o2::framework::VariantType::String, "list-calibfile", {"Name of the collection input file"}});`
`36`	`36`	`workflowOptions.push_back(ConfigParamSpec{"ninstances", o2::framework::VariantType::Int, 1, {"Number of reader instances"}});`
	`37`	`+ workflowOptions.push_back(ConfigParamSpec{"tpc-matches", o2::framework::VariantType::Bool, false, {"Made from TOF-TPC matches"}});`
`37`	`38`	`workflowOptions.push_back(ConfigParamSpec{"configKeyValues", o2::framework::VariantType::String, "", {"Semicolon separated key=value strings ..."}});`
`38`	`39`	`}`
`39`	`40`
`@@ -65,6 +66,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)`
`65`	`66`
`66`	`67`	`int ninstances = cfgc.options().get<int>("ninstances");`
`67`	`68`	`auto listname = cfgc.options().get<std::string>("collection-infile");`
	`69`	`+ auto toftpc = cfgc.options().get<bool>("tpc-matches");`
`68`	`70`
`69`	`71`	`char* stringTBP = new char[listname.size()];`
`70`	`72`	`sprintf(stringTBP, "%s", listname.c_str());`
`@@ -74,7 +76,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)`
`74`	`76`	`// std::vector<int> laneConfiguration = tofSectors;`
`75`	`77`
`76`	`78`	`for (int i = 0; i < ninstances; i++) {`
`77`		`- specs.emplace_back(o2::tof::getCalibInfoReaderSpec(i, ninstances, stringTBP));`
	`79`	`+ specs.emplace_back(o2::tof::getCalibInfoReaderSpec(i, ninstances, stringTBP, toftpc));`
`78`	`80`	`}`
`79`	`81`
`80`	`82`	`LOG(INFO) << "Number of active devices = " << specs.size();`