L0Muon::TgcL0Floating::TrackSelector Class Reference

Select and convert floating-point TGC candidates. More...

#include <TgcL0TrackSelector.h>

Collaboration diagram for L0Muon::TgcL0Floating::TrackSelector:

Public Member Functions
void	select (const TgcL0CandidateContainer &candidates, xAOD::TGCCandDataContainer &output) const
	Fill the xAOD output with the six highest-threshold candidates per sector for one BC processing chain.

Static Private Attributes
static constexpr std::size_t	s_maxCandidatesPerSector {6U}

Detailed Description

Select and convert floating-point TGC candidates.

Definition at line 16 of file TgcL0TrackSelector.h.

Member Function Documentation

select()

void TrackSelector::select	(	const TgcL0CandidateContainer &	candidates,
		xAOD::TGCCandDataContainer &	output ) const

Fill the xAOD output with the six highest-threshold candidates per sector for one BC processing chain.

Parameters

candidates	Input candidates after Inner Coincidence and BC-chain selection.
output	Output TGC candidate container.

Definition at line 52 of file TgcL0TrackSelector.cxx.

                                                                   {
  std::vector<const TgcL0Candidate *> orderedCandidates;
  orderedCandidates.reserve(candidates.size());
  for (const TgcL0Candidate &candidate : candidates) {
    if (candidate.threshold == 0U)
      continue;
    orderedCandidates.emplace_back(&candidate);
  }
 
  std::stable_sort(orderedCandidates.begin(), orderedCandidates.end(),
                   [](const TgcL0Candidate *left, const TgcL0Candidate *right) {
                     const CandidateGroup leftGroup = candidateGroup(*left);
                     const CandidateGroup rightGroup = candidateGroup(*right);
                     if (leftGroup != rightGroup)
                       return leftGroup < rightGroup;
 
                     if (left->threshold != right->threshold) {
                       return left->threshold > right->threshold;
                     }
                     const float leftPt = selectionPt(*left);
                     const float rightPt = selectionPt(*right);
                     if (leftPt != rightPt)
                       return leftPt > rightPt;
                     return left->selectorPriority > right->selectorPriority;
                   });
 
  CandidateGroup currentGroup{};
  bool haveCurrentGroup{false};
  std::size_t groupCandidate{0U};
  for (const TgcL0Candidate *candidate : orderedCandidates) {
    const CandidateGroup group = candidateGroup(*candidate);
    if (!haveCurrentGroup || group != currentGroup) {
      currentGroup = group;
      haveCurrentGroup = true;
      groupCandidate = 0U;
    }
    if (groupCandidate >= s_maxCandidatesPerSector)
      continue;
 
    ++groupCandidate;
    xAOD::TGCCandData *outputCandidate =
        output.push_back(std::make_unique<xAOD::TGCCandData>());
    fillOutputCandidate(*candidate, static_cast<std::uint8_t>(groupCandidate),
                        *outputCandidate);
  }
}

Member Data Documentation

s_maxCandidatesPerSector

std::size_t L0Muon::TgcL0Floating::TrackSelector::s_maxCandidatesPerSector {6U}

staticconstexprprivate

Definition at line 31 of file TgcL0TrackSelector.h.

{6U};

---

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

• TgcL0TrackSelector.h
• TgcL0TrackSelector.cxx