Phase2L1GMT::TrackMuonMatchAlgorithm Class Reference

#include <TrackMuonMatchAlgorithm.h>

Public Member Functions
std::vector< PreTrackMatchedMuon >	cleanNeighbor (const std::vector< PreTrackMatchedMuon > &muons, const std::vector< PreTrackMatchedMuon > &muonsPrevious, const std::vector< PreTrackMatchedMuon > &muonsNext, bool equality)
std::vector< l1t::TrackerMuon >	convert (std::vector< PreTrackMatchedMuon > &muons, uint maximum)
bool	outputGT (std::vector< l1t::TrackerMuon > &muons)
std::vector< PreTrackMatchedMuon >	processNonant (const std::vector< ConvertedTTTrack > &convertedTracks, const std::vector< MuonROI > &rois)
std::vector< l1t::TrackerMuon >	sort (std::vector< l1t::TrackerMuon > &muons, uint maximum)
	TrackMuonMatchAlgorithm (const edm::ParameterSet &iConfig)
	~TrackMuonMatchAlgorithm ()

Private Member Functions
std::vector< PreTrackMatchedMuon >	clean (std::vector< PreTrackMatchedMuon > &muons)
ap_uint< 5 >	cleanMuon (const PreTrackMatchedMuon &mu, const PreTrackMatchedMuon &other, bool eq)
ap_uint< BITSSIGMACOORD+1 >	deltaCoord (const ap_int< BITSSTUBCOORD > &phi1, const ap_int< BITSSTUBCOORD > &phi2)
ap_uint< BITSSIGMAETA+1 >	deltaEta (const ap_int< BITSSTUBETA > &eta1, const ap_int< BITSSTUBETA > &eta2)
match_t	getBest (const std::vector< match_t > matches)
match_t	match (const propagation_t prop, const l1t::MuonStubRef &stub)
PreTrackMatchedMuon	processTrack (const ConvertedTTTrack &track, const std::vector< MuonROI > &rois)
propagation_t	propagate (const ConvertedTTTrack &track, uint layer)
match_t	propagateAndMatch (const ConvertedTTTrack &track, const l1t::MuonStubRef &stub)

Private Attributes
int	verbose_

Detailed Description

Definition at line 47 of file TrackMuonMatchAlgorithm.h.

Constructor & Destructor Documentation

TrackMuonMatchAlgorithm()

Phase2L1GMT::TrackMuonMatchAlgorithm::TrackMuonMatchAlgorithm ( const edm::ParameterSet &  iConfig )

inline

Definition at line 49 of file TrackMuonMatchAlgorithm.h.

: verbose_(iConfig.getParameter<int>("verbose")) {}

~TrackMuonMatchAlgorithm()

Phase2L1GMT::TrackMuonMatchAlgorithm::~TrackMuonMatchAlgorithm ( )

inline

Definition at line 51 of file TrackMuonMatchAlgorithm.h.

{}

Member Function Documentation

clean()

std::vector<PreTrackMatchedMuon> Phase2L1GMT::TrackMuonMatchAlgorithm::clean ( std::vector< PreTrackMatchedMuon > &  muons )

inlineprivate

Definition at line 594 of file TrackMuonMatchAlgorithm.h.

References cleanMuon(), mps_fire::i, dqmiolumiharvest::j, PDWG_BPHSkim_cff::muons, MillePedeFileConverter_cfg::out, parallelization::uint, and verbose_.

Referenced by processNonant().

                                                                                {
      std::vector<PreTrackMatchedMuon> out;
      if (muons.empty())
        return out;
      if (verbose_ == 1) {
        printf("-----Cleaning Up Muons in the same Nonant\n");
        printf("Before:\n");
      }
      for (uint i = 0; i < muons.size(); ++i) {
        if (verbose_ == 1)
          muons[i].print();

        ap_uint<5> mask = 0x1f;
        for (uint j = 0; j < muons.size(); ++j) {
          if (i == j)
            continue;
          mask = mask & cleanMuon(muons[i], muons[j], false);
        }
        if (mask) {
          if (verbose_ == 1)
            printf("kept\n");
          out.push_back(muons[i]);
        } else {
          if (verbose_ == 1)
            printf("discarded\n");
        }
      }
      return out;
    }

cleanMuon()

ap_uint<5> Phase2L1GMT::TrackMuonMatchAlgorithm::cleanMuon ( const PreTrackMatchedMuon &  mu, const PreTrackMatchedMuon &  other, bool  eq  )

inlineprivate

Definition at line 559 of file TrackMuonMatchAlgorithm.h.

References amptDefaultParameters_cff::mu, trackingPlots::other, hltL1SingleMuFiltered5_cfi::overlap, validateGeometry_cfg::valid, testProducerWithPsetDescEmpty_cfi::x1, and testProducerWithPsetDescEmpty_cfi::x2.

