L0Muon::TgcL0Floating::OverlapClassification Class Reference

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

#include <TgcL0OverlapClassification.h>

Collaboration diagram for L0Muon::TgcL0Floating::OverlapClassification:

Public Member Functions
	OverlapClassification (OverlapClassificationConfig config=OverlapClassificationConfig{})
void	classify (TgcL0CandidateContainer &candidates, OverlapClassificationStatistics &statistics) const

Private Attributes
OverlapClassificationConfig	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 34 of file TgcL0OverlapClassification.h.

Constructor & Destructor Documentation

OverlapClassification()

L0Muon::TgcL0Floating::OverlapClassification::OverlapClassification ( OverlapClassificationConfig config = OverlapClassificationConfig{} )

explicit

Definition at line 98 of file TgcL0OverlapClassification.cxx.

    : m_config(config) {}

Member Function Documentation

classify()

void L0Muon::TgcL0Floating::OverlapClassification::classify	(	TgcL0CandidateContainer &	candidates,
		OverlapClassificationStatistics &	statistics ) const

Definition at line 101 of file TgcL0OverlapClassification.cxx.

                                                       {
  statistics = OverlapClassificationStatistics{};
  for (TgcL0Candidate& 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]);
    }
    TgcL0Candidate& 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

OverlapClassificationConfig L0Muon::TgcL0Floating::OverlapClassification::m_config {}

private

Definition at line 43 of file TgcL0OverlapClassification.h.

{};

---

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

• TgcL0OverlapClassification.h
• TgcL0OverlapClassification.cxx