#include <MicroGMTIsolationUnit.h>

Public Member Functions
void	calculate5by1Sums (const MicroGMTConfiguration::CaloInputCollection &, int bx)

int	calculate5by5Sum (unsigned index) const

void	extrapolateMuons (MicroGMTConfiguration::InterMuonList &) const

int	getCaloIndex (MicroGMTConfiguration::InterMuon &) const

void	initialise (L1TMuonGlobalParamsHelper *)
	Initialisation from ES record. More...

void	isolate (MicroGMTConfiguration::InterMuonList &) const

void	isolatePreSummed (MicroGMTConfiguration::InterMuonList &muons) const

	MicroGMTIsolationUnit ()

void	setTowerSums (const MicroGMTConfiguration::CaloInputCollection &inputs, int bx)

virtual	~MicroGMTIsolationUnit ()

Private Attributes
std::vector< int >	m_5by1TowerSums

std::shared_ptr< MicroGMTAbsoluteIsolationCheckLUT >	m_AbsIsoCheckMem

std::shared_ptr< MicroGMTExtrapolationLUT >	m_BEtaExtrapolation

std::shared_ptr< MicroGMTExtrapolationLUT >	m_BPhiExtrapolation

std::bitset< 28 >	m_caloInputsToDisable

std::map< tftype, std::shared_ptr< MicroGMTExtrapolationLUT > >	m_etaExtrapolationLUTs

std::shared_ptr< MicroGMTExtrapolationLUT >	m_FEtaExtrapolation

std::shared_ptr< MicroGMTExtrapolationLUT >	m_FPhiExtrapolation

int	m_fwVersion

std::shared_ptr< MicroGMTCaloIndexSelectionLUT >	m_IdxSelMemEta

std::shared_ptr< MicroGMTCaloIndexSelectionLUT >	m_IdxSelMemPhi

bool	m_initialSums

std::bitset< 28 >	m_maskedCaloInputs

std::shared_ptr< MicroGMTExtrapolationLUT >	m_OEtaExtrapolation

std::shared_ptr< MicroGMTExtrapolationLUT >	m_OPhiExtrapolation

std::map< tftype, std::shared_ptr< MicroGMTExtrapolationLUT > >	m_phiExtrapolationLUTs

std::shared_ptr< MicroGMTRelativeIsolationCheckLUT >	m_RelIsoCheckMem

std::map< int, int >	m_towerEnergies

Detailed Description

Definition at line 14 of file MicroGMTIsolationUnit.h.

Constructor & Destructor Documentation

l1t::MicroGMTIsolationUnit::MicroGMTIsolationUnit ( )

Definition at line 9 of file MicroGMTIsolationUnit.cc.

                                                  : m_fwVersion(0), m_initialSums(false)
 {
 }

l1t::MicroGMTIsolationUnit::~MicroGMTIsolationUnit ( )

virtual

Definition at line 13 of file MicroGMTIsolationUnit.cc.

14 {

15 }

Member Function Documentation

void l1t::MicroGMTIsolationUnit::calculate5by1Sums	(	const MicroGMTConfiguration::CaloInputCollection &	inputs,
		int	bx
	)

Definition at line 107 of file MicroGMTIsolationUnit.cc.