Referenced by clean(), and cleanNeighbor().

                                                                                                   {
      ap_uint<5> valid = 0;
      ap_uint<5> overlap = 0;
      if (mu.stubID0() != 511) {
        valid = valid | 0x1;
        if (mu.stubID0() == other.stubID0())
          overlap = overlap | 0x1;
      }
      if (mu.stubID1() != 511) {
        valid = valid | 0x2;
        if (mu.stubID1() == other.stubID1())
          overlap = overlap | 0x2;
      }
      if (mu.stubID2() != 511) {
        valid = valid | 0x4;
        if (mu.stubID2() == other.stubID2())
          overlap = overlap | 0x4;
      }
      if (mu.stubID3() != 511) {
        valid = valid | 0x8;
        if (mu.stubID3() == other.stubID3())
          overlap = overlap | 0x8;
      }
      if (mu.stubID4() != 511) {
        valid = valid | 0x10;
        if (mu.stubID4() == other.stubID4())
          overlap = overlap | 0x10;
      }

      if (((mu.quality() < other.quality()) && (!eq)) || ((mu.quality() <= other.quality()) && (eq)))
        return valid & (~overlap);
      else
        return valid;
    }

cleanNeighbor()

std::vector<PreTrackMatchedMuon> Phase2L1GMT::TrackMuonMatchAlgorithm::cleanNeighbor ( const std::vector< PreTrackMatchedMuon > &  muons, const std::vector< PreTrackMatchedMuon > &  muonsPrevious, const std::vector< PreTrackMatchedMuon > &  muonsNext, bool  equality  )

inline

Definition at line 65 of file TrackMuonMatchAlgorithm.h.

References cleanMuon(), mps_fire::i, dqmiolumiharvest::j, PDWG_BPHSkim_cff::muons, MillePedeFileConverter_cfg::out, parallelization::uint, and verbose_.

                                                                  {
      std::vector<PreTrackMatchedMuon> out;

      if (muons.empty())
        return out;

      if (verbose_ == 1) {
        printf("-----Cleaning Up Muons in the neighbours\n");
        printf("Before:\n");
      }

      for (uint i = 0; i < muons.size(); ++i) {
        if (verbose_ == 1) {
          muons[i].print();
        }
        ap_uint<5> mask = 0x1f;
        for (uint j = 0; j < muonsPrevious.size(); ++j) {
          mask = mask & cleanMuon(muons[i], muonsPrevious[j], equality);
        }
        for (uint j = 0; j < muonsNext.size(); ++j) {
          mask = mask & cleanMuon(muons[i], muonsNext[j], equality);
        }
        if (mask) {
          if (verbose_ == 1)
            printf("kept\n");
          out.push_back(muons[i]);
        } else {
          if (verbose_ == 1)
            printf("discarded\n");
        }
      }
      return out;
    }

convert()

std::vector<l1t::TrackerMuon> Phase2L1GMT::TrackMuonMatchAlgorithm::convert ( std::vector< PreTrackMatchedMuon > &  muons, uint  maximum  )

inline

Definition at line 102 of file TrackMuonMatchAlgorithm.h.

References amptDefaultParameters_cff::mu, HLT_2022v11_cff::muon, PDWG_BPHSkim_cff::muons, MillePedeFileConverter_cfg::out, and verbose_.

                                                                                           {
      std::vector<l1t::TrackerMuon> out;
      for (const auto& mu : muons) {
        if (out.size() == maximum)
          break;
        l1t::TrackerMuon muon(mu.trkPtr(), mu.charge(), mu.pt(), mu.eta(), mu.phi(), mu.z0(), mu.d0(), mu.quality());
        //muon.setMuonRef(mu.muonRef());
        for (const auto& stub : mu.stubs())
          muon.addStub(stub);
        out.push_back(muon);
        if (verbose_ == 1) {
          printf("Final Muon:");
          muon.print();
        }
      }
      return out;
    }

deltaCoord()

ap_uint<BITSSIGMACOORD + 1> Phase2L1GMT::TrackMuonMatchAlgorithm::deltaCoord ( const ap_int< BITSSTUBCOORD > &  phi1, const ap_int< BITSSTUBCOORD > &  phi2  )

inlineprivate

Definition at line 300 of file TrackMuonMatchAlgorithm.h.

References HLT_2022v11_cff::dPhi.

