#include <L1MuGMTMerger.h>

Public Member Functions
const std::vector< L1MuGMTExtendedCand * > &	Cands () const
	return std::vector with all muon candidates More...

int	id () const
	return identifier More...

	L1MuGMTMerger (const L1MuGlobalMuonTrigger &gmt, int id)
	constructor More...

void	print () const
	print results after selection More...

void	reset ()
	clear Merger More...

void	run ()
	run GMT Merger More...

virtual	~L1MuGMTMerger ()
	destructor More...

Private Member Functions
unsigned	convertedEta (const L1MuRegionalCand *mu) const

void	createDTCSCCand (int idx_dtcsc)

void	createMergedCand (int idx_dtcsc, int idx_rpc)

void	createRPCCand (int idx_rpc)

int	doANDMerge (unsigned MMconfig) const

int	doSpecialMerge (unsigned MMconfig) const

void	load ()

void	merge ()

int	merge_rank (const L1MuRegionalCand *) const
	Merge Rank Table. More...

unsigned	projectedPhi (const L1MuRegionalCand *mu) const

int	selectDTCSC (unsigned MMconfig, int by_rank, int by_pt, int by_combi) const

unsigned	sysign (const L1MuRegionalCand *mu) const

Private Attributes
std::vector< const L1MuRegionalCand * >	dtcsc_mu

const L1MuGlobalMuonTrigger &	m_gmt

int	m_id

std::vector< L1MuGMTExtendedCand * >	m_MuonCands

std::vector< const L1MuRegionalCand * >	rpc_mu

std::vector< int >	singleRank

Detailed Description

L1 Global Muon Trigger Merger.

There are two GMT Mergers. One for the barrel (id=0) and one for the forward (id=1) part.

The merger receives four DT(CSC) muons and four RPC muons. Each DT(CSC) muon is either merged with an RPC one or passed through.

To simplify the C++ model, the merger conatians also the conversion units and sort rank units as well as the MergeMethodSelection unit which are separate units in the hardware.

Definition at line 58 of file L1MuGMTMerger.h.

Constructor & Destructor Documentation

◆ L1MuGMTMerger()

L1MuGMTMerger::L1MuGMTMerger	(	const L1MuGlobalMuonTrigger &	gmt,
		int	id
	)

constructor

Definition at line 70 of file L1MuGMTMerger.cc.

References dtcsc_mu, and rpc_mu.

                                                                      : m_gmt(gmt), m_id(id), dtcsc_mu(4), rpc_mu(4) {
   dtcsc_mu.reserve(4);
   rpc_mu.reserve(4);
 }

◆ ~L1MuGMTMerger()

L1MuGMTMerger::~L1MuGMTMerger ( )

virtual

destructor

Definition at line 78 of file L1MuGMTMerger.cc.

References reset().

78 { reset(); }

L1MuGMTMerger::reset

void reset()

clear Merger

Definition: L1MuGMTMerger.cc:95

Member Function Documentation

◆ Cands()

const std::vector<L1MuGMTExtendedCand*>& L1MuGMTMerger::Cands ( ) const

inline

return std::vector with all muon candidates

Definition at line 79 of file L1MuGMTMerger.h.

References m_MuonCands.

Referenced by L1MuGMTSorter::run().

79 { return m_MuonCands; }

L1MuGMTMerger::m_MuonCands

std::vector< L1MuGMTExtendedCand * > m_MuonCands

Definition: L1MuGMTMerger.h:107

◆ convertedEta()

unsigned L1MuGMTMerger::convertedEta ( const L1MuRegionalCand * mu ) const

private

Definition at line 306 of file L1MuGMTMerger.cc.

References L1MuGMTConfig::getLFEtaConvLUT(), amptDefaultParameters_cff::mu, and L1MuGMTLFEtaConvLUT::SpecificLookup_eta_gmt().

Referenced by createDTCSCCand(), createMergedCand(), and createRPCCand().

                                                                      {
   L1MuGMTLFEtaConvLUT* etaconv_lut = L1MuGMTConfig::getLFEtaConvLUT();
   return etaconv_lut->SpecificLookup_eta_gmt(mu->type_idx(), mu->eta_packed());
 }

◆ createDTCSCCand()

void L1MuGMTMerger::createDTCSCCand ( int idx_dtcsc )

private

Definition at line 220 of file L1MuGMTMerger.cc.

