MatchCosmics: reject legs that are part of primary-vertex contributors

Review suggestion: a TPC track that is part of a global track contributing
to a primary vertex comes from a collision, not from a cosmic. The existing
veto (--use-pv-info with cosmicsMatch.discardPVContributors, default on)
compared the contributor's own track ID with the seeds, so it never fired
for TPC-only legs: the contributors are ITS-TPC and higher.

New workflow option --pv-contributor-sources (implies --use-pv-info,
ignored with a warning if discardPVContributors is off): the contributors
of these global track sources reject every leg they contain
(RecoContainer::getSingleDetectorRefs), e.g. their TPC track. The sources
and the parent matches needed to resolve them are loaded only for this;
the legs still come from --track-sources only. Log line: seeds rejected
per TF (also those that are themselves contributors).

PbPb 567939, 2 TFs with vertices (94 each), sources ITS-TPC,ITS-TPC-TRD,
ITS-TPC-TOF,ITS-TPC-TRD-TOF: 54 % of the TPC seeds rejected; without seed
DCA cuts the collision-track pairs drop from 183 / 285 to 58 / 88 per TF,
with the near-beam option the near-beam seeds by 57 %; matcher CPU for the
4 TFs (2 of them without vertices) 3.1 -> 2.3 s; the physics-v1 cosmic is
kept.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: matthias-kleiner

Detectors/GlobalTracking/include/GlobalTracking/MatchCosmics.h

@@ -118,6 +118,8 @@ class MatchCosmics
   void process(const o2::globaltracking::RecoContainer& data);
   void setUseMC(bool mc) { mUseMC = mc; }
   void setUsePVInfo(bool v) { mUsePVInfo = v; }
+  void setSeedSources(GTrackID::mask_t src) { mSeedSources = src; }     ///< track sources used as legs (other loaded ones resolve PV contributors)
+  void setPVVetoSources(GTrackID::mask_t src) { mPVVetoSources = src; } ///< sources whose PV contributors veto the legs they contain
   void init();
   void end();
 
@@ -180,6 +182,8 @@ class MatchCosmics
   bool mFieldON = true;
   bool mUsePVInfo = false;
   bool mUseMC = true;
+  GTrackID::mask_t mSeedSources{GTrackID::MASK_ALL};    ///< track sources used as legs
+  GTrackID::mask_t mPVVetoSources{GTrackID::MASK_NONE}; ///< sources whose PV contributors veto the legs they contain
   float mITSROFrameLengthMUS = 0.;
   float mQ2PtCutoff = 1e9;
   float mQ2PtCutoffOppositeSides = 1e9;
@@ -195,6 +199,7 @@ class MatchCosmics
   size_t mNTOFFallbacks = 0;                                    ///< TOF-confirmed winners refitted at their time without TOF in this TF
   size_t mNSeedsNearBeam = 0;                                   ///< TPC-only seeds kept for TOF-confirmed pairs only (minSeedDCAxyTOF) in this TF
   size_t mNNearBeamConfirmed = 0;                               ///< accepted pairs with such a seed, confirmed by a TOF flight pair, in this TF
+  size_t mNSeedsPVContributors = 0;                             ///< seeds rejected as part of a primary-vertex contributor in this TF
 
   std::vector<o2d::TrackCosmics> mCosmicTracks;
   std::vector<o2::MCCompLabel> mCosmicTracksLbl;

Detectors/GlobalTracking/src/MatchCosmics.cxx

@@ -161,6 +161,9 @@ void MatchCosmics::process(const o2::globaltracking::RecoContainer& data)
   if (mMatchParams->tofFlightSelection) {
     LOGP(info, "{} accepted pairs confirmed by a TOF flight pair", mNTOFConfirmed);
   }
+  if (mNSeedsPVContributors) {
+    LOGP(info, "{} seeds rejected as (part of) a primary-vertex contributor", mNSeedsPVContributors);
+  }
   if (mNSeedsNearBeam) {
     LOGP(info, "{} seeds near the beam line used in TOF-confirmed pairs only, {} such pairs confirmed", mNSeedsNearBeam, mNNearBeamConfirmed);
   }
@@ -940,8 +943,9 @@ void MatchCosmics::createSeeds(const o2::globaltracking::RecoContainer& data)
     }
   };
 
-  data.createTracksVariadic(creator);
+  data.createTracksVariadic(creator, mSeedSources); // other loaded sources only resolve the primary-vertex contributors below
 