Referenced by match().

                                                                                                                 {
      ap_int<BITSSTUBCOORD> dPhiRoll = phi1 - phi2;
      ap_ufixed<BITSSIGMACOORD + 1, BITSSIGMACOORD + 1, AP_TRN_ZERO, AP_SAT_SYM> dPhi;
      if (dPhiRoll < 0)
        dPhi = ap_ufixed<BITSSIGMACOORD + 1, BITSSIGMACOORD + 1, AP_TRN_ZERO, AP_SAT_SYM>(-dPhiRoll);
      else
        dPhi = ap_ufixed<BITSSIGMACOORD + 1, BITSSIGMACOORD + 1, AP_TRN_ZERO, AP_SAT_SYM>(dPhiRoll);

      return ap_uint<BITSSIGMACOORD + 1>(dPhi);
    }

deltaEta()

ap_uint<BITSSIGMAETA + 1> Phase2L1GMT::TrackMuonMatchAlgorithm::deltaEta ( const ap_int< BITSSTUBETA > &  eta1, const ap_int< BITSSTUBETA > &  eta2  )

inlineprivate

Definition at line 292 of file TrackMuonMatchAlgorithm.h.

References HLT_2022v11_cff::dEta, HLT_2022v11_cff::eta1, and HLT_2022v11_cff::eta2.

Referenced by match().

                                                                                                         {
      ap_fixed<BITSSIGMAETA + 2, BITSSIGMAETA + 2, AP_TRN_ZERO, AP_SAT_SYM> dEta = eta1 - eta2;
      if (dEta < 0)
        return ap_uint<BITSSIGMAETA + 1>(-dEta);
      else
        return ap_uint<BITSSIGMAETA + 1>(dEta);
    }

getBest()

match_t Phase2L1GMT::TrackMuonMatchAlgorithm::getBest ( const std::vector< match_t >  matches )

inlineprivate

Definition at line 419 of file TrackMuonMatchAlgorithm.h.

References visualization-live-secondInstance_cfg::m, oniaPATMuonsWithTrigger_cff::matches, and Phase2L1GMT::match_t::quality.

Referenced by processTrack().

                                                      {
      match_t best = matches[0];
      for (const auto& m : matches) {
        if (m.quality > best.quality)
          best = m;
      }

      return best;
    }

match()

match_t Phase2L1GMT::TrackMuonMatchAlgorithm::match ( const propagation_t  prop, const l1t::MuonStubRef &  stub  )

inlineprivate

Definition at line 311 of file TrackMuonMatchAlgorithm.h.

References Phase2L1GMT::propagation_t::coord1, Phase2L1GMT::propagation_t::coord2, deltaCoord(), deltaEta(), Phase2L1GMT::propagation_t::eta, edm::Ref< C, T, F >::id(), Phase2L1GMT::propagation_t::is_barrel, MillePedeFileConverter_cfg::out, Phase2L1GMT::propagation_t::sigma_coord1, Phase2L1GMT::propagation_t::sigma_coord2, Phase2L1GMT::propagation_t::sigma_eta1, Phase2L1GMT::propagation_t::sigma_eta2, and verbose_.