References nano_mu_digi_cff::bx, convertedEta(), dtcsc_mu, L1MuGMTSortRankUnit::getVeryLowQualityLevel(), L1MuGMTMipIsoAU::ISO(), m_gmt, m_id, m_MuonCands, L1MuGMTMipIsoAU::MIP(), L1MuGlobalMuonTrigger::MipIsoAU(), projectedPhi(), quality, L1MuGMTCand::setBx(), L1MuGMTCand::setChargePacked(), L1MuGMTExtendedCand::setDTCSCIndex(), L1MuGMTCand::setEtaPacked(), L1MuGMTExtendedCand::setFwdBit(), L1MuGMTCand::setIsolation(), L1MuGMTCand::setMIP(), L1MuGMTCand::setPhiPacked(), L1MuGMTCand::setPtPacked(), L1MuGMTCand::setQuality(), L1MuGMTExtendedCand::setRank(), L1MuGMTExtendedCand::setRPCBit(), L1MuGMTExtendedCand::setRPCIndex(), L1MuGMTSortRankUnit::sort_rank(), and sysign().

Referenced by merge().

                                                  {
   L1MuGMTExtendedCand* tmpmuon = new L1MuGMTExtendedCand();
 
   tmpmuon->setBx(dtcsc_mu[idx_dtcsc]->bx());
   tmpmuon->setPhiPacked(projectedPhi(dtcsc_mu[idx_dtcsc]));
   tmpmuon->setEtaPacked(convertedEta(dtcsc_mu[idx_dtcsc]));
   tmpmuon->setPtPacked(dtcsc_mu[idx_dtcsc]->pt_packed());
   tmpmuon->setChargePacked(sysign(dtcsc_mu[idx_dtcsc]));
   tmpmuon->setMIP(m_gmt.MipIsoAU(m_id)->MIP(idx_dtcsc));
   tmpmuon->setIsolation(m_gmt.MipIsoAU(m_id)->ISO(idx_dtcsc));
   tmpmuon->setRank(L1MuGMTSortRankUnit::sort_rank(dtcsc_mu[idx_dtcsc]));
 
   unsigned quality = 0;
   switch (L1MuGMTSortRankUnit::getVeryLowQualityLevel(dtcsc_mu[idx_dtcsc])) {
     case 0:
       quality = 6;
       break;  //DT/CSC
     case 1:
       quality = 2;
       break;  //VERY LOW QUALITY LEVEL 1
     case 2:
       quality = 3;
       break;  //VERY LOW QUALITY LEVEL 2
     case 3:
       quality = 4;
       break;  //VERY LOW QUALITY LEVEL 3
   }
 
   if ((m_id == 1) && (dtcsc_mu[idx_dtcsc]->finehalo_packed() == 1))
     quality = 1;  // HALO quality
 
   tmpmuon->setQuality(quality);  // RPC
   tmpmuon->setDTCSCIndex(idx_dtcsc);
   tmpmuon->setRPCIndex(0);
   tmpmuon->setFwdBit(m_id);
   tmpmuon->setRPCBit(0);
 
   m_MuonCands.push_back(tmpmuon);
 }

◆ createMergedCand()

void L1MuGMTMerger::createMergedCand	(	int	idx_dtcsc,
		int	idx_rpc
	)

private

Definition at line 343 of file L1MuGMTMerger.cc.

