#include <L1Trigger/L1TMuon/src/L1TMuonProducer.cc>

Inheritance diagram for L1TMuonProducer:

Public Member Functions
	L1TMuonProducer (const edm::ParameterSet &)

	~L1TMuonProducer ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	addMuonsToCollections (MicroGMTConfiguration::InterMuonList &coll, MicroGMTConfiguration::InterMuonList &interout, std::unique_ptr< MuonBxCollection > &out, int bx) const

virtual void	beginJob ()

virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	beginRun (edm::Run const &, edm::EventSetup const &)

void	calculateRank (MicroGMTConfiguration::InterMuonList &muons) const

void	convertMuons (edm::Handle< MicroGMTConfiguration::InputCollection > const &in, MicroGMTConfiguration::InterMuonList &out, GMTInternalWedges &wedges, int bx) const

virtual void	endJob ()

virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	endRun (edm::Run const &, edm::EventSetup const &)

virtual void	produce (edm::Event &, const edm::EventSetup &)

void	sortMuons (MicroGMTConfiguration::InterMuonList &, unsigned) const

void	splitAndConvertMuons (edm::Handle< MicroGMTConfiguration::InputCollection > const &in, MicroGMTConfiguration::InterMuonList &out_pos, MicroGMTConfiguration::InterMuonList &out_neg, GMTInternalWedges &wedges_pos, GMTInternalWedges &wedges_neg, int bx) const

Static Private Member Functions
static bool	compareMuons (const std::shared_ptr< MicroGMTConfiguration::InterMuon > &mu1, const std::shared_ptr< MicroGMTConfiguration::InterMuon > &mu2)

Private Attributes
bool	m_autoBxRange

edm::InputTag	m_barrelTfInputTag

edm::EDGetTokenT< MicroGMTConfiguration::InputCollection >	m_barrelTfInputToken

std::bitset< 12 >	m_bmtfInputsToDisable

int	m_bxMax

int	m_bxMin

std::bitset< 28 >	m_caloInputsToDisable

edm::EDGetTokenT< MicroGMTConfiguration::CaloInputCollection >	m_caloTowerInputToken

MicroGMTCancelOutUnit	m_cancelOutUnit

std::ofstream	m_debugOut

std::bitset< 12 >	m_emtfInputsToDisable

edm::InputTag	m_endcapTfInputTag

edm::EDGetTokenT< MicroGMTConfiguration::InputCollection >	m_endcapTfInputToken

std::bitset< 72 >	m_inputsToDisable

MicroGMTIsolationUnit	m_isolationUnit

std::bitset< 12 >	m_maskedBmtfInputs

std::bitset< 28 >	m_maskedCaloInputs

std::bitset< 12 >	m_maskedEmtfInputs

std::bitset< 72 >	m_maskedInputs

std::bitset< 12 >	m_maskedOmtfInputs

std::bitset< 12 >	m_omtfInputsToDisable

edm::InputTag	m_overlapTfInputTag

edm::EDGetTokenT< MicroGMTConfiguration::InputCollection >	m_overlapTfInputToken

std::shared_ptr< MicroGMTRankPtQualLUT >	m_rankPtQualityLUT

edm::InputTag	m_trigTowerTag

std::unique_ptr< L1TMuonGlobalParamsHelper >	microGMTParamsHelper

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Description: Takes txt-file input and produces barrel- / overlap- / forward TF muons

Implementation: [Notes on implementation]

Definition at line 58 of file L1TMuonProducer.cc.

Constructor & Destructor Documentation

L1TMuonProducer::L1TMuonProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 142 of file L1TMuonProducer.cc.

