L1Muon::L1TGC::FloatingStationCoincidenceBuilder Class Reference

Build station representative points from layer-level TGC hits. More...

#include <FloatingStationCoincidenceBuilder.h>

Collaboration diagram for L1Muon::L1TGC::FloatingStationCoincidenceBuilder:

Public Member Functions
StatusCode	build (const FloatingHitGroups &hitGroups, FloatingStationCoincidenceContainer &coincidences) const

Static Private Member Functions
static std::uint8_t	nominalLayers (FloatingStation station, bool isStrip)

Detailed Description

Build station representative points from layer-level TGC hits.

Definition at line 13 of file FloatingStationCoincidenceBuilder.h.

Member Function Documentation

build()

StatusCode L1Muon::L1TGC::FloatingStationCoincidenceBuilder::build	(	const FloatingHitGroups &	hitGroups,
		FloatingStationCoincidenceContainer &	coincidences ) const

Definition at line 58 of file FloatingStationCoincidenceBuilder.cxx.

                                                             {
  coincidences.clear();
 
  for (const auto& [key, groupHits] : hitGroups) {
    std::array<std::array<std::vector<const Hit*>, 2>, 3> grouped{};
    for (const Hit& hit : groupHits) {
      if (!isBigWheelStation(hit.station)) continue;
      grouped[stationIndex(hit.station)][hit.isStrip ? 1U : 0U].emplace_back(&hit);
    }
 
    for (std::size_t stationPosition = 0U; stationPosition < grouped.size();
         ++stationPosition) {
      const Station hitStation = static_cast<Station>(stationPosition);
      for (std::size_t projection = 0U; projection < 2U; ++projection) {
        const bool isStrip = projection == 1U;
        std::vector<const Hit*>& hits = grouped[stationPosition][projection];
        if (hits.empty()) continue;
 
        std::sort(hits.begin(), hits.end(),
                  [](const Hit* lhs, const Hit* rhs) {
                    if (lhs->channel != rhs->channel) {
                      return lhs->channel < rhs->channel;
                    }
                    if (lhs->gasGap != rhs->gasGap) {
                      return lhs->gasGap < rhs->gasGap;
                    }
                    if (lhs->stationEta != rhs->stationEta) {
                      return lhs->stationEta < rhs->stationEta;
                    }
                    return lhs->stationPhi < rhs->stationPhi;
                  });
 
        std::vector<const Hit*> cluster;
        auto flushCluster = [&]() {
          if (cluster.empty()) return;
 
          std::uint32_t channelSum = 0U;
          std::uint8_t layerMask = 0U;
          float etaSum = 0.F;
          float sinPhiSum = 0.F;
          float cosPhiSum = 0.F;
          float rSum = 0.F;
          float zSum = 0.F;
          for (const Hit* hit : cluster) {
            channelSum += hit->channel;
            if (hit->gasGap > 0U && hit->gasGap <= 3U) {
              layerMask |= static_cast<std::uint8_t>(1U << (hit->gasGap - 1U));
            }
            etaSum += hit->eta;
            sinPhiSum += std::sin(hit->phi);
            cosPhiSum += std::cos(hit->phi);
            rSum += hit->r;
            zSum += hit->z;
          }
 
          const std::uint8_t observedLayers = static_cast<std::uint8_t>(
              std::popcount(static_cast<unsigned int>(layerMask)));
          if (observedLayers == 0U) {
            cluster.clear();
            return;
          }
 
          const std::uint16_t representativeChannel =
              static_cast<std::uint16_t>(std::lround(
                  static_cast<double>(channelSum) /
                  static_cast<double>(cluster.size())));
          const Hit* representativeHit = nullptr;
          for (const Hit* hit : cluster) {
            if (betterRepresentativeHit(hit, representativeHit,
                                        representativeChannel)) {
              representativeHit = hit;
            }
          }
          if (representativeHit == nullptr) {
            cluster.clear();
            return;
          }
 
          const float scale = 1.F / static_cast<float>(cluster.size());
          coincidences.emplace_back(
              key, hitStation, isStrip, representativeHit->detectorSector,
              representativeHit->stationEta, representativeHit->stationPhi,
              representativeChannel, layerMask, observedLayers,
              nominalLayers(hitStation, isStrip), etaSum * scale,
              std::atan2(sinPhiSum, cosPhiSum), rSum * scale, zSum * scale);
          cluster.clear();
        };
 
        std::uint16_t previousChannel = 0U;
        bool hasPreviousChannel = false;
        for (const Hit* hit : hits) {
          if (!hasPreviousChannel ||
              std::abs(static_cast<int>(hit->channel) -
                       static_cast<int>(previousChannel)) <= 1) {
            cluster.emplace_back(hit);
          } else {
            flushCluster();
            cluster.emplace_back(hit);
          }
          previousChannel = hit->channel;
          hasPreviousChannel = true;
        }
        flushCluster();
      }
    }
  }
 
  std::sort(coincidences.begin(), coincidences.end(),
            [](const FloatingStationCoincidence& lhs,
               const FloatingStationCoincidence& rhs) {
              if (lhs.key.tie() != rhs.key.tie()) {
                return lhs.key.tie() < rhs.key.tie();
              }
              if (lhs.station != rhs.station) return lhs.station < rhs.station;
              if (lhs.isStrip != rhs.isStrip) return lhs.isStrip < rhs.isStrip;
              if (lhs.observedLayers != rhs.observedLayers) {
                return lhs.observedLayers > rhs.observedLayers;
              }
              return lhs.channel < rhs.channel;
            });
  return StatusCode::SUCCESS;
}

nominalLayers()

std::uint8_t L1Muon::L1TGC::FloatingStationCoincidenceBuilder::nominalLayers ( FloatingStation station, bool isStrip )

staticprivate

Definition at line 48 of file FloatingStationCoincidenceBuilder.cxx.

                                               {
  if (station == Station::M1 && !isStrip) return 3U;
  if (station == Station::M1 || station == Station::M2 ||
      station == Station::M3) {
    return 2U;
  }
  return 0U;
}

---

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

• FloatingStationCoincidenceBuilder.h
• FloatingStationCoincidenceBuilder.cxx