Referenced by propagateAndMatch().

                                                                        {
      if (verbose_ == 1) {
        printf("Matching to ");
        stub->print();
      }
      //Matching of Coord1
      ap_uint<1> coord1Matched;
      ap_uint<BITSSIGMACOORD + 1> deltaCoord1 = deltaCoord(prop.coord1, stub->coord1());
      if (deltaCoord1 <= prop.sigma_coord1 && (stub->quality() & 0x1)) {
        coord1Matched = 1;
      } else {
        coord1Matched = 0;
      }
      if (verbose_ == 1)
        printf("Coord1 matched=%d delta=%d res=%d\n",
               coord1Matched.to_int(),
               deltaCoord1.to_int(),
               prop.sigma_coord1.to_int());

      //Matching of Coord2
      ap_uint<1> coord2Matched;
      ap_uint<BITSSIGMACOORD + 1> deltaCoord2 = deltaCoord(prop.coord2, stub->coord2());
      if (deltaCoord2 <= prop.sigma_coord2 && (stub->quality() & 0x2)) {
        coord2Matched = 1;
      } else {
        coord2Matched = 0;
      }
      if (verbose_ == 1)
        printf("Coord2 matched=%d delta=%d res=%d\n",
               coord2Matched.to_int(),
               deltaCoord2.to_int(),
               prop.sigma_coord2.to_int());

      //Matching of Eta1

      ap_uint<1> eta1Matched;

      //if we have really bad quality[Barrel no eta]
      //increase the resolution
      ap_ufixed<BITSSIGMAETA, BITSSIGMAETA, AP_TRN_ZERO, AP_SAT_SYM> prop_sigma_eta1;
      if (stub->etaQuality() == 0)
        prop_sigma_eta1 = prop.sigma_eta1 + 6;
      else
        prop_sigma_eta1 = prop.sigma_eta1;

      ap_uint<BITSSIGMAETA + 1> deltaEta1 = deltaEta(prop.eta, stub->eta1());
      if (deltaEta1 <= prop_sigma_eta1 && (stub->etaQuality() == 0 || (stub->etaQuality() & 0x1)))
        eta1Matched = 1;
      else
        eta1Matched = 0;

      if (verbose_ == 1)
        printf("eta1 matched=%d delta=%d res=%d\n", eta1Matched.to_int(), deltaEta1.to_int(), prop_sigma_eta1.to_int());

      //Matching of Eta2

      ap_uint<1> eta2Matched;

      ap_uint<BITSSIGMAETA + 1> deltaEta2 = deltaEta(prop.eta, stub->eta2());
      if (deltaEta2 <= prop.sigma_eta2 && (stub->etaQuality() & 0x2))
        eta2Matched = 1;
      else
        eta2Matched = 0;
      match_t out;
      out.id = stub->id();

      if (verbose_ == 1)
        printf("eta2 matched=%d delta=%d res=%d\n", eta2Matched.to_int(), deltaEta2.to_int(), prop.sigma_eta2.to_int());

      //if barrel, coord1 has to always be matched, coord2 maybe and eta1 is needed if etaQ=0 or then the one that depends on eta quality
      if (prop.is_barrel) {
        out.valid = (coord1Matched == 1 && (eta1Matched == 1 || eta2Matched == 1));
        if (out.valid == 0) {
          out.quality = 0;
        } else {
          out.quality = 32 - deltaCoord1;
          if (coord2Matched == 1)
            out.quality += 32 - deltaCoord2;
        }
      }
      //if endcap each coordinate is independent except the case where phiQuality=1 and etaQuality==3
      else {
        bool match1 = (coord1Matched == 1 && eta1Matched == 1);
        bool match2 = (coord2Matched == 1 && eta2Matched == 1);
        bool match3 =
            (coord1Matched == 1 && (eta1Matched || eta2Matched) && stub->etaQuality() == 3 && stub->quality() == 1);
        out.valid = match1 || match2 || match3;
        if (out.valid == 0)
          out.quality = 0;
        else {
          out.quality = 0;
          if (match1 || match3)
            out.quality += 32 - deltaCoord1;
          if (match2)
            out.quality += 32 - deltaCoord2;
        }
      }
      if (verbose_ == 1)
        printf("GlobalMatchQuality = %d\n", out.quality.to_int());
      out.stubRef = stub;
      return out;
    }

outputGT()

bool Phase2L1GMT::TrackMuonMatchAlgorithm::outputGT ( std::vector< l1t::TrackerMuon > &  muons )

inline

Definition at line 120 of file TrackMuonMatchAlgorithm.h.

References Phase2L1GMT::BITSGTD0, Phase2L1GMT::BITSGTETA, Phase2L1GMT::BITSGTISO, Phase2L1GMT::BITSGTPHI, Phase2L1GMT::BITSGTPT, Phase2L1GMT::BITSGTQUALITY, Phase2L1GMT::BITSGTZ0, Phase2L1GMT::BITSMUONBETA, amptDefaultParameters_cff::mu, and PDWG_BPHSkim_cff::muons.

                                                    {
      for (auto& mu : muons) {
        wordtype word1 = 0;
        wordtype word2 = 0;

        int bstart = 0;
        bstart = wordconcat<wordtype>(word1, bstart, mu.hwPt(), BITSGTPT);
        bstart = wordconcat<wordtype>(word1, bstart, mu.hwPhi(), BITSGTPHI);
        bstart = wordconcat<wordtype>(word1, bstart, mu.hwEta(), BITSGTETA);
        bstart = wordconcat<wordtype>(word1, bstart, mu.hwZ0(), BITSGTZ0);
        bstart = wordconcat<wordtype>(word1, bstart, (mu.hwD0() >> 2), BITSGTD0);

        bstart = 0;
        bstart = wordconcat<wordtype>(word2, bstart, mu.hwCharge(), 1);
        bstart = wordconcat<wordtype>(word2, bstart, mu.hwQual(), BITSGTQUALITY);
        bstart = wordconcat<wordtype>(word2, bstart, mu.hwIso(), BITSGTISO);
        bstart = wordconcat<wordtype>(word2, bstart, mu.hwBeta(), BITSMUONBETA);

        std::array<uint64_t, 2> wordout = {{word1, word2}};
        mu.setWord(wordout);
      }
      return true;
    }

processNonant()

std::vector<PreTrackMatchedMuon> Phase2L1GMT::TrackMuonMatchAlgorithm::processNonant ( const std::vector< ConvertedTTTrack > &  convertedTracks, const std::vector< MuonROI > &  rois  )

inline

Definition at line 53 of file TrackMuonMatchAlgorithm.h.