References edm::ParameterSet::getParameter(), m_autoBxRange, m_barrelTfInputTag, m_barrelTfInputToken, m_bxMax, m_bxMin, m_caloTowerInputToken, m_endcapTfInputTag, m_endcapTfInputToken, m_overlapTfInputTag, m_overlapTfInputToken, and m_trigTowerTag.

                                                                : m_debugOut("test/debug/iso_debug.dat")
 {
   // edm::InputTag barrelTfInputTag = iConfig.getParameter<edm::InputTag>("barrelTFInput");
   // edm::InputTag overlapTfInputTag = iConfig.getParameter<edm::InputTag>("overlapTFInput");
   // edm::InputTag forwardTfInputTag = iConfig.getParameter<edm::InputTag>("forwardTFInput");
 
   m_barrelTfInputTag = iConfig.getParameter<edm::InputTag>("barrelTFInput");
   m_overlapTfInputTag = iConfig.getParameter<edm::InputTag>("overlapTFInput");
   m_endcapTfInputTag = iConfig.getParameter<edm::InputTag>("forwardTFInput");
   m_trigTowerTag = iConfig.getParameter<edm::InputTag>("triggerTowerInput");
 
   m_autoBxRange = iConfig.getParameter<bool>("autoBxRange");
   m_bxMin = iConfig.getParameter<int>("bxMin");
   m_bxMax = iConfig.getParameter<int>("bxMax");
 
   m_barrelTfInputToken = consumes<MicroGMTConfiguration::InputCollection>(m_barrelTfInputTag);
   m_overlapTfInputToken = consumes<MicroGMTConfiguration::InputCollection>(m_overlapTfInputTag);
   m_endcapTfInputToken = consumes<MicroGMTConfiguration::InputCollection>(m_endcapTfInputTag);
   m_caloTowerInputToken = consumes<MicroGMTConfiguration::CaloInputCollection>(m_trigTowerTag);
 
   //register your products
   produces<MuonBxCollection>();
   produces<MuonBxCollection>("imdMuonsBMTF");
   produces<MuonBxCollection>("imdMuonsEMTFPos");
   produces<MuonBxCollection>("imdMuonsEMTFNeg");
   produces<MuonBxCollection>("imdMuonsOMTFPos");
   produces<MuonBxCollection>("imdMuonsOMTFNeg");
 }

L1TMuonProducer::~L1TMuonProducer ( )

Definition at line 171 of file L1TMuonProducer.cc.

References m_debugOut.

 {
   m_debugOut.close();
 }

Member Function Documentation

void L1TMuonProducer::addMuonsToCollections	(	MicroGMTConfiguration::InterMuonList &	coll,
		MicroGMTConfiguration::InterMuonList &	interout,
		std::unique_ptr< MuonBxCollection > &	out,
		int	bx
	)		const

private

Definition at line 410 of file L1TMuonProducer.cc.

References RPCpg::mu.

Referenced by produce().

 {
   for (auto& mu : coll) {
     interout.push_back(mu);
     math::PtEtaPhiMLorentzVector vec{(mu->hwPt()-1)*0.5, mu->hwEta()*0.010875, mu->hwGlobalPhi()*0.010908, 0.0};
     int outMuQual = MicroGMTConfiguration::setOutputMuonQuality(mu->hwQual(), mu->trackFinderType(), mu->hwHF());
     Muon outMu{vec, mu->hwPt(), mu->hwEta(), mu->hwGlobalPhi(), outMuQual, mu->hwSign(), mu->hwSignValid(), -1, mu->tfMuonIndex(), 0, true, -1, mu->hwDPhi(), mu->hwDEta(), mu->hwRank()};
     if (mu->hwSignValid()) {
       outMu.setCharge(1 - 2 * mu->hwSign());
     } else {
       outMu.setCharge(0);
     }
     // set the coordinates at the vertex to be the same as coordinates at muon station
     outMu.setHwEtaAtVtx(outMu.hwEta());
     outMu.setHwPhiAtVtx(outMu.hwPhi());
     outMu.setEtaAtVtx(outMu.eta());
     outMu.setPhiAtVtx(outMu.phi());
 
     out->push_back(bx, outMu);
   }
 }

void L1TMuonProducer::beginJob ( void )

privatevirtual

Reimplemented from edm::EDProducer.

Definition at line 509 of file L1TMuonProducer.cc.

510 {

511 }

void L1TMuonProducer::beginLuminosityBlock	(	edm::LuminosityBlock const &	,
		edm::EventSetup const &
	)

