L1Muon::L1TGC::FloatingTrackSelector Class Reference

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

#include <FloatingTrackSelector.h>

Collaboration diagram for L1Muon::L1TGC::FloatingTrackSelector:

Public Member Functions
void	select (const TgcSLCandidateContainer &candidates, xAOD::L1TGCCandDataContainer &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 15 of file FloatingTrackSelector.h.

Member Function Documentation

select()

void L1Muon::L1TGC::FloatingTrackSelector::select	(	const TgcSLCandidateContainer &	candidates,
		xAOD::L1TGCCandDataContainer &	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 49 of file FloatingTrackSelector.cxx.

                                                                     {
  std::vector<const TgcSLCandidate *> orderedCandidates;
  orderedCandidates.reserve(candidates.size());
  for (const TgcSLCandidate &candidate : candidates) {
    if (candidate.threshold == 0U)
      continue;
    orderedCandidates.emplace_back(&candidate);
  }
 
  std::stable_sort(orderedCandidates.begin(), orderedCandidates.end(),
                   [](const TgcSLCandidate *left, const TgcSLCandidate *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 TgcSLCandidate *candidate : orderedCandidates) {
    const CandidateGroup group = candidateGroup(*candidate);
    if (!haveCurrentGroup || group != currentGroup) {
      currentGroup = group;
      haveCurrentGroup = true;
      groupCandidate = 0U;
    }
    if (groupCandidate >= s_maxCandidatesPerSector)
      continue;
 
    ++groupCandidate;
    xAOD::L1TGCCandData *outputCandidate =
        output.push_back(std::make_unique<xAOD::L1TGCCandData>());
    fillOutputCandidate(*candidate, static_cast<std::uint8_t>(groupCandidate),
                        *outputCandidate);
  }
}

Member Data Documentation

s_maxCandidatesPerSector

std::size_t L1Muon::L1TGC::FloatingTrackSelector::s_maxCandidatesPerSector {6U}

staticconstexprprivate

Definition at line 30 of file FloatingTrackSelector.h.

{6U};

---

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

• FloatingTrackSelector.h
• FloatingTrackSelector.cxx