Referenced by merge().

                                                                {
   // In the hardware matrices of select_bits are calculated for all
   // possible pairings.
   // In ORCA we only calculate selec-bits for the actual
   // pairs to save time.
 
   // look up merge ranks
   int merge_rank_dtcsc = merge_rank(dtcsc_mu[idx_dtcsc]);
   int merge_rank_rpc = merge_rank(rpc_mu[idx_rpc]);
 
   // calculate select-bits (1: take DT/CSC, 0: take RPC)
   // fix: if equal prefer DT/CSC as in HW!
   //  int selected_by_rank = abs(merge_rank_dtcsc) > abs(merge_rank_rpc);
   int selected_by_rank = abs(merge_rank_dtcsc) >= abs(merge_rank_rpc);
   int selected_by_pt = dtcsc_mu[idx_dtcsc]->pt_packed() <= rpc_mu[idx_rpc]->pt_packed();
 
   // Selection by combination of min pt and higher rank
   // select by rank if both flags are set, otherwise by min pt
   // in other words: select by minpt if one flag is not set
   int selected_by_combi = (merge_rank_dtcsc < 0 && merge_rank_rpc < 0) ? selected_by_rank : selected_by_pt;
 
   L1MuGMTExtendedCand* tmpmuon = new L1MuGMTExtendedCand();
 
   tmpmuon->setBx(dtcsc_mu[idx_dtcsc]->bx());
 
   // merge phi
   //  unsigned MMConfig_phi = 32; // take DT
   unsigned MMConfig_phi = L1MuGMTConfig::getRegMMConfigPhi()->getValue(m_id);
 
   unsigned phi = 0;
 
   if (selectDTCSC(MMConfig_phi, selected_by_rank, selected_by_pt, selected_by_combi))
     phi = projectedPhi(dtcsc_mu[idx_dtcsc]);
   else
     phi = projectedPhi(rpc_mu[idx_rpc]);
 
   tmpmuon->setPhiPacked(phi);
 
   // merge eta
   unsigned MMConfig_eta = L1MuGMTConfig::getRegMMConfigEta()->getValue(m_id);
 
   unsigned eta = 0;
 
   if (doSpecialMerge(MMConfig_eta)) {
     if ((m_id == 1) || dtcsc_mu[idx_dtcsc]->finehalo_packed())
       eta = convertedEta(dtcsc_mu[idx_dtcsc]);
     else
       eta = convertedEta(rpc_mu[idx_rpc]);
   } else {
     if (selectDTCSC(MMConfig_eta, selected_by_rank, selected_by_pt, selected_by_combi))
       eta = convertedEta(dtcsc_mu[idx_dtcsc]);
     else
       eta = convertedEta(rpc_mu[idx_rpc]);
   }
   tmpmuon->setEtaPacked(eta);
 
   // merge pt
   unsigned MMConfig_pt = L1MuGMTConfig::getRegMMConfigPt()->getValue(m_id);
 
   unsigned pt = 0;
 
   if (doSpecialMerge(MMConfig_pt)) {  // mix pt
     L1MuGMTLFPtMixLUT* ptmix_lut = L1MuGMTConfig::getLFPtMixLUT();
     pt = ptmix_lut->SpecificLookup_pt_mixed(m_id, dtcsc_mu[idx_dtcsc]->pt_packed(), rpc_mu[idx_rpc]->pt_packed());
   } else {
     if (selectDTCSC(MMConfig_pt, selected_by_rank, selected_by_pt, selected_by_combi))
       pt = dtcsc_mu[idx_dtcsc]->pt_packed();
     else
       pt = rpc_mu[idx_rpc]->pt_packed();
   }
   tmpmuon->setPtPacked(pt);
 
   // merge charge
   unsigned MMConfig_charge = L1MuGMTConfig::getRegMMConfigCharge()->getValue(m_id);
 
   unsigned sy_sign = 0;
 
   if (doSpecialMerge(MMConfig_charge)) {
     // based on charge valid bits
     if (rpc_mu[idx_rpc]->charge_valid_packed() == 1 && dtcsc_mu[idx_dtcsc]->charge_valid_packed() == 0)
       sy_sign = sysign(rpc_mu[idx_rpc]);
     else
       sy_sign = sysign(dtcsc_mu[idx_dtcsc]);
   } else {
     if (selectDTCSC(MMConfig_charge, selected_by_rank, selected_by_pt, selected_by_combi))
       sy_sign = sysign(dtcsc_mu[idx_dtcsc]);
     else
       sy_sign = sysign(rpc_mu[idx_rpc]);
   }
   tmpmuon->setChargePacked(sy_sign);
 
   // merge quality
 
   // merge MIP
   unsigned MMConfig_MIP = L1MuGMTConfig::getRegMMConfigMIP()->getValue(m_id);
 
   bool mip_bit = false;
 
   bool mip_bit_dtcsc = m_gmt.MipIsoAU(m_id)->MIP(idx_dtcsc);
   bool mip_bit_rpc = m_gmt.MipIsoAU(m_id)->MIP(idx_rpc + 4);
 
   if (doSpecialMerge(MMConfig_MIP)) {
     if (doANDMerge(MMConfig_MIP))
       mip_bit = mip_bit_dtcsc && mip_bit_rpc;
     else
       mip_bit = mip_bit_dtcsc || mip_bit_rpc;
   } else {
     if (selectDTCSC(MMConfig_MIP, selected_by_rank, selected_by_pt, selected_by_combi))
       mip_bit = mip_bit_dtcsc;
     else
       mip_bit = mip_bit_rpc;
   }
 
   tmpmuon->setMIP(mip_bit);
 
   // merge ISO
   unsigned MMConfig_ISO = L1MuGMTConfig::getRegMMConfigISO()->getValue(m_id);
 
   bool iso_bit = false;
 
   bool iso_bit_dtcsc = m_gmt.MipIsoAU(m_id)->ISO(idx_dtcsc);
   bool iso_bit_rpc = m_gmt.MipIsoAU(m_id)->ISO(idx_rpc + 4);
 
   if (doSpecialMerge(MMConfig_ISO)) {
     if (doANDMerge(MMConfig_ISO))
       iso_bit = iso_bit_dtcsc && iso_bit_rpc;
     else
       iso_bit = iso_bit_dtcsc || iso_bit_rpc;
   } else {
     if (selectDTCSC(MMConfig_ISO, selected_by_rank, selected_by_pt, selected_by_combi))
       iso_bit = iso_bit_dtcsc;
     else
       iso_bit = iso_bit_rpc;
   }
 
   tmpmuon->setIsolation(iso_bit);
 
   // merge sort rank
   unsigned MMConfig_SRK = L1MuGMTConfig::getRegMMConfigSRK()->getValue(m_id);
 
   unsigned rank_offset = L1MuGMTConfig::getRegSortRankOffset()->getValue(m_id);
 
   unsigned rank = 0;
   if (selectDTCSC(MMConfig_SRK, selected_by_rank, selected_by_pt, selected_by_combi))
     rank = L1MuGMTSortRankUnit::sort_rank(dtcsc_mu[idx_dtcsc]) + rank_offset;
   else
     rank = L1MuGMTSortRankUnit::sort_rank(rpc_mu[idx_rpc]) + rank_offset;
 
   tmpmuon->setRank(rank);
 
   // quality of merged candidate
   tmpmuon->setQuality(7);  // code for matched muons
 
   tmpmuon->setDTCSCIndex(idx_dtcsc);
   tmpmuon->setRPCIndex(idx_rpc);
   tmpmuon->setFwdBit(m_id);
   tmpmuon->setRPCBit(0);
 
   m_MuonCands.push_back(tmpmuon);
 }