References BXVector< T >::at(), m_5by1TowerSums, m_caloInputsToDisable, m_initialSums, m_maskedCaloInputs, and BXVector< T >::size().

 {
   m_5by1TowerSums.clear();
   if (inputs.size(bx) == 0) return;
 
   for (int iphi = 0; iphi < 36; ++iphi) {
     int iphiIndexOffset = iphi*28;
     // ieta = 0 (tower -28) and ieta = 1 (tower 27)
     // 3by1 and 4by1 sums
     for (int ieta = 0; ieta < 2; ++ieta) {
       int sum = 0;
       for (int dIEta = 0-ieta; dIEta <= 2; ++dIEta) {
         if (m_caloInputsToDisable.test(ieta+dIEta) || m_maskedCaloInputs.test(ieta+dIEta)) continue; // only process if input link is enabled and not masked
         sum += inputs.at(bx, iphiIndexOffset+dIEta).etBits();
       }
       m_5by1TowerSums.push_back(sum);
     }
     // 5by1 sums
     for (int ieta = 2; ieta < 26; ++ieta) {
       int sum = 0;
       for (int dIEta = -2; dIEta <= 2; ++dIEta) {
         if (m_caloInputsToDisable.test(ieta+dIEta) || m_maskedCaloInputs.test(ieta+dIEta)) continue; // only process if input link is enabled and not masked
         sum += inputs.at(bx, iphiIndexOffset+dIEta).etBits();
       }
       m_5by1TowerSums.push_back(sum);
     }
     // ieta = 26 (tower 27) and ieta = 27 (tower 28)
     // 4by1 and 3by1 sums
     for (int ieta = 26; ieta < 28; ++ieta) {
       int sum = 0;
       for (int dIEta = -2; dIEta <= 27-ieta; ++dIEta) {
         if (m_caloInputsToDisable.test(ieta+dIEta) || m_maskedCaloInputs.test(ieta+dIEta)) continue; // only process if input link is enabled and not masked
         sum += inputs.at(bx, iphiIndexOffset+dIEta).etBits();
       }
       m_5by1TowerSums.push_back(sum);
     }
   }
 
   m_initialSums = true;
 }

int l1t::MicroGMTIsolationUnit::calculate5by5Sum ( unsigned index ) const

Definition at line 150 of file MicroGMTIsolationUnit.cc.

References m_5by1TowerSums, and min().

Referenced by isolate().

 {
   if (index > m_5by1TowerSums.size()) {
     edm::LogWarning("energysum out of bounds!");
     return 0;
   }
   // phi wrap around:
   int returnSum = 0;
   for (int dIPhi = -2; dIPhi <= 2; ++dIPhi) {
     int currIndex = (index + dIPhi*28)%1008; // wrap-around at top
     if (currIndex < 0) currIndex = 1008+currIndex;
     if ((unsigned)currIndex < m_5by1TowerSums.size()) {
       returnSum += m_5by1TowerSums[currIndex];
     } else {
       edm::LogWarning("energysum out of bounds!");
     }
   }
   return std::min(31, returnSum);
 }

void l1t::MicroGMTIsolationUnit::extrapolateMuons ( MicroGMTConfiguration::InterMuonList & inputmuons ) const

Definition at line 66 of file MicroGMTIsolationUnit.cc.

References funct::abs(), spr::deltaEta, hiPixelPairStep_cff::deltaPhi, m_etaExtrapolationLUTs, m_fwVersion, m_phiExtrapolationLUTs, RPCpg::mu, and Validation_hcalonly_cfi::sign.

Referenced by L1TMuonProducer::produce().

                                                                                                {
   int outputShiftPhi = 3;
   int outputShiftEta = 3;
   if (m_fwVersion >= 0x4010000) {
     outputShiftPhi = 2;
     outputShiftEta = 0;
   }
 
   for (auto &mu : inputmuons) {
     // get input format
     std::shared_ptr<MicroGMTExtrapolationLUT> phiExtrapolationLUT = m_phiExtrapolationLUTs.at(mu->trackFinderType());
     int ptRedInWidth = phiExtrapolationLUT->getPtRedInWidth();
     int ptMask = (1 << ptRedInWidth) - 1;
     int etaRedInWidth = phiExtrapolationLUT->getEtaRedInWidth();
     int redEtaShift = 8 - etaRedInWidth;
 
     // only use LSBs of pt:
     int ptRed = mu->hwPt() & ptMask;
     // here we drop the LSBs and mask the MSB
     int etaAbsRed = (std::abs(mu->hwEta()) >> redEtaShift) & ((1 << etaRedInWidth) - 1);
 
     int deltaPhi = 0;
     int deltaEta = 0;
 
     if (mu->hwPt() < (1 << ptRedInWidth)) { // extrapolation only for "low" pT muons
       int sign = 1;
       if (mu->hwSign() == 1) {
         sign = -1;
       }
       deltaPhi = (phiExtrapolationLUT->lookup(etaAbsRed, ptRed) << outputShiftPhi) * sign;
       deltaEta = (m_etaExtrapolationLUTs.at(mu->trackFinderType())->lookup(etaAbsRed, ptRed) << outputShiftEta);
       if (mu->hwEta() > 0) {
         deltaEta *= -1;
       }
     }
 
     mu->setExtrapolation(deltaEta, deltaPhi);
   }
 }