References clean(), GTTFileWriter_cff::convertedTracks, amptDefaultParameters_cff::mu, processTrack(), and HLT_2022v11_cff::track.

                                                                                   {
      std::vector<PreTrackMatchedMuon> preMuons;
      for (const auto& track : convertedTracks) {
        PreTrackMatchedMuon mu = processTrack(track, rois);
        if (mu.valid() && preMuons.size() < 16)
          preMuons.push_back(mu);
      }
      std::vector<PreTrackMatchedMuon> cleanedMuons = clean(preMuons);
      return cleanedMuons;
    }

processTrack()

PreTrackMatchedMuon Phase2L1GMT::TrackMuonMatchAlgorithm::processTrack ( const ConvertedTTTrack &  track, const std::vector< MuonROI > &  rois  )

inlineprivate

Definition at line 429 of file TrackMuonMatchAlgorithm.h.

References generateTowerEtThresholdLUT::addr, b, getBest(), mps_fire::i, Phase2L1GMT::lt_tpsID, visualization-live-secondInstance_cfg::m, HLT_2022v11_cff::muon, propagateAndMatch(), quality, HLT_2022v11_cff::track, parallelization::uint, and verbose_.

Referenced by processNonant().

                                                                                                    {
      std::vector<match_t> matchInfo0;
      std::vector<match_t> matchInfo1;
      std::vector<match_t> matchInfo2;
      std::vector<match_t> matchInfo3;
      std::vector<match_t> matchInfo4;

      if (verbose_ == 1 && !rois.empty()) {
        printf("-----------processing new track----------");
        track.print();
      }
      for (const auto& roi : rois) {
        if (verbose_ == 1) {
          printf("New ROI with %d stubs \n", int(roi.stubs().size()));
        }
        for (const auto& stub : roi.stubs()) {
          match_t m = propagateAndMatch(track, stub);
          if (m.valid == 1) {
            if (roi.isGlobalMuon() && roi.muonRef().isNonnull()) {
              m.isGlobal = true;
              m.muRef = roi.muonRef();
            }

            if (stub->tfLayer() == 0)
              matchInfo0.push_back(m);
            else if (stub->tfLayer() == 1)
              matchInfo1.push_back(m);
            else if (stub->tfLayer() == 2)
              matchInfo2.push_back(m);
            else if (stub->tfLayer() == 3)
              matchInfo3.push_back(m);
            else if (stub->tfLayer() == 4)
              matchInfo4.push_back(m);
          }
        }
      }

      ap_ufixed<6, 6, AP_TRN_ZERO, AP_SAT_SYM> ptPenalty = ap_ufixed<6, 6, AP_TRN_ZERO, AP_SAT_SYM>(track.pt() / 32);

      ap_uint<BITSMATCHQUALITY> quality = 0;
      PreTrackMatchedMuon muon(track.charge(), track.pt(), track.eta(), track.phi(), track.z0(), track.d0());

      if (!matchInfo0.empty()) {
        match_t b = getBest(matchInfo0);
        if (b.valid) {
          muon.addStub(b.stubRef);
          if (b.isGlobal)
            muon.addMuonRef(b.muRef);
          quality += b.quality;
        }
      }
      if (!matchInfo1.empty()) {
        match_t b = getBest(matchInfo1);
        if (b.valid) {
          muon.addStub(b.stubRef);
          if (b.isGlobal)
            muon.addMuonRef(b.muRef);
          quality += b.quality;
        }
      }
      if (!matchInfo2.empty()) {
        match_t b = getBest(matchInfo2);
        if (b.valid) {
          muon.addStub(b.stubRef);
          if (b.isGlobal)
            muon.addMuonRef(b.muRef);
          quality += b.quality;
        }
      }
      if (!matchInfo3.empty()) {
        match_t b = getBest(matchInfo3);
        if (b.valid) {
          muon.addStub(b.stubRef);
          if (b.isGlobal)
            muon.addMuonRef(b.muRef);
          quality += b.quality;
        }
      }
      if (!matchInfo4.empty()) {
        match_t b = getBest(matchInfo4);
        if (b.valid) {
          muon.addStub(b.stubRef);
          if (b.isGlobal)
            muon.addMuonRef(b.muRef);
          quality += b.quality;
        }
      }

      muon.setOfflineQuantities(track.offline_pt(), track.offline_eta(), track.offline_phi());
      muon.setTrkPtr(track.trkPtr());

      ap_uint<8> etaAddr = muon.eta() < 0 ? ap_uint<8>(-muon.eta() / 256) : ap_uint<8>((muon.eta()) / 256);
      ap_uint<8> ptAddr = muon.pt() > 4095 ? ap_uint<8>(15) : ap_uint<8>(muon.pt() / 256);
      ap_uint<8> addr = ptAddr | (etaAddr << 4);
      ap_uint<8> qualityCut = lt_tpsID[addr];

      if (quality >= qualityCut) {
        muon.setValid(true);
        muon.setQuality(quality + ptPenalty);
      } else {
        muon.setValid(false);
        muon.setQuality(0);
        muon.resetGlobal();
      }
      if (verbose_ == 1)
        muon.print();

      if (verbose_ == 1 && !rois.empty()) {  //patterns for HLS

        printf("TPS %d", track.trkPtr()->phiSector());
        track.printWord();

        for (uint i = 0; i < 16; ++i) {
          if (rois.size() > i) {
            rois[i].printROILine();
          } else {
            printf("%08x", 0);
            printf("%016lx", 0x1ff000000000000);
            printf("%016lx", 0x1ff000000000000);
            printf("%016lx", 0x1ff000000000000);
            printf("%016lx", 0x1ff000000000000);
            printf("%016lx", 0x1ff000000000000);
          }
        }
        muon.printWord();
        printf("\n");
      }
      return muon;
    }