◆ createRPCCand()

void L1MuGMTMerger::createRPCCand ( int idx_rpc )

private

Definition at line 260 of file L1MuGMTMerger.cc.

References nano_mu_digi_cff::bx, convertedEta(), L1MuGMTSortRankUnit::getVeryLowQualityLevel(), L1MuGMTMipIsoAU::ISO(), m_gmt, m_id, m_MuonCands, L1MuGMTMipIsoAU::MIP(), L1MuGlobalMuonTrigger::MipIsoAU(), projectedPhi(), quality, rpc_mu, L1MuGMTCand::setBx(), L1MuGMTCand::setChargePacked(), L1MuGMTExtendedCand::setDTCSCIndex(), L1MuGMTCand::setEtaPacked(), L1MuGMTExtendedCand::setFwdBit(), L1MuGMTCand::setIsolation(), L1MuGMTCand::setMIP(), L1MuGMTCand::setPhiPacked(), L1MuGMTCand::setPtPacked(), L1MuGMTCand::setQuality(), L1MuGMTExtendedCand::setRank(), L1MuGMTExtendedCand::setRPCBit(), L1MuGMTExtendedCand::setRPCIndex(), L1MuGMTSortRankUnit::sort_rank(), and sysign().

Referenced by merge().

                                              {
   L1MuGMTExtendedCand* tmpmuon = new L1MuGMTExtendedCand();
 
   tmpmuon->setBx(rpc_mu[idx_rpc]->bx());
   tmpmuon->setPhiPacked(projectedPhi(rpc_mu[idx_rpc]));
   tmpmuon->setEtaPacked(convertedEta(rpc_mu[idx_rpc]));
   tmpmuon->setPtPacked(rpc_mu[idx_rpc]->pt_packed());
   tmpmuon->setChargePacked(sysign(rpc_mu[idx_rpc]));
   tmpmuon->setMIP(m_gmt.MipIsoAU(m_id)->MIP(idx_rpc + 4));
   tmpmuon->setIsolation(m_gmt.MipIsoAU(m_id)->ISO(idx_rpc + 4));
   tmpmuon->setRank(L1MuGMTSortRankUnit::sort_rank(rpc_mu[idx_rpc]));
 
   unsigned quality = 0;
   switch (L1MuGMTSortRankUnit::getVeryLowQualityLevel(rpc_mu[idx_rpc])) {
     case 0:
       quality = 5;
       break;  //RPC
     case 1:
       quality = 2;
       break;  //VERY LOW QUALITY LEVEL1
     case 2:
       quality = 3;
       break;  //VERY LOW QUALITY LEVEL2
     case 3:
       quality = 4;
       break;  //VERY LOW QUALITY LEVEL3
   }
 
   tmpmuon->setQuality(quality);  // RPC
   tmpmuon->setDTCSCIndex(0);
   tmpmuon->setRPCIndex(idx_rpc);
   tmpmuon->setFwdBit(m_id);
   tmpmuon->setRPCBit(1);
 
   m_MuonCands.push_back(tmpmuon);
 }