int l1t::MicroGMTIsolationUnit::getCaloIndex ( MicroGMTConfiguration::InterMuon & mu ) const

Definition at line 47 of file MicroGMTIsolationUnit.cc.

References PVValHelper::eta, l1t::MicroGMTConfiguration::getTwosComp(), l1t::GMTInternalMuon::hwDEta(), l1t::GMTInternalMuon::hwDPhi(), l1t::GMTInternalMuon::hwEta(), l1t::GMTInternalMuon::hwGlobalPhi(), m_IdxSelMemEta, m_IdxSelMemPhi, l1t::GMTInternalMuon::setHwCaloEta(), and l1t::GMTInternalMuon::setHwCaloPhi().

Referenced by isolate(), and isolatePreSummed().

 {
   // handle the wrap-around of phi:
   int phi = (mu.hwGlobalPhi() + mu.hwDPhi())%576;
   if (phi < 0) {
     phi = 576+phi;
   }
 
   int phiIndex = m_IdxSelMemPhi->lookup(phi);
   int eta = mu.hwEta()+mu.hwDEta();
   eta = MicroGMTConfiguration::getTwosComp(eta, 9);
   int etaIndex = m_IdxSelMemEta->lookup(eta);
   mu.setHwCaloEta(etaIndex);
   mu.setHwCaloPhi(phiIndex);
 
   return phiIndex + etaIndex*36;
 }

void l1t::MicroGMTIsolationUnit::initialise ( L1TMuonGlobalParamsHelper * microGMTParamsHelper )

Initialisation from ES record.

Definition at line 18 of file MicroGMTIsolationUnit.cc.

Referenced by L1TMuonProducer::beginRun().

                                                                                     {
   m_fwVersion = microGMTParamsHelper->fwVersion();
   m_BEtaExtrapolation = l1t::MicroGMTExtrapolationLUTFactory::create(microGMTParamsHelper->bEtaExtrapolationLUT(), MicroGMTConfiguration::ETA_OUT, m_fwVersion);
   m_BPhiExtrapolation = l1t::MicroGMTExtrapolationLUTFactory::create(microGMTParamsHelper->bPhiExtrapolationLUT(), MicroGMTConfiguration::PHI_OUT, m_fwVersion);
   m_OEtaExtrapolation = l1t::MicroGMTExtrapolationLUTFactory::create(microGMTParamsHelper->oEtaExtrapolationLUT(), MicroGMTConfiguration::ETA_OUT, m_fwVersion);
   m_OPhiExtrapolation = l1t::MicroGMTExtrapolationLUTFactory::create(microGMTParamsHelper->oPhiExtrapolationLUT(), MicroGMTConfiguration::PHI_OUT, m_fwVersion);
   m_FEtaExtrapolation = l1t::MicroGMTExtrapolationLUTFactory::create(microGMTParamsHelper->fEtaExtrapolationLUT(), MicroGMTConfiguration::ETA_OUT, m_fwVersion);
   m_FPhiExtrapolation = l1t::MicroGMTExtrapolationLUTFactory::create(microGMTParamsHelper->fPhiExtrapolationLUT(), MicroGMTConfiguration::PHI_OUT, m_fwVersion);
   m_IdxSelMemEta = l1t::MicroGMTCaloIndexSelectionLUTFactory::create(microGMTParamsHelper->idxSelMemEtaLUT(), MicroGMTConfiguration::ETA, m_fwVersion);
   m_IdxSelMemPhi = l1t::MicroGMTCaloIndexSelectionLUTFactory::create(microGMTParamsHelper->idxSelMemPhiLUT(), MicroGMTConfiguration::PHI, m_fwVersion);
   m_RelIsoCheckMem = l1t::MicroGMTRelativeIsolationCheckLUTFactory::create(microGMTParamsHelper->relIsoCheckMemLUT(), m_fwVersion);
   m_AbsIsoCheckMem = l1t::MicroGMTAbsoluteIsolationCheckLUTFactory::create(microGMTParamsHelper->absIsoCheckMemLUT(), m_fwVersion);
 
   m_etaExtrapolationLUTs[tftype::bmtf] = m_BEtaExtrapolation;
   m_phiExtrapolationLUTs[tftype::bmtf] = m_BPhiExtrapolation;
   m_etaExtrapolationLUTs[tftype::omtf_pos] = m_OEtaExtrapolation;
   m_etaExtrapolationLUTs[tftype::omtf_neg] = m_OEtaExtrapolation;
   m_phiExtrapolationLUTs[tftype::omtf_pos] = m_OPhiExtrapolation;
   m_phiExtrapolationLUTs[tftype::omtf_neg] = m_OPhiExtrapolation;
   m_etaExtrapolationLUTs[tftype::emtf_pos] = m_FEtaExtrapolation;
   m_etaExtrapolationLUTs[tftype::emtf_neg] = m_FEtaExtrapolation;
   m_phiExtrapolationLUTs[tftype::emtf_pos] = m_FPhiExtrapolation;
   m_phiExtrapolationLUTs[tftype::emtf_neg] = m_FPhiExtrapolation;
 
   m_caloInputsToDisable = microGMTParamsHelper->caloInputsToDisable();
   m_maskedCaloInputs = microGMTParamsHelper->maskedCaloInputs();
 }