propagate()

propagation_t Phase2L1GMT::TrackMuonMatchAlgorithm::propagate ( const ConvertedTTTrack &  track, uint  layer  )

inlineprivate

Definition at line 162 of file TrackMuonMatchAlgorithm.h.

References Phase2L1GMT::barrelLimit0_, Phase2L1GMT::barrelLimit1_, Phase2L1GMT::barrelLimit2_, Phase2L1GMT::barrelLimit3_, Phase2L1GMT::BITSPROPCOORD, Phase2L1GMT::BITSTTCURV, PixelRecoUtilities::curvature(), PVValHelper::eta, Phase2L1GMT::ETADIVIDER, phase1PixelTopology::layer, Phase2L1GMT::lt_prop_coord1_0, Phase2L1GMT::lt_prop_coord1_1, Phase2L1GMT::lt_prop_coord1_2, Phase2L1GMT::lt_prop_coord1_3, Phase2L1GMT::lt_prop_coord1_4, Phase2L1GMT::lt_prop_coord2_0, Phase2L1GMT::lt_prop_coord2_1, Phase2L1GMT::lt_prop_coord2_2, Phase2L1GMT::lt_prop_coord2_3, Phase2L1GMT::lt_prop_coord2_4, Phase2L1GMT::lt_res0_coord1_0, Phase2L1GMT::lt_res0_coord1_1, Phase2L1GMT::lt_res0_coord1_2, Phase2L1GMT::lt_res0_coord1_3, Phase2L1GMT::lt_res0_coord1_4, Phase2L1GMT::lt_res0_coord2_0, Phase2L1GMT::lt_res0_coord2_1, Phase2L1GMT::lt_res0_coord2_2, Phase2L1GMT::lt_res0_coord2_3, Phase2L1GMT::lt_res0_coord2_4, Phase2L1GMT::lt_res0_eta1_0, Phase2L1GMT::lt_res0_eta1_1, Phase2L1GMT::lt_res0_eta1_2, Phase2L1GMT::lt_res0_eta1_3, Phase2L1GMT::lt_res0_eta1_4, Phase2L1GMT::lt_res0_eta2_0, Phase2L1GMT::lt_res0_eta2_1, Phase2L1GMT::lt_res0_eta2_2, Phase2L1GMT::lt_res0_eta2_3, Phase2L1GMT::lt_res0_eta2_4, Phase2L1GMT::lt_res1_coord1_0, Phase2L1GMT::lt_res1_coord1_1, Phase2L1GMT::lt_res1_coord1_2, Phase2L1GMT::lt_res1_coord1_3, Phase2L1GMT::lt_res1_coord1_4, Phase2L1GMT::lt_res1_coord2_0, Phase2L1GMT::lt_res1_coord2_1, Phase2L1GMT::lt_res1_coord2_2, Phase2L1GMT::lt_res1_coord2_3, Phase2L1GMT::lt_res1_coord2_4, Phase2L1GMT::lt_res1_eta_0, Phase2L1GMT::lt_res1_eta_1, Phase2L1GMT::lt_res1_eta_2, Phase2L1GMT::lt_res1_eta_3, Phase2L1GMT::lt_res1_eta_4, MillePedeFileConverter_cfg::out, Phase2L1GMT::PHIDIVIDER, HLT_2022v11_cff::track, parallelization::uint, and verbose_.