◆ doANDMerge()

int L1MuGMTMerger::doANDMerge ( unsigned MMconfig ) const

private

Definition at line 304 of file L1MuGMTMerger.cc.

Referenced by createMergedCand().

304 { return (MMconfig & 64) == 64; }

◆ doSpecialMerge()

int L1MuGMTMerger::doSpecialMerge ( unsigned MMconfig ) const

private

Definition at line 302 of file L1MuGMTMerger.cc.

Referenced by createMergedCand().

302 { return (MMconfig & 1) == 1; }

◆ id()

int L1MuGMTMerger::id ( void ) const

inline

return identifier

Definition at line 76 of file L1MuGMTMerger.h.

References m_id.

76 { return m_id; }

L1MuGMTMerger::m_id

int m_id

Definition: L1MuGMTMerger.h:102

◆ load()

void L1MuGMTMerger::load ( )

private

Definition at line 129 of file L1MuGMTMerger.cc.

References L1MuGMTPSB::CSCMuon(), L1MuGlobalMuonTrigger::Data(), L1MuGMTPSB::DTBXMuon(), dtcsc_mu, m_gmt, m_id, L1MuGMTConfig::MAXCSC, L1MuGMTConfig::MAXDTBX, L1MuGMTConfig::MAXRPCbarrel, L1MuGMTConfig::MAXRPCendcap, rpc_mu, and L1MuGMTPSB::RPCMuon().

Referenced by run().

                          {
   // barrel Merger gets DTBX and barrel RPC muons
   if (m_id == 0) {
     for (unsigned idt = 0; idt < L1MuGMTConfig::MAXDTBX; idt++) {
       dtcsc_mu[idt] = m_gmt.Data()->DTBXMuon(idt);
     }
     for (unsigned irpc = 0; irpc < L1MuGMTConfig::MAXRPCbarrel; irpc++) {
       rpc_mu[irpc] = m_gmt.Data()->RPCMuon(irpc);
     }
   }
 
   // endcap Merger gets CSC and endcap RPC muons
   if (m_id == 1) {
     for (unsigned icsc = 0; icsc < L1MuGMTConfig::MAXCSC; icsc++) {
       dtcsc_mu[icsc] = m_gmt.Data()->CSCMuon(icsc);
     }
     for (unsigned irpc = 0; irpc < L1MuGMTConfig::MAXRPCendcap; irpc++) {
       rpc_mu[irpc] = m_gmt.Data()->RPCMuon(irpc + 4);
     }
   }
 }

◆ merge()

void L1MuGMTMerger::merge ( )

private

Definition at line 151 of file L1MuGMTMerger.cc.

References L1MuGMTCancelOutUnit::cancelMyChipMuon(), L1MuGMTCancelOutUnit::cancelOtherChipMuon(), L1MuGlobalMuonTrigger::CancelOutUnit(), L1MuGMTMatrix< T >::colAny(), createDTCSCCand(), createMergedCand(), createRPCCand(), dtcsc_mu, L1MuScale::getCenter(), L1MuTriggerScales::getGMTEtaScale(), L1MuScale::getLowEdge(), L1MuTriggerScales::getPhiScale(), L1MuTriggerPtScale::getPtScale(), L1MuGMTConfig::getTriggerPtScale(), L1MuGMTConfig::getTriggerScales(), mps_fire::i, L1MuGMTSortRankUnit::isDisabled(), dqmiolumiharvest::j, m_gmt, m_id, m_MuonCands, L1MuGlobalMuonTrigger::Matcher(), L1MuGMTMatcher::pairM(), L1MuGMTMatrix< T >::rowAny(), and rpc_mu.

