L1Muon::L1TGC::FloatingOverlapClassification Class Reference

Tag nearby candidates from distinct chamber paths. More...

#include <FloatingOverlapClassification.h>

Collaboration diagram for L1Muon::L1TGC::FloatingOverlapClassification:

Public Member Functions
	FloatingOverlapClassification (FloatingOverlapClassificationConfig config=FloatingOverlapClassificationConfig{})
void	classify (TgcSLCandidateContainer &candidates, FloatingOverlapClassificationStatistics &statistics) const

Private Attributes
FloatingOverlapClassificationConfig	m_config {}

Detailed Description

Tag nearby candidates from distinct chamber paths.

No candidate is removed or ranked. The tags provide event-local provenance for a later overlap-removal stage, after pT and Inner-Coincidence information are available.

Definition at line 33 of file FloatingOverlapClassification.h.

Constructor & Destructor Documentation

FloatingOverlapClassification()

L1Muon::L1TGC::FloatingOverlapClassification::FloatingOverlapClassification ( FloatingOverlapClassificationConfig config = FloatingOverlapClassificationConfig{} )

explicit

Definition at line 97 of file FloatingOverlapClassification.cxx.

    : m_config(config) {}

Member Function Documentation

classify()

void L1Muon::L1TGC::FloatingOverlapClassification::classify	(	TgcSLCandidateContainer &	candidates,
		FloatingOverlapClassificationStatistics &	statistics ) const

Definition at line 100 of file FloatingOverlapClassification.cxx.

                                                               {
  statistics = FloatingOverlapClassificationStatistics{};
  for (TgcSLCandidate& candidate : candidates) {
    candidate.overlapGroupId = 0U;
    candidate.overlapMultiplicity = 1U;
    candidate.inChamberOverlap = false;
  }
  if (candidates.size() < 2U) return;
 
  DisjointSet groups(candidates.size());
  for (std::size_t first = 0U; first < candidates.size(); ++first) {
    for (std::size_t second = first + 1U; second < candidates.size(); ++second) {
      if (isOverlapPair(candidates[first], candidates[second], m_config)) {
        groups.join(first, second);
      }
    }
  }
 
  std::vector<std::size_t> roots(candidates.size());
  std::vector<std::size_t> multiplicities(candidates.size(), 0U);
  for (std::size_t index = 0U; index < candidates.size(); ++index) {
    roots[index] = groups.find(index);
    ++multiplicities[roots[index]];
  }
 
  std::vector<std::uint16_t> groupIds(candidates.size(), 0U);
  std::uint16_t nextGroupId{1U};
  for (std::size_t index = 0U; index < candidates.size(); ++index) {
    const std::size_t root = roots[index];
    if (multiplicities[root] < 2U) continue;
    if (groupIds[root] == 0U) {
      groupIds[root] = nextGroupId++;
      ++statistics.nGroups;
      statistics.maxMultiplicity =
          std::max(statistics.maxMultiplicity, multiplicities[root]);
    }
    TgcSLCandidate& candidate = candidates[index];
    candidate.overlapGroupId = groupIds[root];
    candidate.overlapMultiplicity = static_cast<std::uint8_t>(
        std::min<std::size_t>(multiplicities[root], 0xffU));
    candidate.inChamberOverlap = true;
    ++statistics.nCandidates;
  }
}

Member Data Documentation

m_config

FloatingOverlapClassificationConfig L1Muon::L1TGC::FloatingOverlapClassification::m_config {}

private

Definition at line 42 of file FloatingOverlapClassification.h.

{};

---

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

• FloatingOverlapClassification.h
• FloatingOverlapClassification.cxx