Referenced by propagateAndMatch().

                                                                       {
      ap_uint<BITSPROPCOORD> prop_coord1 = 0;
      ap_uint<BITSPROPCOORD> prop_coord2 = 0;
      ap_uint<BITSPROPSIGMACOORD_A> res0_coord1 = 0;
      ap_uint<BITSPROPSIGMACOORD_B> res1_coord1 = 0;
      ap_uint<BITSPROPSIGMACOORD_A> res0_coord2 = 0;
      ap_uint<BITSPROPSIGMACOORD_B> res1_coord2 = 0;
      ap_uint<BITSPROPSIGMAETA_A> res0_eta1 = 0;
      ap_uint<BITSPROPSIGMAETA_B> res1_eta = 0;
      ap_uint<BITSPROPSIGMAETA_A> res0_eta2 = 0;
      ap_uint<1> is_barrel = 0;

      uint reducedAbsEta = track.abseta() / 8;

      if (layer == 0) {
        prop_coord1 = lt_prop_coord1_0[reducedAbsEta];
        prop_coord2 = lt_prop_coord2_0[reducedAbsEta];
        res0_coord1 = lt_res0_coord1_0[reducedAbsEta];
        res1_coord1 = lt_res1_coord1_0[reducedAbsEta];
        res0_coord2 = lt_res0_coord2_0[reducedAbsEta];
        res1_coord2 = lt_res1_coord2_0[reducedAbsEta];
        res0_eta1 = lt_res0_eta1_0[reducedAbsEta];
        res1_eta = lt_res1_eta_0[reducedAbsEta];
        res0_eta2 = lt_res0_eta2_0[reducedAbsEta];
        is_barrel = reducedAbsEta < barrelLimit0_ ? 1 : 0;
      } else if (layer == 1) {
        prop_coord1 = lt_prop_coord1_1[reducedAbsEta];
        prop_coord2 = lt_prop_coord2_1[reducedAbsEta];
        res0_coord1 = lt_res0_coord1_1[reducedAbsEta];
        res1_coord1 = lt_res1_coord1_1[reducedAbsEta];
        res0_coord2 = lt_res0_coord2_1[reducedAbsEta];
        res1_coord2 = lt_res1_coord2_1[reducedAbsEta];
        res0_eta1 = lt_res0_eta1_1[reducedAbsEta];
        res1_eta = lt_res1_eta_1[reducedAbsEta];
        res0_eta2 = lt_res0_eta2_1[reducedAbsEta];
        is_barrel = reducedAbsEta < barrelLimit1_ ? 1 : 0;

      } else if (layer == 2) {
        prop_coord1 = lt_prop_coord1_2[reducedAbsEta];
        prop_coord2 = lt_prop_coord2_2[reducedAbsEta];
        res0_coord1 = lt_res0_coord1_2[reducedAbsEta];
        res1_coord1 = lt_res1_coord1_2[reducedAbsEta];
        res0_coord2 = lt_res0_coord2_2[reducedAbsEta];
        res1_coord2 = lt_res1_coord2_2[reducedAbsEta];
        res0_eta1 = lt_res0_eta1_2[reducedAbsEta];
        res1_eta = lt_res1_eta_2[reducedAbsEta];
        res0_eta2 = lt_res0_eta2_2[reducedAbsEta];
        is_barrel = reducedAbsEta < barrelLimit2_ ? 1 : 0;

      } else if (layer == 3) {
        prop_coord1 = lt_prop_coord1_3[reducedAbsEta];
        prop_coord2 = lt_prop_coord2_3[reducedAbsEta];
        res0_coord1 = lt_res0_coord1_3[reducedAbsEta];
        res1_coord1 = lt_res1_coord1_3[reducedAbsEta];
        res0_coord2 = lt_res0_coord2_3[reducedAbsEta];
        res1_coord2 = lt_res1_coord2_3[reducedAbsEta];
        res0_eta1 = lt_res0_eta1_3[reducedAbsEta];
        res1_eta = lt_res1_eta_3[reducedAbsEta];
        res0_eta2 = lt_res0_eta2_3[reducedAbsEta];
        is_barrel = reducedAbsEta < barrelLimit3_ ? 1 : 0;

      } else if (layer == 4) {
        prop_coord1 = lt_prop_coord1_4[reducedAbsEta];
        prop_coord2 = lt_prop_coord2_4[reducedAbsEta];
        res0_coord1 = lt_res0_coord1_4[reducedAbsEta];
        res1_coord1 = lt_res1_coord1_4[reducedAbsEta];
        res0_coord2 = lt_res0_coord2_4[reducedAbsEta];
        res1_coord2 = lt_res1_coord2_4[reducedAbsEta];
        res0_eta1 = lt_res0_eta1_4[reducedAbsEta];
        res1_eta = lt_res1_eta_4[reducedAbsEta];
        res0_eta2 = lt_res0_eta2_4[reducedAbsEta];
        is_barrel = 0;
      }

      propagation_t out;
      ap_int<BITSTTCURV> curvature = track.curvature();
      ap_int<BITSPHI> phi = track.phi();
      ap_int<BITSPROPCOORD + BITSTTCURV> c1kFull = prop_coord1 * curvature;
      ap_int<BITSPROPCOORD + BITSTTCURV - 10> c1k = (c1kFull) / 1024;
      ap_int<BITSPHI> coord1 = phi - c1k;

      out.coord1 = coord1 / PHIDIVIDER;

      ap_int<BITSPROPCOORD + BITSTTCURV> c2kFull = prop_coord2 * curvature;

      ap_int<BITSPROPCOORD + BITSTTCURV - 10> c2k = (c2kFull) / 1024;
      if (is_barrel)
        out.coord2 = -c2k / PHIDIVIDER;
      else
        out.coord2 = (phi - c2k) / PHIDIVIDER;

      ap_int<BITSETA> eta = track.eta();
      out.eta = eta / ETADIVIDER;

      ap_uint<2 * BITSTTCURV - 2> curvature2All = curvature * curvature;
      ap_uint<BITSTTCURV2> curvature2 = curvature2All / 2;

      //Remember to change emulator with new k2
      ap_uint<BITSPROPSIGMACOORD_B + BITSTTCURV2> rescoord1k = (res1_coord1 * curvature2) >> 23;
      ap_ufixed<BITSSIGMACOORD, BITSSIGMACOORD, AP_TRN_ZERO, AP_SAT_SYM> sigma_coord1 = res0_coord1 + rescoord1k;
      out.sigma_coord1 = ap_uint<BITSSIGMACOORD>(sigma_coord1);

      ap_uint<BITSPROPSIGMACOORD_B + BITSTTCURV2> rescoord2k = (res1_coord2 * curvature2) >> 23;
      ap_ufixed<BITSSIGMACOORD, BITSSIGMACOORD, AP_TRN_ZERO, AP_SAT_SYM> sigma_coord2 = res0_coord2 + rescoord2k;
      out.sigma_coord2 = ap_uint<BITSSIGMACOORD>(sigma_coord2);

      ap_uint<BITSPROPSIGMAETA_B + BITSTTCURV2> resetak = (res1_eta * curvature2) >> 23;
      ap_ufixed<BITSSIGMAETA, BITSSIGMAETA, AP_TRN_ZERO, AP_SAT_SYM> sigma_eta1 = res0_eta1 + resetak;
      out.sigma_eta1 = ap_uint<BITSSIGMAETA>(sigma_eta1);
      ap_ufixed<BITSSIGMAETA, BITSSIGMAETA, AP_TRN_ZERO, AP_SAT_SYM> sigma_eta2 = res0_eta2 + resetak;
      out.sigma_eta2 = ap_uint<BITSSIGMAETA>(sigma_eta2);
      out.valid = 1;
      out.is_barrel = is_barrel;

      if (verbose_ == 1)

        printf("Propagating to layer %d:is barrel=%d  coords=%d+-%d , %d +-%d etas = %d +- %d +-%d\n",
               int(layer),
               out.is_barrel.to_int(),
               out.coord1.to_int(),
               out.sigma_coord1.to_int(),
               out.coord2.to_int(),
               out.sigma_coord2.to_int(),
               out.eta.to_int(),
               out.sigma_eta1.to_int(),
               out.sigma_eta2.to_int());

      return out;
    }