Referenced by run().

                           {
   const L1MuGMTMatrix<bool>& pairM = m_gmt.Matcher(m_id)->pairM();
 
   // Handling of cancel-out and empty muons is different in software and hardware
   //
   // - in hardware, a candidate may be empty (pt_code == 0) and an empty bit
   //   is passed to the sorter in order to suppress the candidate. In the
   //   software no candidate is created in this case.
   //
   // - in hardware, RPC candidates are passed to the sorter even if they are
   //   also used in a matched pair. They are then suppressed in the sorter. In
   //   software no RPC candidate is created if the muon is used in a pair.
   //
   // - in hardware, cancel-out signals from the cancel-out units in the own and
   //   other Logic FPGA are passed to the sorter in order to cancel out muons.
   //   In software the cancel-out signals are alrady checked here in the merger
   //   and no candidates are created for cancelled muons.
   //
   // There may therefore be less muons passed to the sorter in software than
   // in Hardware. At the output of the first sorter stage the results should
   // be comparable, again.
 
   unsigned HaloOverwritesMatched = 1;
 
   // loop over DT/CSC muons
   for (int i = 0; i < 4; i++) {
     if (dtcsc_mu[i] != nullptr) {
       int match_idx = pairM.rowAny(i);
 
       int csc_is_halo = (m_id == 1) && (dtcsc_mu[i]->finehalo_packed() == 1);
 
       if ((match_idx != -1) &&  // is it matched?
           (!(csc_is_halo && HaloOverwritesMatched)))
         createMergedCand(i, match_idx);
       else {
         // check my first and the other chip's second cancel-out units
         if ((!m_gmt.CancelOutUnit(m_id)->cancelMyChipMuon(i)) &&
             (!m_gmt.CancelOutUnit(3 - m_id)->cancelOtherChipMuon(i)) && (!L1MuGMTSortRankUnit::isDisabled(dtcsc_mu[i])))
           createDTCSCCand(i);
       }
     }
   }
 
   // additionally loop over RPC muons
   for (int j = 0; j < 4; j++) {
     if (rpc_mu[j] != nullptr) {
       int match_idx = pairM.colAny(j);
 
       if (match_idx == -1) {  // is it unmatched?
         if ((!m_gmt.CancelOutUnit(m_id + 2)->cancelMyChipMuon(j)) && (!L1MuGMTSortRankUnit::isDisabled(rpc_mu[j])))
           createRPCCand(j);
       }
     }
   }
 
   // set physical values in the GMT candidates for use in the analysis
   const L1MuTriggerScales* theTriggerScales = L1MuGMTConfig::getTriggerScales();
   const L1MuTriggerPtScale* theTriggerPtScale = L1MuGMTConfig::getTriggerPtScale();
 
   std::vector<L1MuGMTExtendedCand*>::const_iterator icand;
   for (icand = m_MuonCands.begin(); icand != m_MuonCands.end(); icand++) {
     L1MuGMTExtendedCand* cand = (*icand);
     cand->setPhiValue(theTriggerScales->getPhiScale()->getLowEdge(cand->phiIndex()));
     cand->setEtaValue(theTriggerScales->getGMTEtaScale()->getCenter(cand->etaIndex()));
     cand->setPtValue(theTriggerPtScale->getPtScale()->getLowEdge(cand->ptIndex()));
     // cand->setPtValue( theTriggerScales->getPtScale()->getLowEdge( cand->ptIndex() ));
   }
 }

◆ merge_rank()

int L1MuGMTMerger::merge_rank ( const L1MuRegionalCand * muon ) const

private

Merge Rank Table.

Definition at line 506 of file L1MuGMTMerger.cc.

References PVValHelper::eta, RemoveAddSevLevel::flag, L1MuGMTConfig::getLFMergeRankCombineLUT(), L1MuGMTConfig::getLFMergeRankEtaPhiLUT(), L1MuGMTConfig::getLFMergeRankEtaQLUT(), L1MuGMTConfig::getLFMergeRankPtQLUT(), phi, DiDispStaMuonMonitor_cfi::pt, submitPVResolutionJobs::q, L1MuGMTLFMergeRankEtaQLUT::SpecificLookup_flag(), L1MuGMTLFMergeRankCombineLUT::SpecificLookup_merge_rank(), L1MuGMTLFMergeRankEtaPhiLUT::SpecificLookup_rank_etaphi(), L1MuGMTLFMergeRankEtaQLUT::SpecificLookup_rank_etaq(), and L1MuGMTLFMergeRankPtQLUT::SpecificLookup_rank_ptq().

