MuonML::SegmentTrackCandidateBuilderTool Class Reference

#include <SegmentTrackCandidateBuilderTool.h>

Inheritance diagram for MuonML::SegmentTrackCandidateBuilderTool:

Collaboration diagram for MuonML::SegmentTrackCandidateBuilderTool:

Public Member Functions
StatusCode	buildCandidates (const EventContext &ctx, const SegmentEdgeGraph &graph, const std::vector< SegmentEdgeScore > &scores, std::vector< std::vector< unsigned > > &candidateIdsPerSegment) const override

Private Attributes
Gaudi::Property< float >	m_edgeThreshold
Gaudi::Property< float >	m_overlapThreshold
Gaudi::Property< bool >	m_useRecoveryComponents
Gaudi::Property< bool >	m_symmetrizeDirectedEdges
Gaudi::Property< bool >	m_addAllSegmentsRecoveryCandidate
Gaudi::Property< bool >	m_keepIsolatedSegments {this, "KeepIsolatedSegments", false}
Gaudi::Property< unsigned >	m_minCandidateSize {this, "MinCandidateSize", 2}

Detailed Description

Definition at line 12 of file SegmentTrackCandidateBuilderTool.h.

Member Function Documentation

buildCandidates()

StatusCode MuonML::SegmentTrackCandidateBuilderTool::buildCandidates ( const EventContext & ctx, const SegmentEdgeGraph & graph, const std::vector< SegmentEdgeScore > & scores, std::vector< std::vector< unsigned > > & candidateIdsPerSegment ) const

override