privatevirtual

Reimplemented from edm::EDProducer.

Definition at line 557 of file L1TMuonProducer.cc.

558 {

559 }

void L1TMuonProducer::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	iSetup
	)

privatevirtual

Reimplemented from edm::EDProducer.

Definition at line 520 of file L1TMuonProducer.cc.

References l1t::MicroGMTRankPtQualLUTFactory::create(), edm::EventSetup::get(), edm::eventsetup::EventSetupRecord::get(), l1t::MicroGMTIsolationUnit::initialise(), l1t::MicroGMTCancelOutUnit::initialise(), m_bmtfInputsToDisable, m_caloInputsToDisable, m_cancelOutUnit, m_emtfInputsToDisable, m_inputsToDisable, m_isolationUnit, m_maskedBmtfInputs, m_maskedCaloInputs, m_maskedEmtfInputs, m_maskedInputs, m_maskedOmtfInputs, m_omtfInputsToDisable, m_rankPtQualityLUT, and microGMTParamsHelper.

 {
   const L1TMuonGlobalParamsRcd& microGMTParamsRcd = iSetup.get<L1TMuonGlobalParamsRcd>();
   edm::ESHandle<L1TMuonGlobalParams> microGMTParamsHandle;
   microGMTParamsRcd.get(microGMTParamsHandle);
 
   microGMTParamsHelper = std::unique_ptr<L1TMuonGlobalParamsHelper>(new L1TMuonGlobalParamsHelper(*microGMTParamsHandle.product()));
   if (!microGMTParamsHelper) {
     edm::LogError("L1TMuonProducer") << "Could not retrieve parameters from Event Setup" << std::endl;
   }
 
   //microGMTParamsHelper->print(std::cout);
   m_inputsToDisable  = microGMTParamsHelper->inputsToDisable();
   edm::LogVerbatim("L1TMuonProducer") << "uGMT inputsToDisable: " << m_inputsToDisable << "\n                      EMTF-|OMTF-|   BMTF    |OMTF+|EMTF+|            CALO           |  res  0";
   m_caloInputsToDisable  = microGMTParamsHelper->caloInputsToDisable();
   m_bmtfInputsToDisable  = microGMTParamsHelper->bmtfInputsToDisable();
   m_omtfInputsToDisable  = microGMTParamsHelper->omtfInputsToDisable();
   m_emtfInputsToDisable  = microGMTParamsHelper->emtfInputsToDisable();
   m_maskedInputs  = microGMTParamsHelper->maskedInputs();
   edm::LogVerbatim("L1TMuonProducer") << "uGMT maskedInputs:    " << m_maskedInputs << "\n                      EMTF-|OMTF-|   BMTF    |OMTF+|EMTF+|            CALO           |  res  0";
   m_maskedCaloInputs  = microGMTParamsHelper->maskedCaloInputs();
   m_maskedBmtfInputs  = microGMTParamsHelper->maskedBmtfInputs();
   m_maskedOmtfInputs  = microGMTParamsHelper->maskedOmtfInputs();
   m_maskedEmtfInputs  = microGMTParamsHelper->maskedEmtfInputs();
   m_rankPtQualityLUT = l1t::MicroGMTRankPtQualLUTFactory::create(microGMTParamsHelper->sortRankLUT(), microGMTParamsHelper->fwVersion());
   m_isolationUnit.initialise(microGMTParamsHelper.get());
   m_cancelOutUnit.initialise(microGMTParamsHelper.get());
 }

void L1TMuonProducer::calculateRank ( MicroGMTConfiguration::InterMuonList & muons ) const

private

Definition at line 400 of file L1TMuonProducer.cc.

References m_rankPtQualityLUT.

Referenced by produce().

 {
   for (auto& mu1 : muons) {
     int rank = m_rankPtQualityLUT->lookup(mu1->hwPt(), mu1->hwQual());
     mu1->setHwRank(rank);
   }
 }

bool L1TMuonProducer::compareMuons	(	const std::shared_ptr< MicroGMTConfiguration::InterMuon > &	mu1,
		const std::shared_ptr< MicroGMTConfiguration::InterMuon > &	mu2
	)