Referenced by createMergedCand().

                                                                 {
   if (muon == nullptr || muon->empty())
     return 0;
 
   unsigned lut_idx = muon->type_idx();
 
   // obtain inputs as coded in HW
   unsigned eta = muon->eta_packed();
   unsigned q = muon->quality_packed();
   unsigned pt = muon->pt_packed();
   unsigned phi = muon->phi_packed();
 
   // lookup eta-q
   L1MuGMTLFMergeRankEtaQLUT* etaq_lut = L1MuGMTConfig::getLFMergeRankEtaQLUT();
   unsigned rank_etaq = etaq_lut->SpecificLookup_rank_etaq(lut_idx, eta, q);
   unsigned flag = etaq_lut->SpecificLookup_flag(lut_idx, eta, q);
 
   // lookup pt-q
   L1MuGMTLFMergeRankPtQLUT* ptq_lut = L1MuGMTConfig::getLFMergeRankPtQLUT();
   unsigned rank_ptq = ptq_lut->SpecificLookup_rank_ptq(lut_idx, q, pt);
 
   // lookup etaphi
   L1MuGMTLFMergeRankEtaPhiLUT* etaphi_lut = L1MuGMTConfig::getLFMergeRankEtaPhiLUT();
   unsigned rank_etaphi = etaphi_lut->SpecificLookup_rank_etaphi(lut_idx, eta, phi);
 
   // combine
   L1MuGMTLFMergeRankCombineLUT* combine_lut = L1MuGMTConfig::getLFMergeRankCombineLUT();
   unsigned rank = combine_lut->SpecificLookup_merge_rank(lut_idx, rank_etaq, rank_ptq, rank_etaphi);
 
   int rank_signed = rank;
 
   if (flag == 1)
     rank_signed *= -1;
 
   return rank_signed;
 }

◆ print()

void L1MuGMTMerger::print ( void ) const

print results after selection

Definition at line 114 of file L1MuGMTMerger.cc.

References m_MuonCands.

Referenced by L1MuGlobalMuonTrigger::produce().

                                 {
   edm::LogVerbatim("GMT_Merger_info") << " ";
 
   std::vector<L1MuGMTExtendedCand*>::const_iterator iter;
   for (iter = m_MuonCands.begin(); iter != m_MuonCands.end(); iter++) {
     if (*iter && !(*iter)->empty())
       (*iter)->print();
   }
 
   edm::LogVerbatim("GMT_Merger_info") << " ";
 }

◆ projectedPhi()

unsigned L1MuGMTMerger::projectedPhi ( const L1MuRegionalCand * mu ) const

private

Definition at line 311 of file L1MuGMTMerger.cc.

References HLT_2023v12_cff::eta4, L1MuGMTConfig::getLFPhiProEtaConvLUT(), L1MuGMTConfig::getLFPhiProLUT(), L1MuSignedPacking< Bits >::idxFromPacked(), amptDefaultParameters_cff::mu, L1MuGMTLFPhiProLUT::SpecificLookup_dphi(), and L1MuGMTLFPhiProEtaConvLUT::SpecificLookup_eta_out().

Referenced by createDTCSCCand(), createMergedCand(), and createRPCCand().

                                                                      {
   // convert eta
   L1MuGMTLFPhiProEtaConvLUT* phiproetaconv_lut = L1MuGMTConfig::getLFPhiProEtaConvLUT();
   unsigned eta4 = phiproetaconv_lut->SpecificLookup_eta_out(mu->type_idx(), mu->eta_packed());
 
   // look up delta-phi 9 bit signed
   L1MuGMTLFPhiProLUT* phipro_lut = L1MuGMTConfig::getLFPhiProLUT();
   unsigned dphi9 = phipro_lut->SpecificLookup_dphi(mu->type_idx(), eta4, mu->pt_packed(), mu->charge_packed());
 
   // sign extend
   L1MuSignedPacking<9> DPhiPacking;
   int dphi = DPhiPacking.idxFromPacked(dphi9);
 
   // add modulo 144
   int newphi = mu->phi_packed() + dphi;
   if (newphi < 0)
     newphi += 144;
   if (newphi >= 144)
     newphi -= 144;
 
   return (unsigned)newphi;
 }