+  mNSeedsPVContributors = 0;
   if (mUsePVInfo) {                                         // if needed, veto with the primary vertex info
     auto trackIndex = data.getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
     auto vtxRefs = data.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
@@ -954,11 +958,28 @@ void MatchCosmics::createSeeds(const o2::globaltracking::RecoContainer& data)
         auto tvid = trackIndex[it];
         auto entry = trackEntry.find(tvid);
         if (entry == trackEntry.end()) {
+          // a contributor of a veto source (not itself a leg): the legs it contains (e.g. its TPC track) come from a collision
+          if (mMatchParams->discardPVContributors && tvid.isPVContributor() && mPVVetoSources[tvid.getSource()] && data.isTrackSourceLoaded(tvid.getSource())) {
+            const auto refs = data.getSingleDetectorRefs(tvid);
+            for (int src = 0; src < GTrackID::NSources; src++) {
+              if (!mSeedSources[src] || !refs[src].isIndexSet()) {
+                continue;
+              }
+              auto partEntry = trackEntry.find(refs[src]);
+              if (partEntry != trackEntry.end() && mSeeds[partEntry->second].matchID != Reject) {
+                mSeeds[partEntry->second].matchID = Reject;
+                mNSeedsPVContributors++;
+              }
+            }
+          }
           continue;
         }
         auto& seed = mSeeds[entry->second];
-        if (seed.matchID == Reject || (mMatchParams->discardPVContributors && tvid.isPVContributor())) {
+        if (seed.matchID != Reject && mMatchParams->discardPVContributors && tvid.isPVContributor()) { // the leg itself is a contributor
           seed.matchID = Reject;
+          mNSeedsPVContributors++;
+        }
+        if (seed.matchID == Reject) {
           continue;
         }
         if (seed.vtIDMin < 0) {

Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/CosmicsMatchingSpec.h

@@ -24,7 +24,11 @@ namespace globaltracking
 {
 
 /// create a processor spec
-framework::DataProcessorSpec getCosmicsMatchingSpec(o2::dataformats::GlobalTrackID::mask_t src, bool usePV, bool useMC, bool itsStag, bool useTOFClusters = false);
+/// srcPVContributors plus the parent matches needed to resolve their single-detector parts (RecoContainer::getSingleDetectorRefs)
+o2::dataformats::GlobalTrackID::mask_t addPVContributorParents(o2::dataformats::GlobalTrackID::mask_t srcPVContributors);
+
+framework::DataProcessorSpec getCosmicsMatchingSpec(o2::dataformats::GlobalTrackID::mask_t src, bool usePV, bool useMC, bool itsStag, bool useTOFClusters = false,
+                                                    o2::dataformats::GlobalTrackID::mask_t srcPVContributors = {});
 
 } // namespace globaltracking
 } // namespace o2

Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx

@@ -66,7 +66,7 @@ namespace globaltracking
 class CosmicsMatchingSpec : public Task
 {
  public:
-  CosmicsMatchingSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool usePV, bool useMC) : mDataRequest(dr), mGGCCDBRequest(gr), mUsePVInfo(usePV), mUseMC(useMC) {}
+  CosmicsMatchingSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, GTrackID::mask_t srcPVVeto, bool usePV, bool useMC) : mDataRequest(dr), mGGCCDBRequest(gr), mSeedSources(src), mPVVetoSources(srcPVVeto), mUsePVInfo(usePV), mUseMC(useMC) {}
   ~CosmicsMatchingSpec() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -81,6 +81,8 @@ class CosmicsMatchingSpec : public Task
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
   const o2::gpu::TPCFastTransformPOD* mCorrMap{nullptr};
   o2::globaltracking::MatchCosmics mMatching; // matching engine
+  GTrackID::mask_t mSeedSources;              // track sources used as legs
+  GTrackID::mask_t mPVVetoSources;            // sources whose PV contributors veto the legs they contain
   bool mUseMC = true;
   bool mUsePVInfo = false;
   TStopwatch mTimer;
@@ -94,6 +96,8 @@ void CosmicsMatchingSpec::init(InitContext& ic)
   mMatching.setDebugFlag(ic.options().get<int>("debug-tree-flags"));
   mMatching.setUseMC(mUseMC);
   mMatching.setUsePVInfo(mUsePVInfo);
+  mMatching.setSeedSources(mSeedSources);
+  mMatching.setPVVetoSources(mPVVetoSources);
   //
 }
 
