Muon/L1MuonNSW/src/MMT_Road.cxx

Go to the documentation of this file.

/*
 *   Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 */
 
#include "MMT_Road.h"
#include <algorithm>
#include <stdexcept>
 
namespace L1Muon::L1MM {
 
MMT_Road::MMT_Road(const char sector, const int roadSize,
                   const int UpX, const int DownX, const int UpUV, const int DownUV,
                   const int xthr, const int uvthr,
                   const int iroadx, const int iroadu, const int iroadv) :
  m_iroadx(iroadx),
  m_iroadu(iroadu != -1 ? iroadu : iroadx),
  m_iroadv(iroadv != -1 ? iroadv : iroadx),
  m_xthr(xthr),
  m_uvthr(uvthr),
  m_sector(sector)
{
  // Pre-calculate slopes
  m_slopeXlow  = roadSize*m_iroadx     + 0.5 - DownX;
  m_slopeXhigh = roadSize*(m_iroadx+1) + 0.5 + UpX;
 
  m_slopeUlow  = roadSize*m_iroadu     + 0.5 - DownUV;
  m_slopeUhigh = roadSize*(m_iroadu+1) + 0.5 + UpUV;
 
  m_slopeVlow  = roadSize*m_iroadv     + 0.5 - DownUV;
  m_slopeVhigh = roadSize*(m_iroadv+1) + 0.5 + UpUV;
}
 
void MMT_Road::addHits(const std::vector<const MMT_Hit*>& hits) {
  for (const MMT_Hit* hit_i : hits) {
    double low{0.}, high{0.};
    switch (hit_i->getType()) {
      case LayerType::X:
        low = m_slopeXlow;
        high = m_slopeXhigh;
        break;
      case LayerType::U:
        low = m_slopeUlow;
        high = m_slopeUhigh;
        break;
      case LayerType::V:
        low = m_slopeVlow;
        high = m_slopeVhigh;
        break;
      default:
        continue;
    }
    const double slow = hit_i->getShift() + low * hit_i->getPitchOverZ();
    const double shigh = hit_i->getShift() + high * hit_i->getPitchOverZ();
 
    const double val = hit_i->getRZSlope();
    bool has_hit = (val > 0.) ? (val > slow && val < shigh) : (val > shigh && val < slow);
    if (!has_hit) continue;
 
    const int pl = hit_i->getPlane();
    if (std::ranges::any_of(m_road_hits, [&pl](const auto &hit) { return (hit.getPlane() == pl); })) continue;
 
    m_road_hits.emplace_back(*hit_i);
    m_road_hits.back().setAge(0);
  }
}
 
double MMT_Road::avgSofXUV(const LayerType type) const {
  double sum = 0;
  unsigned short int N = 0;
  for (const auto &hit : m_road_hits) {
    if (hit.getType() != type) continue;
    sum += hit.getRZSlope();
    ++N;
  }
  if (N == 0)[[unlikely]]{
    throw std::runtime_error("MMT_Road::avgSofXUV: N is zero.");
  }
  return sum/N;
}
 
unsigned int MMT_Road::countUHits() const {
  return std::ranges::count_if(m_road_hits, [](const auto& hit) { return hit.isU(); });
}
 
unsigned int MMT_Road::countXHits() const {
  return std::ranges::count_if(m_road_hits, [](const auto& hit) { return hit.isX(); });
}
 
bool MMT_Road::evaluateLowRes() const {
  unsigned short int nhits1 = 0, nhits2 = 0;
  for (const auto &hit : m_road_hits) {
    nhits1 += hit.getPlane() < 4;
    nhits2 += hit.getPlane() > 3;
  }
  return (nhits1 < 4 || nhits2 < 4);
}
 
bool MMT_Road::horizontalCheck() const {
  unsigned short int nx1 = 0, nx2 = 0;
  for (const auto &hit : m_road_hits) {
    nx1 += hit.getPlane() < 2;
    nx2 += hit.getPlane() > 5;
 
    if (nx1 > 0 && nx2 > 0 && (nx1+nx2) >= m_xthr) return true;
  }
  return false;
}
 
void MMT_Road::incrementAge(const int bcwind) {
  unsigned short int old_ihits = 0;
  for (auto &hit : m_road_hits) {
    hit.setAge(hit.getAge()+1);
    if (hit.getAge() > (bcwind-1)) ++old_ihits;
  }
  m_road_hits.erase(m_road_hits.begin(), m_road_hits.begin()+old_ihits);
}
 
bool MMT_Road::matureCheck(const int bcwind) const {
  for (const auto &hit : m_road_hits) {
    if (hit.getAge() == (bcwind - 1)) return true;
  }
  return false;
}
 
double MMT_Road::mxl() const {
  std::vector<double> ys, zs;
  for (const auto &hit : m_road_hits) {
    if (hit.isX()) {
      ys.push_back(hit.getR());
      zs.push_back(hit.getZ());
    }
  }
  double mxl = 0;
  double avg_z = std::accumulate(zs.begin(), zs.end(), 0.0)/static_cast<double>(zs.size());
  double sum_sq_z = std::inner_product(zs.begin(), zs.end(), zs.begin(), 0.0);
  for (unsigned int i = 0; i < ys.size(); i++) {
    mxl += ys[i]*( (zs[i]-avg_z) / (sum_sq_z - zs.size()*std::pow(avg_z,2)) );
  }
 
  return mxl;
}
 
bool MMT_Road::stereoCheck() const {
  unsigned short int nu = 0, nv = 0;
  for (const auto &hit : m_road_hits) {
    nu += hit.isU();
    nv += hit.isV();
 
    if (nu > 0 && nv > 0 && (nu+nv) >= m_uvthr) return true;
  }
  return false;
}
 
}  // namespace L1Muon::L1MM