void l1t::MicroGMTIsolationUnit::isolate ( MicroGMTConfiguration::InterMuonList & muons ) const

Definition at line 171 of file MicroGMTIsolationUnit.cc.

References objects.autophobj::absIso, calculate5by5Sum(), CastorDataFrameFilter_impl::energySum(), getCaloIndex(), m_AbsIsoCheckMem, m_RelIsoCheckMem, RPCpg::mu, and objects.autophobj::relIso.

 {
   for (auto& mu : muons) {
     int caloIndex = getCaloIndex(*mu);
     int energySum = calculate5by5Sum(caloIndex);
     mu->setHwIsoSum(energySum);
 
     int absIso = m_AbsIsoCheckMem->lookup(energySum);
     int relIso = m_RelIsoCheckMem->lookup(energySum, mu->hwPt());
 
     mu->setHwRelIso(relIso);
     mu->setHwAbsIso(absIso);
   }
 }

void l1t::MicroGMTIsolationUnit::isolatePreSummed ( MicroGMTConfiguration::InterMuonList & muons ) const

Definition at line 203 of file MicroGMTIsolationUnit.cc.

References objects.autophobj::absIso, CastorDataFrameFilter_impl::energySum(), getCaloIndex(), m_AbsIsoCheckMem, m_RelIsoCheckMem, m_towerEnergies, RPCpg::mu, and objects.autophobj::relIso.

Referenced by L1TMuonProducer::produce().

 {
   for (const auto &mu : muons) {
     int caloIndex = getCaloIndex(*mu);
     int energySum = 0;
     if (m_towerEnergies.count(caloIndex) == 1) {
       energySum = m_towerEnergies.at(caloIndex);
     }
 
     mu->setHwIsoSum(energySum);
 
     int absIso = m_AbsIsoCheckMem->lookup(energySum);
     int relIso = m_RelIsoCheckMem->lookup(energySum, mu->hwPt());
 
     mu->setHwRelIso(relIso);
     mu->setHwAbsIso(absIso);
   }
 
 }

void l1t::MicroGMTIsolationUnit::setTowerSums	(	const MicroGMTConfiguration::CaloInputCollection &	inputs,
		int	bx
	)

Definition at line 186 of file MicroGMTIsolationUnit.cc.

References BXVector< T >::begin(), BXVector< T >::end(), BXVector< T >::getFirstBX(), BXVector< T >::getLastBX(), input, m_caloInputsToDisable, m_initialSums, m_maskedCaloInputs, m_towerEnergies, and BXVector< T >::size().

Referenced by L1TMuonProducer::produce().

                                                                                                           {
   m_towerEnergies.clear();
   if (bx < inputs.getFirstBX() || bx > inputs.getLastBX()) return;
   if (inputs.size(bx) == 0) return;
   for (auto input = inputs.begin(bx); input != inputs.end(bx); ++input) {
     if (m_caloInputsToDisable.test(input->hwEta()) || m_maskedCaloInputs.test(input->hwEta())) {
       continue; // only process if input link is enabled and not masked
     }
     if ( input->etBits() != 0 ) {
       m_towerEnergies[input->hwEta()*36+input->hwPhi()] = input->etBits();
     }
   }
 
   m_initialSums = true;
 
 }