propagateAndMatch()

match_t Phase2L1GMT::TrackMuonMatchAlgorithm::propagateAndMatch ( const ConvertedTTTrack &  track, const l1t::MuonStubRef &  stub  )

inlineprivate

Definition at line 414 of file TrackMuonMatchAlgorithm.h.

References match(), propagate(), and HLT_2022v11_cff::track.

Referenced by processTrack().

                                                                                         {
      propagation_t prop = propagate(track, stub->tfLayer());
      return match(prop, stub);
    }

sort()

std::vector<l1t::TrackerMuon> Phase2L1GMT::TrackMuonMatchAlgorithm::sort ( std::vector< l1t::TrackerMuon > &  muons, uint  maximum  )

inline

Definition at line 144 of file TrackMuonMatchAlgorithm.h.

References a, b, mps_fire::i, PDWG_BPHSkim_cff::muons, MillePedeFileConverter_cfg::out, and jetUpdater_cfi::sort.

                                                                                   {
      if (muons.size() < 2)
        return muons;

      std::sort(muons.begin(), muons.end(), [](l1t::TrackerMuon a, l1t::TrackerMuon b) { return a.hwPt() > b.hwPt(); });
      std::vector<l1t::TrackerMuon> out;
      for (unsigned int i = 0; i < muons.size(); ++i) {
        out.push_back(muons[i]);
        if (i == (maximum - 1))
          break;
      }

      return out;
    }

Member Data Documentation

verbose_

int Phase2L1GMT::TrackMuonMatchAlgorithm::verbose_

private

Definition at line 160 of file TrackMuonMatchAlgorithm.h.

Referenced by clean(), cleanNeighbor(), convert(), match(), processTrack(), and propagate().