staticprivate

Definition at line 354 of file L1TMuonProducer.cc.

Referenced by sortMuons().

                                                                                               {
   return (mu1->hwWins() >= mu2->hwWins());
 }

void L1TMuonProducer::convertMuons	(	edm::Handle< MicroGMTConfiguration::InputCollection > const &	in,
		MicroGMTConfiguration::InterMuonList &	out,
		GMTInternalWedges &	wedges,
		int	bx
	)		const

private

Definition at line 477 of file L1TMuonProducer.cc.

References BXVector< T >::at(), BXVector< T >::getLastBX(), l1t::RegionalMuonCand::hwPhi(), mps_fire::i, l1t::RegionalMuonCand::link(), m_inputsToDisable, m_maskedInputs, l1t::RegionalMuonCand::processor(), BXVector< T >::size(), findQualityFiles::size, and l1t::RegionalMuonCand::trackFinderType().

Referenced by produce().

 {
   // initialize the wedge collection:
   for (int i = 0; i < 12; ++i) {
     wedges[i] = std::vector<std::shared_ptr<GMTInternalMuon>>();
     wedges[i].reserve(3);
   }
   if (bx < in->getFirstBX() || bx > in->getLastBX()) return;
   int muIdx = 0;
   int currentLink = 0;
   for (size_t i = 0; i < in->size(bx); ++i, ++muIdx) {
     int link = in->at(bx, i).link();
     if (m_inputsToDisable.test(link) || m_maskedInputs.test(link)) continue; // only process if input link is enabled and not masked
     if (currentLink != link) {
       muIdx = 0;
       currentLink = link;
     }
     int gPhi = MicroGMTConfiguration::calcGlobalPhi(in->at(bx, i).hwPhi(), in->at(bx, i).trackFinderType(), in->at(bx, i).processor());
     int tfMuonIdx = 3 * (currentLink - 36) + muIdx;
     std::shared_ptr<GMTInternalMuon> outMu = std::make_shared<GMTInternalMuon>(in->at(bx, i), gPhi, tfMuonIdx);
     out.emplace_back(outMu);
     wedges[in->at(bx, i).processor()].push_back(outMu);
   }
   for (int i = 0; i < 12; ++i) {
     if(wedges[i].size() > 3) edm::LogWarning("Input Mismatch") << " too many inputs per processor for barrel. Wedge " << i << ": Size " << wedges[i].size() << std::endl;
   }
 }

void L1TMuonProducer::endJob ( void )

privatevirtual

Reimplemented from edm::EDProducer.

Definition at line 515 of file L1TMuonProducer.cc.

515 {

516 }

void L1TMuonProducer::endLuminosityBlock	(	edm::LuminosityBlock const &	,
		edm::EventSetup const &
	)

privatevirtual

Reimplemented from edm::EDProducer.

Definition at line 563 of file L1TMuonProducer.cc.

564 {

565 }

void L1TMuonProducer::endRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

privatevirtual

Reimplemented from edm::EDProducer.

Definition at line 551 of file L1TMuonProducer.cc.

552 {

553 }

void L1TMuonProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 569 of file L1TMuonProducer.cc.