@@ -183,7 +187,22 @@ void CosmicsMatchingSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getCosmicsMatchingSpec(GTrackID::mask_t src, bool usePV, bool useMC, bool itsStag, bool useTOFClusters)
+GTrackID::mask_t addPVContributorParents(GTrackID::mask_t srcPVContributors)
+{
+  auto src = srcPVContributors;
+  if (src[GTrackID::ITSTPCTRDTOF]) {
+    src |= GTrackID::getSourceMask(GTrackID::ITSTPCTRD);
+  }
+  if (src[GTrackID::TPCTRDTOF]) {
+    src |= GTrackID::getSourceMask(GTrackID::TPCTRD);
+  }
+  if (src[GTrackID::ITSTPCTRD] || src[GTrackID::ITSTPCTOF]) {
+    src |= GTrackID::getSourceMask(GTrackID::ITSTPC);
+  }
+  return src;
+}
+
+DataProcessorSpec getCosmicsMatchingSpec(GTrackID::mask_t src, bool usePV, bool useMC, bool itsStag, bool useTOFClusters, GTrackID::mask_t srcPVContributors)
 {
   std::vector<OutputSpec> outputs;
   Options opts{
@@ -200,6 +219,8 @@ DataProcessorSpec getCosmicsMatchingSpec(GTrackID::mask_t src, bool usePV, bool
   }
   if (usePV) {
     dataRequest->requestPrimaryVertices(useMC);
+    // global tracks whose primary-vertex contributors veto their TPC track as a leg (MatchCosmicsParams::discardPVContributors), not legs
+    dataRequest->requestTracks(addPVContributorParents(srcPVContributors) & ~src, useMC); // same MC flag: some requests are shared with the legs
   }
 
   outputs.emplace_back("GLO", "COSMICTRC", 0, Lifetime::Timeframe);
@@ -224,7 +245,7 @@ DataProcessorSpec getCosmicsMatchingSpec(GTrackID::mask_t src, bool usePV, bool
     "cosmics-matcher",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<CosmicsMatchingSpec>(dataRequest, ggRequest, usePV, useMC)},
+    AlgorithmSpec{adaptFromTask<CosmicsMatchingSpec>(dataRequest, ggRequest, src, usePV ? srcPVContributors : GTrackID::mask_t{}, usePV, useMC)},
     opts};
 }
 

Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx

@@ -54,6 +54,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"disable-root-input", o2::framework::VariantType::Bool, false, {"disable root-files input reader"}},
     {"disable-root-output", o2::framework::VariantType::Bool, false, {"disable root-files output writer"}},
     {"use-pv-info", o2::framework::VariantType::Bool, false, {"request primary vertex for relevant cuts in the collision/cosmics interleaved data"}},
+    {"pv-contributor-sources", VariantType::String, "", {"global track sources (with TPC) loaded only to reject the TPC track of a primary-vertex contributor as a leg (cosmicsMatch.discardPVContributors, implies --use-pv-info), e.g. ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF"}},
     {"enable-cluster-output", o2::framework::VariantType::Bool, false, {"collect the raw clusters of the cosmics (legs + road around them) and write them with the cosmics"}},
     {"road-detectors", VariantType::String, "ITS,TOF,TRD", {"with --enable-cluster-output: detectors whose hits along the cosmic are collected besides the TPC road"}},
     {"cosmics-preset", VariantType::String, "", {"named set of cosmicsMatch settings applied before --configKeyValues (which can override single keys): physics-v1 = cosmics in collision data"}},
@@ -127,7 +128,15 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt));
   }
   bool usePV = configcontext.options().get<bool>("use-pv-info");
-  specs.emplace_back(o2::globaltracking::getCosmicsMatchingSpec(src, usePV, useMC, doStag, useTOFClusters));
+  GID::mask_t srcPV = GID::getSourcesMask("ITS-TPC,TPC-TRD,TPC-TOF,ITS-TPC-TRD,TPC-TRD-TOF,ITS-TPC-TOF,ITS-TPC-TRD-TOF") &
+                      GID::getSourcesMask(configcontext.options().get<std::string>("pv-contributor-sources"));
+  if (srcPV.any() && !o2::globaltracking::MatchCosmicsParams::Instance().discardPVContributors) {
+    LOG(warning) << "--pv-contributor-sources ignored: cosmicsMatch.discardPVContributors is off";
+    srcPV.reset();
+  }
+  usePV |= srcPV.any();
+  specs.emplace_back(o2::globaltracking::getCosmicsMatchingSpec(src, usePV, useMC, doStag, useTOFClusters, srcPV));
+  const auto srcPVLoaded = o2::globaltracking::addPVContributorParents(srcPV); // with the parents needed to resolve the contributors
   bool clusterOutput = configcontext.options().get<bool>("enable-cluster-output");
   if (clusterOutput) {
     if (!src[GID::TPC]) {
@@ -142,7 +151,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     specs.emplace_back(o2::globaltracking::getCosmicsClusterCollectorSpec(src, useMC, doStag, roadDets));
   }
 
-  o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCl, src, src, useMC, dummy); // clusters MC is not needed
+  o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCl, src | srcPVLoaded, src | srcPVLoaded, useMC, dummy); // clusters MC is not needed
   if (usePV) {
     o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC); // P-vertex is always needed
   }