L1TMuonProducer Class Reference

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

Inheritance diagram for L1TMuonProducer:

Public Member Functions
	L1TMuonProducer (const edm::ParameterSet &)
	~L1TMuonProducer () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final

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

Private Member Functions
void	addMuonsToCollections (MicroGMTConfiguration::InterMuonList &coll, MicroGMTConfiguration::InterMuonList &interout, std::unique_ptr< MuonBxCollection > &out, int bx) const
void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
void	beginRun (edm::Run const &, edm::EventSetup const &) override
void	calculateRank (MicroGMTConfiguration::InterMuonList &muons) const
void	convertMuons (edm::Handle< MicroGMTConfiguration::InputCollection > const &in, MicroGMTConfiguration::InterMuonList &out, GMTInternalWedges &wedges, int bx) const
void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
void	endRun (edm::Run const &, edm::EventSetup const &) override
void	produce (edm::Event &, const edm::EventSetup &) override
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
bool	m_autoCancelMode
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
l1t::cancelmode	m_emtfCancelMode
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::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

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

Implementation: [Notes on implementation]

Definition at line 59 of file L1TMuonProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 143 of file L1TMuonProducer.cc.

References edm::ParameterSet::getParameter(), m_autoBxRange, m_autoCancelMode, m_barrelTfInputTag, m_barrelTfInputToken, m_bxMax, m_bxMin, m_caloTowerInputToken, m_emtfCancelMode, m_endcapTfInputTag, m_endcapTfInputToken, m_overlapTfInputTag, m_overlapTfInputToken, m_trigTowerTag, AlCaHLTBitMon_QueryRunRegistry::string, and l1t::tracks.

                                                               : m_debugOut("test/debug/iso_debug.dat"), m_emtfCancelMode(cancelmode::coordinate)
{
  // 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_autoCancelMode = iConfig.getParameter<bool>("autoCancelMode");
  if (!m_autoCancelMode && iConfig.getParameter<std::string>("emtfCancelMode").find("tracks") == 0) {
    m_emtfCancelMode = cancelmode::tracks;
  }

  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 ( )

override

Definition at line 177 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 415 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());
    // set tfMuonIndex and iso to 0 like in the FW
    Muon outMu{vec, mu->hwPt(), mu->hwEta(), mu->hwGlobalPhi(), outMuQual, mu->hwSign(), mu->hwSignValid(), 0, 0, 0, true, 0, mu->hwDPhi(), mu->hwDEta(), mu->hwRank()};
    if (mu->hwSignValid()) {
      outMu.setCharge(1 - 2 * mu->hwSign());
    } else {
      outMu.setCharge(0);
    }

    out->push_back(bx, outMu);
  }
}

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

overrideprivate

Definition at line 554 of file L1TMuonProducer.cc.

{
}

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

overrideprivate

Definition at line 510 of file L1TMuonProducer.cc.

References cast_to_L1TMuonGlobalParams(), cast_to_L1TMuonGlobalParams_PUBLIC(), l1t::MicroGMTRankPtQualLUTFactory::create(), edm::EventSetup::get(), edm::eventsetup::EventSetupRecord::get(), l1t::MicroGMTIsolationUnit::initialise(), l1t::MicroGMTCancelOutUnit::initialise(), m_autoCancelMode, m_bmtfInputsToDisable, m_caloInputsToDisable, m_cancelOutUnit, m_emtfCancelMode, m_emtfInputsToDisable, m_inputsToDisable, m_isolationUnit, m_maskedBmtfInputs, m_maskedCaloInputs, m_maskedEmtfInputs, m_maskedInputs, m_maskedOmtfInputs, m_omtfInputsToDisable, m_rankPtQualityLUT, microGMTParamsHelper, edm::ESHandle< T >::product(), and l1t::tracks.

{
  const L1TMuonGlobalParamsRcd& microGMTParamsRcd = iSetup.get<L1TMuonGlobalParamsRcd>();
  edm::ESHandle<L1TMuonGlobalParams> microGMTParamsHandle;
  microGMTParamsRcd.get(microGMTParamsHandle);

  std::unique_ptr<L1TMuonGlobalParams_PUBLIC> microGMTParams( new L1TMuonGlobalParams_PUBLIC( cast_to_L1TMuonGlobalParams_PUBLIC(*microGMTParamsHandle.product()) ) );
  if( microGMTParams->pnodes_.empty() ){ 
      edm::ESHandle<L1TMuonGlobalParams> o2oProtoHandle;
      iSetup.get<L1TMuonGlobalParamsO2ORcd>().get(o2oProtoHandle);
      microGMTParamsHelper = std::unique_ptr<L1TMuonGlobalParamsHelper>(new L1TMuonGlobalParamsHelper(*o2oProtoHandle.product()));
  } else
      microGMTParamsHelper.reset( new L1TMuonGlobalParamsHelper(cast_to_L1TMuonGlobalParams(*microGMTParams.get())) );

  //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());

  if (m_autoCancelMode && microGMTParamsHelper->fwVersion() > 0x5000000) {
    m_emtfCancelMode = cancelmode::tracks;
  }
}

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

private

Definition at line 405 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 359 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 478 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::endLuminosityBlock ( edm::LuminosityBlock const &  , edm::EventSetup const &    )

overrideprivate

Definition at line 560 of file L1TMuonProducer.cc.

{
}

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

overrideprivate

Definition at line 548 of file L1TMuonProducer.cc.

{
}

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

static

Definition at line 566 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  )

overrideprivate

Definition at line 191 of file L1TMuonProducer.cc.