References edm::ConfigurationDescriptions::addDefault(), DEFINE_FWK_MODULE, and edm::ParameterSetDescription::setUnknown().

                                                                             {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

void L1TMuonProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Definition at line 185 of file L1TMuonProducer.cc.

References addMuonsToCollections(), l1t::bmtf, calculateRank(), convertMuons(), l1t::coordinate, l1t::emtf_neg, l1t::emtf_pos, l1t::MicroGMTIsolationUnit::extrapolateMuons(), edm::Event::getByToken(), BXVector< T >::getFirstBX(), BXVector< T >::getLastBX(), l1t::MicroGMTIsolationUnit::isolatePreSummed(), m_autoBxRange, m_barrelTfInputToken, m_bmtfInputsToDisable, m_bxMax, m_bxMin, m_caloInputsToDisable, m_caloTowerInputToken, m_cancelOutUnit, m_debugOut, m_emtfInputsToDisable, m_endcapTfInputToken, m_isolationUnit, m_maskedBmtfInputs, m_maskedCaloInputs, m_maskedEmtfInputs, m_maskedOmtfInputs, m_omtfInputsToDisable, m_overlapTfInputToken, hpstanc_transforms::max, min(), eostools::move(), RPCpg::mu, l1t::omtf_neg, l1t::omtf_pos, edm::Event::put(), l1t::MicroGMTCancelOutUnit::setCancelOutBits(), l1t::MicroGMTCancelOutUnit::setCancelOutBitsOverlapBarrel(), l1t::MicroGMTCancelOutUnit::setCancelOutBitsOverlapEndcap(), l1t::MicroGMTIsolationUnit::setTowerSums(), sortMuons(), splitAndConvertMuons(), and l1t::tracks.

 {
   using namespace edm;
   std::unique_ptr<MuonBxCollection> outMuons (new MuonBxCollection());
   std::unique_ptr<MuonBxCollection> imdMuonsBMTF (new MuonBxCollection());
   std::unique_ptr<MuonBxCollection> imdMuonsEMTFPos (new MuonBxCollection());
   std::unique_ptr<MuonBxCollection> imdMuonsEMTFNeg (new MuonBxCollection());
   std::unique_ptr<MuonBxCollection> imdMuonsOMTFPos (new MuonBxCollection());
   std::unique_ptr<MuonBxCollection> imdMuonsOMTFNeg (new MuonBxCollection());
 
 
   Handle<MicroGMTConfiguration::InputCollection> bmtfMuons;
   Handle<MicroGMTConfiguration::InputCollection> emtfMuons;
   Handle<MicroGMTConfiguration::InputCollection> omtfMuons;
   Handle<MicroGMTConfiguration::CaloInputCollection> trigTowers;
 
   iEvent.getByToken(m_barrelTfInputToken, bmtfMuons);
   iEvent.getByToken(m_endcapTfInputToken, emtfMuons);
   iEvent.getByToken(m_overlapTfInputToken, omtfMuons);
   iEvent.getByToken(m_caloTowerInputToken, trigTowers);
 
   // find out the BX range from the inputs
   // the smallest BX window defines the output BX window
   if (m_autoBxRange) {
     int bxMin = -1000;
     int bxMax = 1000;
     if (!(m_caloInputsToDisable.all() || m_maskedCaloInputs.all())) {
       bxMin = std::max(bxMin, trigTowers->getFirstBX());
       bxMax = std::min(bxMax, trigTowers->getLastBX());
     }
     if (!(m_bmtfInputsToDisable.all() || m_maskedBmtfInputs.all())) {
       bxMin = std::max(bxMin, bmtfMuons->getFirstBX());
       bxMax = std::min(bxMax, bmtfMuons->getLastBX());
     }
     if (!(m_omtfInputsToDisable.all() || m_maskedOmtfInputs.all())) {
       bxMin = std::max(bxMin, omtfMuons->getFirstBX());
       bxMax = std::min(bxMax, omtfMuons->getLastBX());
     }
     if (!(m_emtfInputsToDisable.all() || m_maskedEmtfInputs.all())) {
       bxMin = std::max(bxMin, emtfMuons->getFirstBX());
       bxMax = std::min(bxMax, emtfMuons->getLastBX());
     }
     if (bxMin > 0) {
       bxMin = 0;
     }
     if (bxMax < 0){
       bxMax = 0;
     }
     if (bxMin > -1000) {
       m_bxMin = bxMin;
     } else {
       m_bxMin = 0;
     }
     if (bxMax < 1000) {
       m_bxMax = bxMax;
     } else {
       m_bxMax = 0;
     }
   }
 
   // set BX range for outputs
   outMuons->setBXRange(m_bxMin, m_bxMax);
   imdMuonsBMTF->setBXRange(m_bxMin, m_bxMax);
   imdMuonsEMTFPos->setBXRange(m_bxMin, m_bxMax);
   imdMuonsEMTFNeg->setBXRange(m_bxMin, m_bxMax);
   imdMuonsOMTFPos->setBXRange(m_bxMin, m_bxMax);
   imdMuonsOMTFNeg->setBXRange(m_bxMin, m_bxMax);
 
   for (int bx = m_bxMin; bx <= m_bxMax; ++bx) {
     m_isolationUnit.setTowerSums(*trigTowers, bx);
     MicroGMTConfiguration::InterMuonList internMuonsBmtf;
     MicroGMTConfiguration::InterMuonList internMuonsEmtfPos;
     MicroGMTConfiguration::InterMuonList internMuonsEmtfNeg;
     MicroGMTConfiguration::InterMuonList internMuonsOmtfPos;
     MicroGMTConfiguration::InterMuonList internMuonsOmtfNeg;
 
     // These wedges contain shared pointers to the ones in the InterMuonList
     GMTInternalWedges omtfNegWedges;
     GMTInternalWedges bmtfWedges;
     GMTInternalWedges emtfPosWedges;
     GMTInternalWedges emtfNegWedges;
     GMTInternalWedges omtfPosWedges;
 
     // this converts the InputMuon type to the InternalMuon type and splits them into
     // positive / negative eta collections necessary as LUTs may differ for pos / neg.
     convertMuons(bmtfMuons, internMuonsBmtf, bmtfWedges, bx);
     splitAndConvertMuons(emtfMuons, internMuonsEmtfPos, internMuonsEmtfNeg, emtfPosWedges, emtfNegWedges, bx);
     splitAndConvertMuons(omtfMuons, internMuonsOmtfPos, internMuonsOmtfNeg, omtfPosWedges, omtfNegWedges, bx);
 
     // cancel out within the track finders:
     m_cancelOutUnit.setCancelOutBits(bmtfWedges, tftype::bmtf, cancelmode::tracks);
     m_cancelOutUnit.setCancelOutBits(omtfPosWedges, tftype::omtf_pos, cancelmode::coordinate);
     m_cancelOutUnit.setCancelOutBits(omtfNegWedges, tftype::omtf_neg, cancelmode::coordinate);
     // cancel-out for endcap will be done in the sorter
     m_cancelOutUnit.setCancelOutBits(emtfPosWedges, tftype::emtf_pos, cancelmode::coordinate);
     m_cancelOutUnit.setCancelOutBits(emtfNegWedges, tftype::emtf_neg, cancelmode::coordinate);
 
     // cancel out between track finder acceptance overlaps:
     m_cancelOutUnit.setCancelOutBitsOverlapBarrel(omtfPosWedges, bmtfWedges, cancelmode::coordinate);
     m_cancelOutUnit.setCancelOutBitsOverlapBarrel(omtfNegWedges, bmtfWedges, cancelmode::coordinate);
     m_cancelOutUnit.setCancelOutBitsOverlapEndcap(omtfPosWedges, emtfPosWedges, cancelmode::coordinate);
     m_cancelOutUnit.setCancelOutBitsOverlapEndcap(omtfNegWedges, emtfNegWedges, cancelmode::coordinate);
 
     m_isolationUnit.extrapolateMuons(internMuonsBmtf);
     m_isolationUnit.extrapolateMuons(internMuonsEmtfNeg);
     m_isolationUnit.extrapolateMuons(internMuonsEmtfPos);
     m_isolationUnit.extrapolateMuons(internMuonsOmtfNeg);
     m_isolationUnit.extrapolateMuons(internMuonsOmtfPos);
 
     // the rank calculated here is used in the sort below
     calculateRank(internMuonsBmtf);
     calculateRank(internMuonsEmtfNeg);
     calculateRank(internMuonsEmtfPos);
     calculateRank(internMuonsOmtfNeg);
     calculateRank(internMuonsOmtfPos);
 
     // The sort function both sorts and removes all but best "nSurvivors"
     sortMuons(internMuonsBmtf, 8);
     sortMuons(internMuonsOmtfPos, 4);
     sortMuons(internMuonsOmtfNeg, 4);
     sortMuons(internMuonsEmtfPos, 4);
     sortMuons(internMuonsEmtfNeg, 4);
 
     // This combines the 5 streams into one InternalMuon collection for
     // the final global sort.
     MicroGMTConfiguration::InterMuonList internalMuons;
     addMuonsToCollections(internMuonsEmtfPos, internalMuons, imdMuonsEMTFPos, bx);
     addMuonsToCollections(internMuonsOmtfPos, internalMuons, imdMuonsOMTFPos, bx);
     addMuonsToCollections(internMuonsBmtf, internalMuons, imdMuonsBMTF, bx);
     addMuonsToCollections(internMuonsOmtfNeg, internalMuons, imdMuonsOMTFNeg, bx);
     addMuonsToCollections(internMuonsEmtfNeg, internalMuons, imdMuonsEMTFNeg, bx);
 
     // sort internal muons and delete all but best 8
     sortMuons(internalMuons, 8);
 
     m_isolationUnit.isolatePreSummed(internalMuons);
     // copy muons to output collection...
     for (const auto& mu : internalMuons) {
       if (mu->hwPt() > 0) {
         math::PtEtaPhiMLorentzVector vec{(mu->hwPt()-1)*0.5, mu->hwEta()*0.010875, mu->hwGlobalPhi()*0.010908, 0.0};
         int iso = mu->hwAbsIso() + (mu->hwRelIso() << 1);
         int outMuQual = MicroGMTConfiguration::setOutputMuonQuality(mu->hwQual(), mu->trackFinderType(), mu->hwHF());
         Muon outMu{vec, mu->hwPt(), mu->hwEta(), mu->hwGlobalPhi(), outMuQual, mu->hwSign(), mu->hwSignValid(), iso, mu->tfMuonIndex(), 0, true, mu->hwIsoSum(), mu->hwDPhi(), mu->hwDEta(), mu->hwRank()};
         if (mu->hwSignValid()) {
           outMu.setCharge(1 - 2 * mu->hwSign());
         } else {
           outMu.setCharge(0);
         }
         // set the coordinates at the vertex
         outMu.setHwEtaAtVtx(MicroGMTConfiguration::calcMuonHwEtaExtra(outMu));
         outMu.setHwPhiAtVtx(MicroGMTConfiguration::calcMuonHwPhiExtra(outMu));
         outMu.setEtaAtVtx(MicroGMTConfiguration::calcMuonEtaExtra(outMu));
         outMu.setPhiAtVtx(MicroGMTConfiguration::calcMuonPhiExtra(outMu));
         m_debugOut << mu->hwCaloPhi() << " " << mu->hwCaloEta() << std::endl;
         outMuons->push_back(bx, outMu);
       }
     }
   }
 
   iEvent.put(std::move(outMuons));
   iEvent.put(std::move(imdMuonsBMTF), "imdMuonsBMTF");
   iEvent.put(std::move(imdMuonsEMTFPos), "imdMuonsEMTFPos");
   iEvent.put(std::move(imdMuonsEMTFNeg), "imdMuonsEMTFNeg");
   iEvent.put(std::move(imdMuonsOMTFPos), "imdMuonsOMTFPos");
   iEvent.put(std::move(imdMuonsOMTFNeg), "imdMuonsOMTFNeg");
 }

void L1TMuonProducer::sortMuons	(	MicroGMTConfiguration::InterMuonList &	muons,
		unsigned	nSurvivors
	)		const

private

Definition at line 360 of file L1TMuonProducer.cc.

References compareMuons().

Referenced by produce().

                                                                                                {
   MicroGMTConfiguration::InterMuonList::iterator mu1;
   // reset from previous sort stage
   for (mu1 = muons.begin(); mu1 != muons.end(); ++mu1) {
     (*mu1)->setHwWins(0);
   }
 
   int nCancelled = 0;
   for (mu1 = muons.begin(); mu1 != muons.end(); ++mu1) {
     int mu1CancelBit = (*mu1)->hwCancelBit();
     nCancelled += mu1CancelBit;
     auto mu2 = mu1;
     mu2++;
     for ( ; mu2 != muons.end(); ++mu2) {
       if (mu1CancelBit != 1 && (*mu2)->hwCancelBit() != 1) {
         if ((*mu1)->hwRank() >= (*mu2)->hwRank()) {
           (*mu1)->increaseWins();
         } else {
           (*mu2)->increaseWins();
         }
       } else if (mu1CancelBit != 1) {
         (*mu1)->increaseWins();
       } else if ((*mu2)->hwCancelBit() != 1) {
         (*mu2)->increaseWins();
       }
     }
   }
 
   size_t nMuonsBefore = muons.size();
   int minWins = nMuonsBefore - nSurvivors;
 
   // remove all muons that were cancelled or that do not have sufficient rank
   // (reduces the container size to nSurvivors)
   muons.remove_if([&minWins](auto muon) { return ((muon->hwWins() < minWins) || (muon->hwCancelBit() == 1)); });
   muons.sort(L1TMuonProducer::compareMuons);
 }

void L1TMuonProducer::splitAndConvertMuons	(	edm::Handle< MicroGMTConfiguration::InputCollection > const &	in,
		MicroGMTConfiguration::InterMuonList &	out_pos,
		MicroGMTConfiguration::InterMuonList &	out_neg,
		GMTInternalWedges &	wedges_pos,
		GMTInternalWedges &	wedges_neg,
		int	bx
	)		const

private

Definition at line 435 of file L1TMuonProducer.cc.

References BXVector< T >::at(), BXVector< T >::getLastBX(), l1t::RegionalMuonCand::hwEta(), l1t::RegionalMuonCand::hwPhi(), mps_fire::i, l1t::RegionalMuonCand::link(), m_inputsToDisable, m_maskedInputs, MillePedeFileConverter_cfg::out, l1t::RegionalMuonCand::processor(), BXVector< T >::size(), findQualityFiles::size, and l1t::RegionalMuonCand::trackFinderType().

Referenced by produce().

 {
   // initialize the wedge collections:
   for (int i = 0; i < 6; ++i) {
     wedges_pos[i] = std::vector<std::shared_ptr<GMTInternalMuon>>();
     wedges_pos[i].reserve(3);
     wedges_neg[i] = std::vector<std::shared_ptr<GMTInternalMuon>>();
     wedges_neg[i].reserve(3);
   }
   if (bx < in->getFirstBX() || bx > in->getLastBX()) return;
   int muIdx = 0;
   int currentLink = 0;
   for (size_t i = 0; i < in->size(bx); ++i, ++muIdx) {
     int link = in->at(bx, i).link();
     if (m_inputsToDisable.test(link) || m_maskedInputs.test(link)) continue; // only process if input link is enabled and not masked
     if (currentLink != link) {
       muIdx = 0;
       currentLink = link;
     }
     int gPhi = MicroGMTConfiguration::calcGlobalPhi(in->at(bx, i).hwPhi(), in->at(bx, i).trackFinderType(), in->at(bx, i).processor());
     int tfMuonIdx = 3 * (currentLink - 36) + muIdx;
     std::shared_ptr<GMTInternalMuon> out = std::make_shared<GMTInternalMuon>(in->at(bx, i), gPhi, tfMuonIdx);
     if(in->at(bx, i).hwEta() > 0) {
       out_pos.push_back(out);
       wedges_pos[in->at(bx, i).processor()].push_back(out);
     } else {
       out_neg.emplace_back(out);
       wedges_neg[in->at(bx, i).processor()].push_back(out);
     }
   }
   for (int i = 0; i < 6; ++i) {
     if(wedges_pos[i].size() > 3) edm::LogWarning("Input Mismatch") << " too many inputs per processor for emtf+ / omtf+. Wedge " << i << ": Size " << wedges_pos[i].size() << std::endl;
     if(wedges_neg[i].size() > 3) edm::LogWarning("Input Mismatch") << " too many inputs per processor for emtf- / omtf-. Wedge " << i << ": Size " << wedges_neg[i].size() << std::endl;
   }
 }