Definition at line 91 of file SegmentTrackCandidateBuilderTool.cxx.

                                                                  {
 
  candidateIdsPerSegment.assign(graph.nNodes, {});
 
  if (graph.nNodes == 0) return StatusCode::SUCCESS;
 
  const auto pairScore = makeUndirectedScores(graph, scores, m_symmetrizeDirectedEdges.value());
 
  // 1. High-purity cores.
  std::vector<NodeVec> candidates =
      componentsAboveThreshold(graph, pairScore,
                               m_overlapThreshold.value(),
                               m_keepIsolatedSegments.value());
 
  // 2. Recall recovery components.
  //
  // This is the important no-loss improvement. A true trajectory may contain
  // only 0.3--0.7 edge probabilities, especially for difficult segments.
  // The previous implementation never created a candidate unless some edge
  // crossed OverlapThreshold. Here we add an extra low-threshold connected
  // component candidate.
  if (m_useRecoveryComponents.value()) {
    std::vector<NodeVec> recovery =
        componentsAboveThreshold(graph, pairScore,
                                 m_edgeThreshold.value(),
                                 m_keepIsolatedSegments.value());
    candidates.insert(candidates.end(),
                      std::make_move_iterator(recovery.begin()),
                      std::make_move_iterator(recovery.end()));
  }
 
  // 3. Optional validation/debug safety net.
  //
  // This should be disabled for production timing studies, but it is useful
  // when proving that remaining losses are due to the model/graph pruning
  // rather than the seeding wrapper.
  if (m_addAllSegmentsRecoveryCandidate.value() &&
      graph.nNodes >= m_minCandidateSize.value()) {
    NodeVec all(graph.nNodes);
    std::iota(all.begin(), all.end(), 0);
    candidates.push_back(std::move(all));
  }
 
  // 4. Remove exact duplicate candidate node sets and assign IDs.
  std::set<NodeVec> seen;
  unsigned next = 0;
  for (NodeVec& nodes : candidates) {
    std::sort(nodes.begin(), nodes.end());
    nodes.erase(std::unique(nodes.begin(), nodes.end()), nodes.end());
    if (nodes.size() < m_minCandidateSize.value()) continue;
    if (!seen.insert(nodes).second) continue;
 
    for (std::size_t n : nodes) {
      addUnique(candidateIdsPerSegment[n], next);
    }
    ++next;
  }
 
  for (auto& ids : candidateIdsPerSegment) {
    std::sort(ids.begin(), ids.end());
  }
 
  std::unordered_map<unsigned, unsigned> candSegCount;
  candSegCount.reserve(next);
  for (const auto& ids : candidateIdsPerSegment) {
    for (unsigned id : ids) ++candSegCount[id];
  }
 
  std::size_t assignedNodes = 0;
  std::size_t multiAssignedNodes = 0;
  for (const auto& ids : candidateIdsPerSegment) {
    assignedNodes += !ids.empty();
    multiAssignedNodes += ids.size() > 1;
  }
 
  ATH_MSG_DEBUG("buildCandidates: " << candSegCount.size()
                << " candidate(s) from " << graph.nNodes
                << " segment(s); assignedNodes=" << assignedNodes
                << ", multiAssignedNodes=" << multiAssignedNodes
                << ", edgeThreshold=" << m_edgeThreshold.value()
                << ", overlapThreshold=" << m_overlapThreshold.value()
                << ", recovery=" << m_useRecoveryComponents.value()
                << ", symmetrize=" << m_symmetrizeDirectedEdges.value());
  if (msgLvl(MSG::VERBOSE)) {
    for (const auto& [id, nSegs] : candSegCount) {
      ATH_MSG_VERBOSE("  candidate " << id << ": " << nSegs << " segment(s)");
    }
  }
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_addAllSegmentsRecoveryCandidate

Gaudi::Property<bool> MuonML::SegmentTrackCandidateBuilderTool::m_addAllSegmentsRecoveryCandidate

private

Initial value:

{
      this, "AddAllSegmentsRecoveryCandidate", false,
      "Add one final candidate containing all graph nodes; use only for no-loss validation/debugging"}

Definition at line 36 of file SegmentTrackCandidateBuilderTool.h.

                                                         {
      this, "AddAllSegmentsRecoveryCandidate", false,
      "Add one final candidate containing all graph nodes; use only for no-loss validation/debugging"};

m_edgeThreshold

Gaudi::Property<float> MuonML::SegmentTrackCandidateBuilderTool::m_edgeThreshold

private

Initial value:

{
      this, "EdgeThreshold", 0.25f,
      "Loose edge probability threshold used for recall/recovery components"}

Definition at line 20 of file SegmentTrackCandidateBuilderTool.h.

                                        {
      this, "EdgeThreshold", 0.25f,
      "Loose edge probability threshold used for recall/recovery components"};

m_keepIsolatedSegments

Gaudi::Property<bool> MuonML::SegmentTrackCandidateBuilderTool::m_keepIsolatedSegments {this, "KeepIsolatedSegments", false}

private

Definition at line 40 of file SegmentTrackCandidateBuilderTool.h.

{this, "KeepIsolatedSegments", false};

m_minCandidateSize

Gaudi::Property<unsigned> MuonML::SegmentTrackCandidateBuilderTool::m_minCandidateSize {this, "MinCandidateSize", 2}

private

Definition at line 41 of file SegmentTrackCandidateBuilderTool.h.

{this, "MinCandidateSize", 2};

m_overlapThreshold

Gaudi::Property<float> MuonML::SegmentTrackCandidateBuilderTool::m_overlapThreshold

private

Initial value:

{
      this, "OverlapThreshold", 0.8f,
      "High-purity edge probability threshold used to build core components"}

Definition at line 24 of file SegmentTrackCandidateBuilderTool.h.

                                           {
      this, "OverlapThreshold", 0.8f,
      "High-purity edge probability threshold used to build core components"};

m_symmetrizeDirectedEdges

Gaudi::Property<bool> MuonML::SegmentTrackCandidateBuilderTool::m_symmetrizeDirectedEdges

private

Initial value:

{
      this, "SymmetrizeDirectedEdges", true,
      "Use max(score i->j, score j->i) for undirected segment association"}

Definition at line 32 of file SegmentTrackCandidateBuilderTool.h.

                                                 {
      this, "SymmetrizeDirectedEdges", true,
      "Use max(score i->j, score j->i) for undirected segment association"};

m_useRecoveryComponents

Gaudi::Property<bool> MuonML::SegmentTrackCandidateBuilderTool::m_useRecoveryComponents

private

Initial value:

{
      this, "UseRecoveryComponents", true,
      "Add additional low-threshold connected components to recover true candidates missed by the high-purity core"}

Definition at line 28 of file SegmentTrackCandidateBuilderTool.h.

                                               {
      this, "UseRecoveryComponents", true,
      "Add additional low-threshold connected components to recover true candidates missed by the high-purity core"};

---

The documentation for this class was generated from the following files:

• SegmentTrackCandidateBuilderTool.h
• SegmentTrackCandidateBuilderTool.cxx