References addMuonsToCollections(), l1t::bmtf, calculateRank(), convertMuons(), 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_emtfCancelMode, m_emtfInputsToDisable, m_endcapTfInputToken, m_isolationUnit, m_maskedBmtfInputs, m_maskedCaloInputs, m_maskedEmtfInputs, m_maskedOmtfInputs, m_omtfInputsToDisable, m_overlapTfInputToken, SiStripPI::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);
    m_cancelOutUnit.setCancelOutBits(emtfPosWedges, tftype::emtf_pos, m_emtfCancelMode);
    m_cancelOutUnit.setCancelOutBits(emtfNegWedges, tftype::emtf_neg, m_emtfCancelMode);

    // 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 365 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 436 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;
  }
}

Member Data Documentation

bool L1TMuonProducer::m_autoBxRange

private

Definition at line 99 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer(), and produce().

bool L1TMuonProducer::m_autoCancelMode

private

Definition at line 102 of file L1TMuonProducer.cc.

Referenced by beginRun(), and L1TMuonProducer().

edm::InputTag L1TMuonProducer::m_barrelTfInputTag

private

Definition at line 114 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer().

edm::EDGetTokenT<MicroGMTConfiguration::InputCollection> L1TMuonProducer::m_barrelTfInputToken

private

Definition at line 124 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer(), and produce().

std::bitset<12> L1TMuonProducer::m_bmtfInputsToDisable

private

Definition at line 105 of file L1TMuonProducer.cc.

Referenced by beginRun(), and produce().

int L1TMuonProducer::m_bxMax

private

Definition at line 101 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer(), and produce().

int L1TMuonProducer::m_bxMin

private

Definition at line 100 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer(), and produce().

std::bitset<28> L1TMuonProducer::m_caloInputsToDisable

private

Definition at line 104 of file L1TMuonProducer.cc.

Referenced by beginRun(), and produce().

edm::EDGetTokenT<MicroGMTConfiguration::CaloInputCollection> L1TMuonProducer::m_caloTowerInputToken

private

Definition at line 127 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer(), and produce().

MicroGMTCancelOutUnit L1TMuonProducer::m_cancelOutUnit

private

Definition at line 120 of file L1TMuonProducer.cc.

Referenced by beginRun(), and produce().

std::ofstream L1TMuonProducer::m_debugOut

private

Definition at line 121 of file L1TMuonProducer.cc.

Referenced by produce(), and ~L1TMuonProducer().

l1t::cancelmode L1TMuonProducer::m_emtfCancelMode

private

Definition at line 122 of file L1TMuonProducer.cc.

Referenced by beginRun(), L1TMuonProducer(), and produce().

std::bitset<12> L1TMuonProducer::m_emtfInputsToDisable

private

Definition at line 107 of file L1TMuonProducer.cc.

Referenced by beginRun(), and produce().

edm::InputTag L1TMuonProducer::m_endcapTfInputTag

private

Definition at line 116 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer().

edm::EDGetTokenT<MicroGMTConfiguration::InputCollection> L1TMuonProducer::m_endcapTfInputToken

private

Definition at line 126 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer(), and produce().

std::bitset<72> L1TMuonProducer::m_inputsToDisable

private

Definition at line 103 of file L1TMuonProducer.cc.

Referenced by beginRun(), convertMuons(), and splitAndConvertMuons().

MicroGMTIsolationUnit L1TMuonProducer::m_isolationUnit

private

Definition at line 119 of file L1TMuonProducer.cc.

Referenced by beginRun(), and produce().

std::bitset<12> L1TMuonProducer::m_maskedBmtfInputs

private

Definition at line 110 of file L1TMuonProducer.cc.

Referenced by beginRun(), and produce().

std::bitset<28> L1TMuonProducer::m_maskedCaloInputs

private

Definition at line 109 of file L1TMuonProducer.cc.

Referenced by beginRun(), and produce().

std::bitset<12> L1TMuonProducer::m_maskedEmtfInputs

private

Definition at line 112 of file L1TMuonProducer.cc.

Referenced by beginRun(), and produce().

std::bitset<72> L1TMuonProducer::m_maskedInputs

private

Definition at line 108 of file L1TMuonProducer.cc.

Referenced by beginRun(), convertMuons(), and splitAndConvertMuons().

std::bitset<12> L1TMuonProducer::m_maskedOmtfInputs

private

Definition at line 111 of file L1TMuonProducer.cc.

Referenced by beginRun(), and produce().

std::bitset<12> L1TMuonProducer::m_omtfInputsToDisable

private

Definition at line 106 of file L1TMuonProducer.cc.

Referenced by beginRun(), and produce().

edm::InputTag L1TMuonProducer::m_overlapTfInputTag

private

Definition at line 115 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer().

edm::EDGetTokenT<MicroGMTConfiguration::InputCollection> L1TMuonProducer::m_overlapTfInputToken

private

Definition at line 125 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer(), and produce().

std::shared_ptr<MicroGMTRankPtQualLUT> L1TMuonProducer::m_rankPtQualityLUT

private

Definition at line 118 of file L1TMuonProducer.cc.

Referenced by beginRun(), and calculateRank().

edm::InputTag L1TMuonProducer::m_trigTowerTag

private

Definition at line 117 of file L1TMuonProducer.cc.

Referenced by L1TMuonProducer().

std::unique_ptr<L1TMuonGlobalParamsHelper> L1TMuonProducer::microGMTParamsHelper

private

Definition at line 113 of file L1TMuonProducer.cc.

Referenced by beginRun().