◆ reset()

void L1MuGMTMerger::reset ( void )

clear Merger

Definition at line 95 of file L1MuGMTMerger.cc.

References dtcsc_mu, mps_fire::i, m_MuonCands, and rpc_mu.

Referenced by L1MuGlobalMuonTrigger::reset(), and ~L1MuGMTMerger().

                           {
   for (int i = 0; i < 4; i++) {
     dtcsc_mu[i] = nullptr;
     rpc_mu[i] = nullptr;
   }
 
   std::vector<L1MuGMTExtendedCand*>::iterator iter;
   for (iter = m_MuonCands.begin(); iter != m_MuonCands.end(); iter++) {
     if (*iter)
       delete (*iter);
     *iter = nullptr;
   }
 
   m_MuonCands.clear();
 }

◆ run()

void L1MuGMTMerger::run ( )

run GMT Merger

Definition at line 87 of file L1MuGMTMerger.cc.

References load(), and merge().

Referenced by L1MuGlobalMuonTrigger::produce().

                         {
   load();
   merge();
 }

◆ selectDTCSC()

int L1MuGMTMerger::selectDTCSC	(	unsigned	MMconfig,
		int	by_rank,
		int	by_pt,
		int	by_combi
	)		const

private

Definition at line 297 of file L1MuGMTMerger.cc.

Referenced by createMergedCand().

                                                                                             {
   return ((MMconfig & 32) == 32) || (((MMconfig & 8) == 8) && by_rank) || (((MMconfig & 4) == 4) && by_pt) ||
          (((MMconfig & 2) == 2) && by_combi);
 }

◆ sysign()

unsigned L1MuGMTMerger::sysign ( const L1MuRegionalCand * mu ) const

private

Definition at line 334 of file L1MuGMTMerger.cc.

References amptDefaultParameters_cff::mu.

Referenced by createDTCSCCand(), createMergedCand(), and createRPCCand().

                                                                {
   unsigned sysign = mu->charge_packed();
 
   if (mu->charge_valid_packed() == 0)
     sysign = 2;  // undefined charge
 
   return sysign;
 }

Member Data Documentation

◆ dtcsc_mu

std::vector<const L1MuRegionalCand*> L1MuGMTMerger::dtcsc_mu

private

Definition at line 104 of file L1MuGMTMerger.h.

Referenced by createDTCSCCand(), createMergedCand(), L1MuGMTMerger(), load(), merge(), and reset().

◆ m_gmt

const L1MuGlobalMuonTrigger& L1MuGMTMerger::m_gmt

private

Definition at line 101 of file L1MuGMTMerger.h.

Referenced by createDTCSCCand(), createMergedCand(), createRPCCand(), load(), and merge().

◆ m_id

int L1MuGMTMerger::m_id

private

Definition at line 102 of file L1MuGMTMerger.h.

Referenced by createDTCSCCand(), createMergedCand(), createRPCCand(), id(), load(), and merge().

◆ m_MuonCands

std::vector<L1MuGMTExtendedCand*> L1MuGMTMerger::m_MuonCands

private

Definition at line 107 of file L1MuGMTMerger.h.

Referenced by Cands(), createDTCSCCand(), createMergedCand(), createRPCCand(), merge(), print(), and reset().

◆ rpc_mu

std::vector<const L1MuRegionalCand*> L1MuGMTMerger::rpc_mu

private

Definition at line 105 of file L1MuGMTMerger.h.

Referenced by createMergedCand(), createRPCCand(), L1MuGMTMerger(), load(), merge(), and reset().

◆ singleRank

std::vector<int> L1MuGMTMerger::singleRank

private

Definition at line 109 of file L1MuGMTMerger.h.

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ L1MuGMTMerger()

◆ ~L1MuGMTMerger()

Member Function Documentation

◆ Cands()

◆ convertedEta()

◆ createDTCSCCand()

◆ createMergedCand()

◆ createRPCCand()

◆ doANDMerge()

◆ doSpecialMerge()

◆ id()

◆ load()

◆ merge()

◆ merge_rank()

◆ print()

◆ projectedPhi()

◆ reset()

◆ run()

◆ selectDTCSC()

◆ sysign()

Member Data Documentation

◆ dtcsc_mu

◆ m_gmt

◆ m_id

◆ m_MuonCands

◆ rpc_mu

◆ singleRank