HLTL1TSeed Class Reference

#include <HLTL1TSeed.h>

Inheritance diagram for HLTL1TSeed:

Public Member Functions
bool	hltFilter (edm::Event &, const edm::EventSetup &, trigger::TriggerFilterObjectWithRefs &filterproduct) override
	filter the event More...
	HLTL1TSeed (const edm::ParameterSet &)
	constructor More...
	~HLTL1TSeed () override
	destructor More...
Public Member Functions inherited from HLTStreamFilter
	HLTStreamFilter (const edm::ParameterSet &config)
int	module (edm::Event const &) const
const std::string *	moduleLabel () const
int	path (edm::Event const &) const
const std::string *	pathName (edm::Event const &) const
std::pair< int, int >	pmid (edm::Event const &) const
bool	saveTags () const
	~HLTStreamFilter () override
Public Member Functions inherited from edm::stream::EDFilter<>
	EDFilter ()=default
	EDFilter (const EDFilter &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDFilter &	operator= (const EDFilter &)=delete
Public Member Functions inherited from edm::stream::EDFilterBase
	EDFilterBase ()
	EDFilterBase (const EDFilterBase &)=delete
ModuleDescription const &	moduleDescription () const
const EDFilterBase &	operator= (const EDFilterBase &)=delete
	~EDFilterBase () override
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 ()
std::vector < edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const
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, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
	~ProducerBase () noexcept(false) override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
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::array< std::vector< ModuleDescription const * > *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
	parameter description More...
Static Public Member Functions inherited from HLTStreamFilter
static void	makeHLTFilterDescription (edm::ParameterSetDescription &desc)
Static Public Member Functions inherited from edm::stream::EDFilterBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	dumpTriggerFilterObjectWithRefs (trigger::TriggerFilterObjectWithRefs &) const
	detailed print of filter content More...
bool	seedsL1TriggerObjectMaps (edm::Event &, trigger::TriggerFilterObjectWithRefs &)
	seeding is done via L1 trigger object maps, considering the objects which fired in L1 More...
void	updateAlgoLogicParser (const L1GtTriggerMenu *, const AlgorithmMap &)
void	updateAlgoLogicParser (const std::vector< bool > &gtWord, const std::vector< unsigned int > &triggerMask, const int physicsDaqPartition)

Private Attributes
bool	m_isDebugEnabled
	cache edm::isDebugEnabled() More...
GlobalLogicParser	m_l1AlgoLogicParser
	logic parser for m_l1SeedsLogicalExpression More...
std::vector < GlobalLogicParser::OperandToken >	m_l1AlgoSeeds
	list of required algorithms for seeding More...
std::vector< std::vector < const std::vector < l1t::GlobalObject > * > >	m_l1AlgoSeedsObjType
	vector of object-type vectors for each condition in the required algorithms for seeding More...
std::vector< const std::vector < GlobalLogicParser::TokenRPN > * >	m_l1AlgoSeedsRpn
	vector of Rpn vectors for the required algorithms for seeding More...
edm::InputTag	m_l1EGammaCollectionsTag
	Meta InputTag for L1 Egamma collection. More...
edm::InputTag	m_l1EGammaTag
edm::EDGetTokenT < l1t::EGammaBxCollection >	m_l1EGammaToken
edm::InputTag	m_l1EtSumCollectionsTag
	Meta InputTag for L1 Egamma collection. More...
edm::InputTag	m_l1EtSumTag
edm::EDGetTokenT < l1t::EtSumBxCollection >	m_l1EtSumToken
bool	m_l1GlobalDecision
	flag to pass if L1TGlobal accept More...
edm::InputTag	m_l1GlobalTag
	InputTag for L1 Global Trigger. More...
edm::EDGetTokenT < GlobalAlgBlkBxCollection >	m_l1GlobalToken
edm::InputTag	m_l1GtObjectMapTag
	InputTag for L1 Global Trigger object maps. This is done per menu. Should be part of Run. More...
edm::EDGetTokenT < GlobalObjectMapRecord >	m_l1GtObjectMapToken
edm::InputTag	m_l1JetCollectionsTag
	Meta InputTag for L1 Egamma collection. More...
edm::InputTag	m_l1JetTag
edm::EDGetTokenT < l1t::JetBxCollection >	m_l1JetToken
edm::InputTag	m_l1MuonCollectionsTag
	Meta InputTag for L1 Muon collection. More...
edm::InputTag	m_l1MuonTag
edm::EDGetTokenT < l1t::MuonBxCollection >	m_l1MuonToken
int	m_l1NrBxInEvent
std::string	m_l1SeedsLogicalExpression
edm::InputTag	m_l1TauCollectionsTag
	Meta InputTag for L1 Egamma collection. More...
edm::InputTag	m_l1TauTag
edm::EDGetTokenT < l1t::TauBxCollection >	m_l1TauToken

Additional Inherited Members
Public Types inherited from edm::stream::EDFilter<>
using	CacheTypes = CacheContexts< T...>
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T...>
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache
Public Types inherited from edm::stream::EDFilterBase
typedef EDFilterAdaptorBase	ModuleType
Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex >>
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
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)
void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: filter L1 bits and extract seed objects from L1 GT for HLT algorithms.

Implementation: This class is an HLTStreamFilter (-> stream::EDFilter). It implements:

• filtering on Level-1 bits, given via a logical expression of algorithm names (currently ignored)
• extraction of the seed objects from L1T uGT object map record

Definition at line 46 of file HLTL1TSeed.h.

Constructor & Destructor Documentation

HLTL1TSeed::HLTL1TSeed ( const edm::ParameterSet &  parSet )

explicit

constructor

Definition at line 32 of file HLTL1TSeed.cc.

References Exception, GlobalLogicParser::expressionSeedsOperandList(), m_l1AlgoLogicParser, m_l1AlgoSeeds, m_l1AlgoSeedsObjType, m_l1AlgoSeedsRpn, m_l1GlobalDecision, m_l1SeedsLogicalExpression, GlobalLogicParser::operandTokenVector(), and findQualityFiles::size.

    : HLTStreamFilter(parSet),
      //useObjectMaps_(parSet.getParameter<bool>("L1UseL1TriggerObjectMaps")),
      m_l1SeedsLogicalExpression(parSet.getParameter<string>("L1SeedsLogicalExpression")),
      m_l1GtObjectMapTag(parSet.getParameter<edm::InputTag>("L1ObjectMapInputTag")),
      m_l1GtObjectMapToken(consumes<GlobalObjectMapRecord>(m_l1GtObjectMapTag)),
      m_l1GlobalTag(parSet.getParameter<edm::InputTag>("L1GlobalInputTag")),
      m_l1GlobalToken(consumes<GlobalAlgBlkBxCollection>(m_l1GlobalTag)),
      m_l1MuonCollectionsTag(parSet.getParameter<edm::InputTag>("L1MuonInputTag")),  // FIX WHEN UNPACKERS ADDED
      m_l1MuonTag(m_l1MuonCollectionsTag),
      m_l1MuonToken(consumes<l1t::MuonBxCollection>(m_l1MuonTag)),
      m_l1EGammaCollectionsTag(parSet.getParameter<edm::InputTag>("L1EGammaInputTag")),  // FIX WHEN UNPACKERS ADDED
      m_l1EGammaTag(m_l1EGammaCollectionsTag),
      m_l1EGammaToken(consumes<l1t::EGammaBxCollection>(m_l1EGammaTag)),
      m_l1JetCollectionsTag(parSet.getParameter<edm::InputTag>("L1JetInputTag")),  // FIX WHEN UNPACKERS ADDED
      m_l1JetTag(m_l1JetCollectionsTag),
      m_l1JetToken(consumes<l1t::JetBxCollection>(m_l1JetTag)),
      m_l1TauCollectionsTag(parSet.getParameter<edm::InputTag>("L1TauInputTag")),  // FIX WHEN UNPACKERS ADDED
      m_l1TauTag(m_l1TauCollectionsTag),
      m_l1TauToken(consumes<l1t::TauBxCollection>(m_l1TauTag)),
      m_l1EtSumCollectionsTag(parSet.getParameter<edm::InputTag>("L1EtSumInputTag")),  // FIX WHEN UNPACKERS ADDED
      m_l1EtSumTag(m_l1EtSumCollectionsTag),
      m_l1EtSumToken(consumes<l1t::EtSumBxCollection>(m_l1EtSumTag)),
      m_l1GlobalDecision(false),
      m_isDebugEnabled(edm::isDebugEnabled()) {
  if (m_l1SeedsLogicalExpression.empty()) {
    throw cms::Exception("FailModule") << "\nTrying to seed with an empty L1SeedsLogicalExpression.\n" << std::endl;

  } else if (m_l1SeedsLogicalExpression != "L1GlobalDecision") {
    // check also the logical expression - add/remove spaces if needed
    m_l1AlgoLogicParser = GlobalLogicParser(m_l1SeedsLogicalExpression);

    // list of required algorithms for seeding
    // dummy values for tokenNumber and tokenResult
    m_l1AlgoSeeds.reserve((m_l1AlgoLogicParser.operandTokenVector()).size());
    m_l1AlgoSeeds = m_l1AlgoLogicParser.expressionSeedsOperandList();
    size_t l1AlgoSeedsSize = m_l1AlgoSeeds.size();

    m_l1AlgoSeedsRpn.reserve(l1AlgoSeedsSize);
    m_l1AlgoSeedsObjType.reserve(l1AlgoSeedsSize);

  } else {
    m_l1GlobalDecision = true;
  }
}

HLTL1TSeed::~HLTL1TSeed ( )

override

destructor

Definition at line 79 of file HLTL1TSeed.cc.

                        {
  // empty now
}

Member Function Documentation

void HLTL1TSeed::dumpTriggerFilterObjectWithRefs ( trigger::TriggerFilterObjectWithRefs &  filterproduct ) const

private

detailed print of filter content

Definition at line 140 of file HLTL1TSeed.cc.

References trigger::TriggerRefsCollections::getObjects(), mps_fire::i, LogTrace, m_l1SeedsLogicalExpression, getGTfromDQMFile::obj, trigger::TriggerL1AsymEt, trigger::TriggerL1AsymEtHF, trigger::TriggerL1AsymHt, trigger::TriggerL1AsymHtHF, trigger::TriggerL1Centrality, trigger::TriggerL1EG, trigger::TriggerL1ETM, trigger::TriggerL1ETMHF, trigger::TriggerL1ETT, trigger::TriggerL1HTM, trigger::TriggerL1HTT, trigger::TriggerL1Jet, trigger::TriggerL1MinBiasHFM0, trigger::TriggerL1MinBiasHFM1, trigger::TriggerL1MinBiasHFP0, trigger::TriggerL1MinBiasHFP1, trigger::TriggerL1Mu, trigger::TriggerL1Tau, and trigger::TriggerL1TowerCount.

Referenced by hltFilter().

                                                                                                        {
  LogTrace("HLTL1TSeed") << "\nHLTL1TSeed::hltFilter "
                         << "\n  Dump TriggerFilterObjectWithRefs\n"
                         << endl;

  vector<l1t::MuonRef> seedsL1Mu;
  filterproduct.getObjects(trigger::TriggerL1Mu, seedsL1Mu);
  const size_t sizeSeedsL1Mu = seedsL1Mu.size();

  LogTrace("HLTL1TSeed") << "\n  HLTL1TSeed: seed logical expression = " << m_l1SeedsLogicalExpression << endl;

  LogTrace("HLTL1TSeed") << "\n  L1Mu seeds:      " << sizeSeedsL1Mu << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1Mu; i++) {
    l1t::MuonRef obj = l1t::MuonRef(seedsL1Mu[i]);

    LogTrace("HLTL1TSeed") << "\tL1Mu     "
                           << "\t"
                           << "q = "
                           << obj->hwCharge()  // TEMP get hwCharge insead of charge which is not yet set NEED FIX.
                           << "\t"
                           << "pt = " << obj->pt() << "\t"
                           << "eta =  " << obj->eta() << "\t"
                           << "phi =  " << obj->phi();  //<< "\t" << "BX = " << obj->bx();
  }

  vector<l1t::EGammaRef> seedsL1EG;
  filterproduct.getObjects(trigger::TriggerL1EG, seedsL1EG);
  const size_t sizeSeedsL1EG = seedsL1EG.size();

  LogTrace("HLTL1TSeed") << "\n  L1EG seeds:      " << sizeSeedsL1EG << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EG; i++) {
    l1t::EGammaRef obj = l1t::EGammaRef(seedsL1EG[i]);

    LogTrace("HLTL1TSeed") << "\tL1EG     "
                           << "\t"
                           << "pt = " << obj->pt() << "\t"
                           << "eta =  " << obj->eta() << "\t"
                           << "phi =  " << obj->phi();  //<< "\t" << "BX = " << obj->bx();
  }

  vector<l1t::JetRef> seedsL1Jet;
  filterproduct.getObjects(trigger::TriggerL1Jet, seedsL1Jet);
  const size_t sizeSeedsL1Jet = seedsL1Jet.size();

  LogTrace("HLTL1TSeed") << "\n  L1Jet seeds:      " << sizeSeedsL1Jet << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1Jet; i++) {
    l1t::JetRef obj = l1t::JetRef(seedsL1Jet[i]);

    LogTrace("HLTL1TSeed") << "\tL1Jet     "
                           << "\t"
                           << "pt = " << obj->pt() << "\t"
                           << "eta =  " << obj->eta() << "\t"
                           << "phi =  " << obj->phi();  //<< "\t" << "BX = " << obj->bx();
  }

  vector<l1t::TauRef> seedsL1Tau;
  filterproduct.getObjects(trigger::TriggerL1Tau, seedsL1Tau);
  const size_t sizeSeedsL1Tau = seedsL1Tau.size();

  LogTrace("HLTL1TSeed") << "\n  L1Tau seeds:      " << sizeSeedsL1Tau << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1Tau; i++) {
    l1t::TauRef obj = l1t::TauRef(seedsL1Tau[i]);

    LogTrace("HLTL1TSeed") << "\tL1Tau     "
                           << "\t"
                           << "pt = " << obj->pt() << "\t"
                           << "eta =  " << obj->eta() << "\t"
                           << "phi =  " << obj->phi();  //<< "\t" << "BX = " << obj->bx();
  }

  vector<l1t::EtSumRef> seedsL1EtSumETT;
  filterproduct.getObjects(trigger::TriggerL1ETT, seedsL1EtSumETT);
  const size_t sizeSeedsL1EtSumETT = seedsL1EtSumETT.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum ETT seeds:      " << sizeSeedsL1EtSumETT << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumETT; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumETT[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  ETT"
                           << "\t"
                           << "pt = " << obj->pt() << "\t"
                           << "eta =  " << obj->eta() << "\t"
                           << "phi =  " << obj->phi();  //<< "\t" << "BX = " << obj->bx();
  }

  vector<l1t::EtSumRef> seedsL1EtSumHTT;
  filterproduct.getObjects(trigger::TriggerL1HTT, seedsL1EtSumHTT);
  const size_t sizeSeedsL1EtSumHTT = seedsL1EtSumHTT.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum HTT seeds:      " << sizeSeedsL1EtSumHTT << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumHTT; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumHTT[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  HTT"
                           << "\t"
                           << "pt = " << obj->pt() << "\t"
                           << "eta =  " << obj->eta() << "\t"
                           << "phi =  " << obj->phi();  //<< "\t" << "BX = " << obj->bx();
  }

  vector<l1t::EtSumRef> seedsL1EtSumETM;
  filterproduct.getObjects(trigger::TriggerL1ETM, seedsL1EtSumETM);
  const size_t sizeSeedsL1EtSumETM = seedsL1EtSumETM.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum ETM seeds:      " << sizeSeedsL1EtSumETM << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumETM; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumETM[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  ETM"
                           << "\t"
                           << "pt = " << obj->pt() << "\t"
                           << "eta =  " << obj->eta() << "\t"
                           << "phi =  " << obj->phi();  //<< "\t" << "BX = " << obj->bx();
  }

  vector<l1t::EtSumRef> seedsL1EtSumETMHF;
  filterproduct.getObjects(trigger::TriggerL1ETMHF, seedsL1EtSumETMHF);
  const size_t sizeSeedsL1EtSumETMHF = seedsL1EtSumETMHF.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum ETMHF seeds:      " << sizeSeedsL1EtSumETMHF << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumETMHF; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumETMHF[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  ETMHF"
                           << "\t"
                           << "pt = " << obj->pt() << "\t"
                           << "eta =  " << obj->eta() << "\t"
                           << "phi =  " << obj->phi();  //<< "\t" << "BX = " << obj->bx();
  }

  vector<l1t::EtSumRef> seedsL1EtSumHTM;
  filterproduct.getObjects(trigger::TriggerL1HTM, seedsL1EtSumHTM);
  const size_t sizeSeedsL1EtSumHTM = seedsL1EtSumHTM.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum HTM seeds:      " << sizeSeedsL1EtSumHTM << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumHTM; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumHTM[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  HTM"
                           << "\t"
                           << "pt = " << obj->pt() << "\t"
                           << "eta =  " << obj->eta() << "\t"
                           << "phi =  " << obj->phi();  //<< "\t" << "BX = " << obj->bx();
  }

  vector<l1t::EtSumRef> seedsL1EtSumCentrality;
  filterproduct.getObjects(trigger::TriggerL1Centrality, seedsL1EtSumCentrality);
  const size_t sizeSeedsL1EtSumCentrality = seedsL1EtSumCentrality.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum Centrality seeds:      " << sizeSeedsL1EtSumCentrality << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumCentrality; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumCentrality[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  Centrality Bits: " << std::bitset<8>(obj->hwPt())
                           << " (hwPt = " << obj->hwPt() << ")";
  }

  vector<l1t::EtSumRef> seedsL1EtSumMinBiasHFP0;
  filterproduct.getObjects(trigger::TriggerL1MinBiasHFP0, seedsL1EtSumMinBiasHFP0);
  const size_t sizeSeedsL1EtSumMinBiasHFP0 = seedsL1EtSumMinBiasHFP0.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum MinBiasHFP0 seeds:      " << sizeSeedsL1EtSumMinBiasHFP0 << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumMinBiasHFP0; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumMinBiasHFP0[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  MinBiasHFP0: hwPt = " << obj->hwPt();
  }

  vector<l1t::EtSumRef> seedsL1EtSumMinBiasHFM0;
  filterproduct.getObjects(trigger::TriggerL1MinBiasHFM0, seedsL1EtSumMinBiasHFM0);
  const size_t sizeSeedsL1EtSumMinBiasHFM0 = seedsL1EtSumMinBiasHFM0.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum MinBiasHFM0 seeds:      " << sizeSeedsL1EtSumMinBiasHFM0 << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumMinBiasHFM0; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumMinBiasHFM0[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  MinBiasHFM0: hwPt = " << obj->hwPt();
  }

  vector<l1t::EtSumRef> seedsL1EtSumMinBiasHFP1;
  filterproduct.getObjects(trigger::TriggerL1MinBiasHFP1, seedsL1EtSumMinBiasHFP1);
  const size_t sizeSeedsL1EtSumMinBiasHFP1 = seedsL1EtSumMinBiasHFP1.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum MinBiasHFP1 seeds:      " << sizeSeedsL1EtSumMinBiasHFP1 << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumMinBiasHFP1; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumMinBiasHFP1[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  MinBiasHFP1: hwPt = " << obj->hwPt();
  }

  vector<l1t::EtSumRef> seedsL1EtSumMinBiasHFM1;
  filterproduct.getObjects(trigger::TriggerL1MinBiasHFM1, seedsL1EtSumMinBiasHFM1);
  const size_t sizeSeedsL1EtSumMinBiasHFM1 = seedsL1EtSumMinBiasHFM1.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum MinBiasHFM1 seeds:      " << sizeSeedsL1EtSumMinBiasHFM1 << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumMinBiasHFM1; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumMinBiasHFM1[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  MinBiasHFM1: hwPt = " << obj->hwPt();
  }

  vector<l1t::EtSumRef> seedsL1EtSumTowerCount;
  filterproduct.getObjects(trigger::TriggerL1TowerCount, seedsL1EtSumTowerCount);
  const size_t sizeSeedsL1EtSumTowerCount = seedsL1EtSumTowerCount.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum TowerCount seeds:      " << sizeSeedsL1EtSumTowerCount << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumTowerCount; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumTowerCount[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  TowerCount: hwPt = " << obj->hwPt();
  }

  vector<l1t::EtSumRef> seedsL1EtSumAsymEt;
  filterproduct.getObjects(trigger::TriggerL1AsymEt, seedsL1EtSumAsymEt);
  const size_t sizeSeedsL1EtSumAsymEt = seedsL1EtSumAsymEt.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum AsymEt seeds:      " << sizeSeedsL1EtSumAsymEt << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumAsymEt; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumAsymEt[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  AsymEt: hwPt = " << obj->hwPt();
  }

  vector<l1t::EtSumRef> seedsL1EtSumAsymHt;
  filterproduct.getObjects(trigger::TriggerL1AsymHt, seedsL1EtSumAsymHt);
  const size_t sizeSeedsL1EtSumAsymHt = seedsL1EtSumAsymHt.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum AsymHt seeds:      " << sizeSeedsL1EtSumAsymHt << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumAsymHt; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumAsymHt[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  AsymHt: hwPt = " << obj->hwPt();
  }

  vector<l1t::EtSumRef> seedsL1EtSumAsymEtHF;
  filterproduct.getObjects(trigger::TriggerL1AsymEtHF, seedsL1EtSumAsymEtHF);
  const size_t sizeSeedsL1EtSumAsymEtHF = seedsL1EtSumAsymEtHF.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum AsymEtHF seeds:      " << sizeSeedsL1EtSumAsymEtHF << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumAsymEtHF; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumAsymEtHF[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  AsymEtHF: hwPt = " << obj->hwPt();
  }

  vector<l1t::EtSumRef> seedsL1EtSumAsymHtHF;
  filterproduct.getObjects(trigger::TriggerL1AsymHtHF, seedsL1EtSumAsymHtHF);
  const size_t sizeSeedsL1EtSumAsymHtHF = seedsL1EtSumAsymHtHF.size();
  LogTrace("HLTL1TSeed") << "\n  L1EtSum AsymHtHF seeds:      " << sizeSeedsL1EtSumAsymHtHF << endl << endl;

  for (size_t i = 0; i != sizeSeedsL1EtSumAsymHtHF; i++) {
    l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumAsymHtHF[i]);

    LogTrace("HLTL1TSeed") << "\tL1EtSum  AsymHtHF: hwPt = " << obj->hwPt();
  }

  LogTrace("HLTL1TSeed") << " \n\n" << endl;
}

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

static

parameter description

Definition at line 85 of file HLTL1TSeed.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and HLTStreamFilter::makeHLTFilterDescription().

                                                                            {
  edm::ParameterSetDescription desc;
  makeHLTFilterDescription(desc);

  // # logical expression for the required L1 algorithms;
  // # the algorithms are specified by name
  // # allowed operators: "AND", "OR", "NOT", "(", ")"
  // #
  // # by convention, "L1GlobalDecision" logical expression means global decision
  desc.add<string>("L1SeedsLogicalExpression", "");
  desc.add<edm::InputTag>("L1ObjectMapInputTag", edm::InputTag("hltGtStage2ObjectMap"));
  desc.add<edm::InputTag>("L1GlobalInputTag", edm::InputTag("hltGtStage2Digis"));
  desc.add<edm::InputTag>("L1MuonInputTag", edm::InputTag("hltGmtStage2Digis:Muon"));
  desc.add<edm::InputTag>("L1EGammaInputTag", edm::InputTag("hltCaloStage2Digis:EGamma"));
  desc.add<edm::InputTag>("L1JetInputTag", edm::InputTag("hltCaloStage2Digis:Jet"));
  desc.add<edm::InputTag>("L1TauInputTag", edm::InputTag("hltCaloStage2Digis:Tau"));
  desc.add<edm::InputTag>("L1EtSumInputTag", edm::InputTag("hltCaloStage2Digis:EtSum"));
  descriptions.add("hltL1TSeed", desc);
}

bool HLTL1TSeed::hltFilter ( edm::Event &  iEvent, const edm::EventSetup &  evSetup, trigger::TriggerFilterObjectWithRefs &  filterproduct  )

overridevirtual

filter the event

Implements HLTStreamFilter.

Definition at line 105 of file HLTL1TSeed.cc.

References trigger::TriggerFilterObjectWithRefs::addCollectionTag(), dumpTriggerFilterObjectWithRefs(), m_isDebugEnabled, m_l1EGammaTag, m_l1EtSumTag, m_l1JetTag, m_l1MuonTag, m_l1TauTag, HLTStreamFilter::saveTags(), and seedsL1TriggerObjectMaps().

                                                                              {
  bool rc = false;

  // the filter object
  if (saveTags()) {
    // muons
    filterproduct.addCollectionTag(m_l1MuonTag);

    // egamma
    filterproduct.addCollectionTag(m_l1EGammaTag);

    // jet
    filterproduct.addCollectionTag(m_l1JetTag);

    // tau
    filterproduct.addCollectionTag(m_l1TauTag);

    // etsum
    filterproduct.addCollectionTag(m_l1EtSumTag);
  }

  // Get all the seeding from iEvent (i.e. L1TriggerObjectMapRecord)
  //
  rc = seedsL1TriggerObjectMaps(iEvent, filterproduct);

  if (m_isDebugEnabled) {
    dumpTriggerFilterObjectWithRefs(filterproduct);
  }

  return rc;
}

bool HLTL1TSeed::seedsL1TriggerObjectMaps ( edm::Event &  iEvent, trigger::TriggerFilterObjectWithRefs &  filterproduct  )

private

seeding is done via L1 trigger object maps, considering the objects which fired in L1

Loop over the list of required algorithms for seeding /////////////////////////////////////////////////////

Unpacked GT result of algorithm is false after masks and prescales - no seeds ////////////////////////////////////////////////////////////////////////////////

Emulated GT result of algorithm is false - no seeds - but still save the event

Definition at line 404 of file HLTL1TSeed.cc.

References trigger::TriggerRefsCollections::addObject(), GlobalObjectMap::algoBitNumber(), GlobalObjectMap::algoGtlResult(), GlobalObjectMap::algoName(), cms::cuda::assert(), GlobalObjectMap::combinationVector(), HLT_FULL_cff::distance, Exception, GlobalLogicParser::expressionResult(), edm::Event::getByToken(), GlobalObjectMap::getCombinationsInCond(), l1t::gtAsymmetryEt, l1t::gtAsymmetryEtHF, l1t::gtAsymmetryHt, l1t::gtAsymmetryHtHF, l1t::gtCentrality0, l1t::gtCentrality1, l1t::gtCentrality2, l1t::gtCentrality3, l1t::gtCentrality4, l1t::gtCentrality5, l1t::gtCentrality6, l1t::gtCentrality7, l1t::gtEG, l1t::gtETM, l1t::gtETMHF, l1t::gtETT, l1t::gtETTem, l1t::gtHTM, l1t::gtHTT, l1t::gtJet, l1t::gtMinBiasHFM0, l1t::gtMinBiasHFM1, l1t::gtMinBiasHFP0, l1t::gtMinBiasHFP1, l1t::gtMu, l1t::gtTau, l1t::gtTowerCount, mps_fire::i, edm::HandleBase::isValid(), fwrapper::jets, l1t::EtSum::kAsymEt, l1t::EtSum::kAsymEtHF, l1t::EtSum::kAsymHt, l1t::EtSum::kAsymHtHF, l1t::EtSum::kCentrality, l1t::EtSum::kMinBiasHFM0, l1t::EtSum::kMinBiasHFM1, l1t::EtSum::kMinBiasHFP0, l1t::EtSum::kMinBiasHFP1, l1t::EtSum::kMissingEt, l1t::EtSum::kMissingEtHF, l1t::EtSum::kMissingHt, l1t::EtSum::kTotalEt, l1t::EtSum::kTotalEtEm, l1t::EtSum::kTotalHt, l1t::EtSum::kTowerCount, LogTrace, m_isDebugEnabled, m_l1AlgoLogicParser, m_l1AlgoSeeds, m_l1EGammaTag, m_l1EGammaToken, m_l1EtSumTag, m_l1EtSumToken, m_l1GlobalDecision, m_l1GlobalTag, m_l1GlobalToken, m_l1GtObjectMapTag, m_l1GtObjectMapToken, m_l1JetTag, m_l1JetToken, m_l1MuonTag, m_l1MuonToken, m_l1SeedsLogicalExpression, m_l1TauTag, m_l1TauToken, patZpeak::muons, GlobalObjectMap::objectTypeVector(), GlobalObjectMap::operandTokenVector(), GlobalLogicParser::operandTokenVector(), AlCaHLTBitMon_QueryRunRegistry::string, runTauDisplay::taus, trigger::TriggerL1AsymEt, trigger::TriggerL1AsymEtHF, trigger::TriggerL1AsymHt, trigger::TriggerL1AsymHtHF, trigger::TriggerL1Centrality, trigger::TriggerL1EG, trigger::TriggerL1ETM, trigger::TriggerL1ETMHF, trigger::TriggerL1ETT, trigger::TriggerL1HTM, trigger::TriggerL1HTT, trigger::TriggerL1Jet, trigger::TriggerL1MinBiasHFM0, trigger::TriggerL1MinBiasHFM1, trigger::TriggerL1MinBiasHFP0, trigger::TriggerL1MinBiasHFP1, trigger::TriggerL1Mu, trigger::TriggerL1Tau, trigger::TriggerL1TotalEtEm, and trigger::TriggerL1TowerCount.

Referenced by hltFilter().

                                                                                                             {
  // Two GT objects are obtained from the Event: (1) the unpacked GT and (2) the emulated GT.
  // Return value of the function is the score of seeding logical expression, evaluated using (1).
  // Seeding is performed (per l1_algo) if ACCEPT both in (1) and (2). Seed objects are identified
  // and only available from ObjectMaps created in (2).

  // define index lists for all particle types

  std::list<int> listMuon;

  std::list<int> listEG;

  std::list<int> listJet;
  std::list<int> listTau;

  std::list<int> listETM;
  std::list<int> listETT;
  std::list<int> listHTT;
  std::list<int> listHTM;
  std::list<int> listETMHF;

  std::list<int> listJetCounts;

  std::list<int> listCentrality;
  std::list<int> listMinBiasHFP0;
  std::list<int> listMinBiasHFM0;
  std::list<int> listMinBiasHFP1;
  std::list<int> listMinBiasHFM1;
  std::list<int> listTotalEtEm;
  std::list<int> listMissingEtHF;
  std::list<int> listTowerCount;
  std::list<int> listAsymEt;
  std::list<int> listAsymHt;
  std::list<int> listAsymEtHF;
  std::list<int> listAsymHtHF;

  // get handle to unpacked GT
  edm::Handle<GlobalAlgBlkBxCollection> uGtAlgoBlocks;
  iEvent.getByToken(m_l1GlobalToken, uGtAlgoBlocks);

  if (!uGtAlgoBlocks.isValid()) {
    edm::LogWarning("HLTL1TSeed") << " Warning: GlobalAlgBlkBxCollection with input tag " << m_l1GlobalTag
                                  << " requested in configuration, but not found in the event." << std::endl;

    return false;
  }

  // check size
  if (uGtAlgoBlocks->size() == 0) {
    edm::LogWarning("HLTL1TSeed") << " Warning: GlobalAlgBlkBxCollection with input tag " << m_l1GlobalTag
                                  << " is empty." << std::endl;

    return false;
  }

  // get handle to object maps from emulator (one object map per algorithm)
  edm::Handle<GlobalObjectMapRecord> gtObjectMapRecord;
  iEvent.getByToken(m_l1GtObjectMapToken, gtObjectMapRecord);

  if (!gtObjectMapRecord.isValid()) {
    edm::LogWarning("HLTL1TSeed") << " Warning: GlobalObjectMapRecord with input tag " << m_l1GtObjectMapTag
                                  << " requested in configuration, but not found in the event." << std::endl;

    return false;
  }

  if (m_isDebugEnabled) {
    const std::vector<GlobalObjectMap>& objMaps = gtObjectMapRecord->gtObjectMap();

    LogTrace("HLTL1TSeed") << "\nHLTL1Seed"
                           << "\n--------------------------------------------------------------------------------------"
                              "-------------------------------";

    LogTrace("HLTL1TSeed")
        << "\n\tAlgorithms in L1TriggerObjectMapRecord and GT results ( emulated | initial | prescaled | final ) "
        << endl;

    LogTrace("HLTL1TSeed") << "\n\tmap"
                           << "\tAlgoBit" << std::setw(40) << "algoName"
                           << "\t (emul|ini|pre|fin)" << endl;

    LogTrace("HLTL1TSeed") << "----------------------------------------------------------------------------------------"
                              "-----------------------------";

    for (size_t imap = 0; imap < objMaps.size(); imap++) {
      int bit = objMaps[imap].algoBitNumber();  //  same as bit from L1T Menu

      int emulDecision = objMaps[imap].algoGtlResult();

      // For bx=0 , get 0th AlgoBlock, so in BXvector at(bx=0,i=0)
      int initDecision = (uGtAlgoBlocks->at(0, 0)).getAlgoDecisionInitial(bit);
      int presDecision = (uGtAlgoBlocks->at(0, 0)).getAlgoDecisionInterm(bit);
      int finlDecision = (uGtAlgoBlocks->at(0, 0)).getAlgoDecisionFinal(bit);

      if (emulDecision != initDecision) {
        LogTrace("HLTL1TSeed") << "L1T decision (emulated vs. unpacked initial) is not the same:"
                               << "\n\tbit = " << std::setw(3) << bit << std::setw(40) << objMaps[imap].algoName()
                               << "\t emulated decision = " << emulDecision
                               << "\t unpacked initial decision = " << initDecision
                               << "\nThis should not happen. Include the L1TGtEmulCompare module in the sequence."
                               << endl;
      }

      LogTrace("HLTL1TSeed") << "\t" << std::setw(3) << imap << "\tbit = " << std::setw(3) << bit << std::setw(40)
                             << objMaps[imap].algoName() << "\t (  " << emulDecision << " | " << initDecision << " | "
                             << presDecision << " | " << finlDecision << " ) ";
    }
    LogTrace("HLTL1TSeed") << endl;
  }

  // Filter decision in case of "L1GlobalDecision" logical expression.
  // By convention, it means global decision.
  // /////////////////////////////////////////////////////////////////
  if (m_l1GlobalDecision) {
    // For bx=0 , get 0th AlgoBlock, so in BXvector at(bx=0,i=0)
    return (uGtAlgoBlocks->at(0, 0)).getFinalOR();
  }

  // Update/Reset m_l1AlgoLogicParser by reseting token result
  // /////////////////////////////////////////////////////////
  std::vector<GlobalLogicParser::OperandToken>& algOpTokenVector = m_l1AlgoLogicParser.operandTokenVector();

  for (auto& i : algOpTokenVector) {
    // rest token result
    //
    i.tokenResult = false;
  }

  // Update m_l1AlgoLogicParser and store emulator results for algOpTokens
  // /////////////////////////////////////////////////////////////////////
  for (auto& i : algOpTokenVector) {
    std::string algoName = i.tokenName;

    const GlobalObjectMap* objMap = gtObjectMapRecord->getObjectMap(algoName);

    if (objMap == nullptr) {
      throw cms::Exception("FailModule")
          << "\nAlgorithm " << algoName
          << ", requested as seed by a HLT path, cannot be matched to a L1 algo name in any GlobalObjectMap\n"
          << "Please check if algorithm " << algoName << " is present in the L1 menu\n"
          << std::endl;

    } else {
      //(algOpTokenVector[i]).tokenResult = objMap->algoGtlResult();

      int bit = objMap->algoBitNumber();
      bool finalAlgoDecision = (uGtAlgoBlocks->at(0, 0)).getAlgoDecisionFinal(bit);
      i.tokenResult = finalAlgoDecision;
    }
  }

  // Filter decision
  // ///////////////
  bool seedsResult = m_l1AlgoLogicParser.expressionResult();

  if (m_isDebugEnabled) {
    LogTrace("HLTL1TSeed") << "\nHLTL1TSeed: l1SeedsLogicalExpression (names) = '" << m_l1SeedsLogicalExpression << "'"
                           << "\n  Result for logical expression after update of algOpTokens: " << seedsResult << "\n"
                           << std::endl;
  }


  for (std::vector<GlobalLogicParser::OperandToken>::const_iterator itSeed = m_l1AlgoSeeds.begin();
       itSeed != m_l1AlgoSeeds.end();
       ++itSeed) {
    std::string algoSeedName = (*itSeed).tokenName;

    LogTrace("HLTL1TSeed") << "\n ----------------  algo seed name = " << algoSeedName << endl;

    const GlobalObjectMap* objMap = gtObjectMapRecord->getObjectMap(algoSeedName);

    if (objMap == nullptr) {
      // Should not get here
      //
      throw cms::Exception("FailModule")
          << "\nAlgorithm " << algoSeedName
          << ", requested as seed by a HLT path, cannot be matched to a L1 algo name in any GlobalObjectMap\n"
          << "Please check if algorithm " << algoSeedName << " is present in the L1 menu\n"
          << std::endl;
    }

    int algoSeedBitNumber = objMap->algoBitNumber();
    bool algoSeedResult = objMap->algoGtlResult();

    // unpacked GT results: uGtAlgoBlock has decisions initial, prescaled, and final after masks
    bool algoSeedResultMaskAndPresc = uGtAlgoBlocks->at(0, 0).getAlgoDecisionFinal(algoSeedBitNumber);

    LogTrace("HLTL1TSeed") << "\n\tAlgo seed " << algoSeedName << " result emulated | final = " << algoSeedResult
                           << " | " << algoSeedResultMaskAndPresc << endl;

    if (!algoSeedResultMaskAndPresc)
      continue;

    //  This should not happen if the emulated and unpacked GT are consistent
    if (!algoSeedResult)
      continue;

    const std::vector<GlobalLogicParser::OperandToken>& opTokenVecObjMap = objMap->operandTokenVector();
    const std::vector<L1TObjectTypeInCond>& condObjTypeVec = objMap->objectTypeVector();
    const std::vector<CombinationsInCond>& condCombinations = objMap->combinationVector();

    LogTrace("HLTL1TSeed") << "\n\talgoName =" << objMap->algoName() << "\talgoBitNumber = " << algoSeedBitNumber
                           << "\talgoGtlResult = " << algoSeedResult << endl
                           << endl;

    if (opTokenVecObjMap.size() != condObjTypeVec.size()) {
      edm::LogWarning("HLTL1TSeed")
          << "\nWarning: GlobalObjectMapRecord with input tag " << m_l1GtObjectMapTag
          << "\nhas object map for bit number " << algoSeedBitNumber
          << " which contains different size vectors of operand tokens and of condition object types!" << std::endl;

      assert(opTokenVecObjMap.size() == condObjTypeVec.size());
    }

    if (opTokenVecObjMap.size() != condCombinations.size()) {
      edm::LogWarning("HLTL1TSeed")
          << "\nWarning: GlobalObjectMapRecord with input tag " << m_l1GtObjectMapTag
          << "\nhas object map for bit number " << algoSeedBitNumber
          << " which contains different size vectors of operand tokens and of condition object combinations!"
          << std::endl;

      assert(opTokenVecObjMap.size() == condCombinations.size());
    }

    // operands are conditions of L1 algo
    //
    for (size_t condNumber = 0; condNumber < opTokenVecObjMap.size(); condNumber++) {
      std::vector<l1t::GlobalObject> condObjType = condObjTypeVec[condNumber];

      for (auto& jOb : condObjType) {
        LogTrace("HLTL1TSeed") << setw(15) << "\tcondObjType = " << jOb << endl;
      }

      const std::string condName = opTokenVecObjMap[condNumber].tokenName;
      bool condResult = opTokenVecObjMap[condNumber].tokenResult;

      // only procede for conditions that passed
      //
      if (!condResult) {
        continue;
      }

      // loop over combinations for a given condition
      //
      const CombinationsInCond* condComb = objMap->getCombinationsInCond(condNumber);

      LogTrace("HLTL1TSeed") << setw(15) << "\tcondCombinations = " << condComb->size() << endl;

      for (auto const& itComb : (*condComb)) {
        LogTrace("HLTL1TSeed") << setw(15) << "\tnew combination" << endl;

        // loop over objects in a combination for a given condition
        //
        for (auto itObject = itComb.begin(); itObject != itComb.end(); itObject++) {
          // in case of object-less triggers (e.g. L1_ZeroBias) condObjType vector is empty, so don't seed!
          //
          if (condObjType.empty()) {
            LogTrace("HLTL1TSeed")
                << "\talgoName = " << objMap->algoName()
                << " is object-less L1 algorithm, so do not attempt to store any objects to the list of seeds.\n"
                << std::endl;
            continue;
          }

          // the index of the object type is the same as the index of the object
          size_t iType = std::distance(itComb.begin(), itObject);

          // get object type and push indices on the list
          //
          const l1t::GlobalObject objTypeVal = condObjType.at(iType);

          LogTrace("HLTL1TSeed") << "\tAdd object of type " << objTypeVal << " and index " << (*itObject)
                                 << " to the seed list." << std::endl;

          // THESE OBJECT CASES ARE CURRENTLY MISSING:
          //gtMinBias,
          //gtExternal,
          //ObjNull

          switch (objTypeVal) {
            case l1t::gtMu: {
              listMuon.push_back(*itObject);
            }

            break;
            case l1t::gtEG: {
              listEG.push_back(*itObject);
            } break;
            case l1t::gtJet: {
              listJet.push_back(*itObject);
            } break;
            case l1t::gtTau: {
              listTau.push_back(*itObject);
            } break;
            case l1t::gtETM: {
              listETM.push_back(*itObject);
            } break;
            case l1t::gtETT: {
              listETT.push_back(*itObject);
            } break;
            case l1t::gtHTT: {
              listHTT.push_back(*itObject);
            } break;
            case l1t::gtHTM: {
              listHTM.push_back(*itObject);
            } break;
            case l1t::gtETMHF: {
              listETMHF.push_back(*itObject);
            } break;
            case l1t::gtTowerCount: {
              listTowerCount.push_back(*itObject);
            } break;
            case l1t::gtMinBiasHFP0: {
              listMinBiasHFP0.push_back(*itObject);
            } break;
            case l1t::gtMinBiasHFM0: {
              listMinBiasHFM0.push_back(*itObject);
            } break;
            case l1t::gtMinBiasHFP1: {
              listMinBiasHFP1.push_back(*itObject);
            } break;
            case l1t::gtMinBiasHFM1: {
              listMinBiasHFM1.push_back(*itObject);
            } break;
            case l1t::gtETTem: {
              listTotalEtEm.push_back(*itObject);
            } break;
            case l1t::gtAsymmetryEt: {
              listAsymEt.push_back(*itObject);
            } break;
            case l1t::gtAsymmetryHt: {
              listAsymHt.push_back(*itObject);
            } break;
            case l1t::gtAsymmetryEtHF: {
              listAsymEtHF.push_back(*itObject);
            } break;
            case l1t::gtAsymmetryHtHF: {
              listAsymHtHF.push_back(*itObject);
            } break;
            case l1t::gtCentrality0:
            case l1t::gtCentrality1:
            case l1t::gtCentrality2:
            case l1t::gtCentrality3:
            case l1t::gtCentrality4:
            case l1t::gtCentrality5:
            case l1t::gtCentrality6:
            case l1t::gtCentrality7: {
              listCentrality.push_back(*itObject);
            } break;

              //case JetCounts: {
              //    listJetCounts.push_back(*itObject);
              //}

              break;
            default: {
              // should not arrive here

              LogTrace("HLTL1TSeed") << "\n    HLTL1TSeed::hltFilter "
                                     << "\n      Unknown object of type " << objTypeVal << " and index " << (*itObject)
                                     << " in the seed list." << std::endl;
            } break;

          }  // end switch objTypeVal

        }  // end for itObj

      }  // end for itComb

    }  // end for condition

  }  // end for itSeed

  // eliminate duplicates

  listMuon.sort();
  listMuon.unique();

  listEG.sort();
  listEG.unique();

  listJet.sort();
  listJet.unique();

  listTau.sort();
  listTau.unique();

  listETM.sort();
  listETM.unique();

  listETT.sort();
  listETT.unique();

  listHTT.sort();
  listHTT.unique();

  listHTM.sort();
  listHTM.unique();

  listETMHF.sort();
  listETMHF.unique();

  listJetCounts.sort();
  listJetCounts.unique();

  listCentrality.sort();
  listCentrality.unique();

  listMinBiasHFP0.sort();
  listMinBiasHFP0.unique();

  listMinBiasHFM0.sort();
  listMinBiasHFM0.unique();

  listMinBiasHFP1.sort();
  listMinBiasHFP1.unique();

  listMinBiasHFM1.sort();
  listMinBiasHFM1.unique();

  listTotalEtEm.sort();
  listTotalEtEm.unique();

  listMissingEtHF.sort();
  listMissingEtHF.unique();

  listTowerCount.sort();
  listTowerCount.unique();

  listAsymEt.sort();
  listAsymEt.unique();

  listAsymHt.sort();
  listAsymHt.unique();

  listAsymEtHF.sort();
  listAsymEtHF.unique();

  listAsymHtHF.sort();
  listAsymHtHF.unique();

  // record the L1 physics objects in the HLT filterproduct
  // //////////////////////////////////////////////////////

  // Muon
  if (!listMuon.empty()) {
    edm::Handle<l1t::MuonBxCollection> muons;
    iEvent.getByToken(m_l1MuonToken, muons);

    if (!muons.isValid()) {
      edm::LogWarning("HLTL1TSeed") << "\nWarning: L1MuonBxCollection with input tag " << m_l1MuonTag
                                    << "\nrequested in configuration, but not found in the event."
                                    << "\nNo muons added to filterproduct." << endl;
    } else {
      for (std::list<int>::const_iterator itObj = listMuon.begin(); itObj != listMuon.end(); ++itObj) {
        // Transform to index for Bx = 0 to begin of BxVector
        unsigned int index = muons->begin(0) - muons->begin() + *itObj;

        l1t::MuonRef myref(muons, index);
        filterproduct.addObject(trigger::TriggerL1Mu, myref);
      }
    }
  }

  // EG (isolated)
  if (!listEG.empty()) {
    edm::Handle<l1t::EGammaBxCollection> egammas;
    iEvent.getByToken(m_l1EGammaToken, egammas);
    if (!egammas.isValid()) {
      edm::LogWarning("HLTL1TSeed") << "\nWarning: L1EGammaBxCollection with input tag " << m_l1EGammaTag
                                    << "\nrequested in configuration, but not found in the event."
                                    << "\nNo egammas added to filterproduct." << endl;
    } else {
      for (std::list<int>::const_iterator itObj = listEG.begin(); itObj != listEG.end(); ++itObj) {
        // Transform to begin of BxVector
        unsigned int index = egammas->begin(0) - egammas->begin() + *itObj;

        l1t::EGammaRef myref(egammas, index);
        filterproduct.addObject(trigger::TriggerL1EG, myref);
      }
    }
  }

  // Jet
  if (!listJet.empty()) {
    edm::Handle<l1t::JetBxCollection> jets;
    iEvent.getByToken(m_l1JetToken, jets);

    if (!jets.isValid()) {
      edm::LogWarning("HLTL1TSeed") << "\nWarning: L1JetBxCollection with input tag " << m_l1JetTag
                                    << "\nrequested in configuration, but not found in the event."
                                    << "\nNo jets added to filterproduct." << endl;
    } else {
      for (std::list<int>::const_iterator itObj = listJet.begin(); itObj != listJet.end(); ++itObj) {
        // Transform to begin of BxVector
        unsigned int index = jets->begin(0) - jets->begin() + *itObj;

        l1t::JetRef myref(jets, index);
        filterproduct.addObject(trigger::TriggerL1Jet, myref);
      }
    }
  }

  // Tau
  if (!listTau.empty()) {
    edm::Handle<l1t::TauBxCollection> taus;
    iEvent.getByToken(m_l1TauToken, taus);

    if (!taus.isValid()) {
      edm::LogWarning("HLTL1TSeed") << "\nWarning: L1TauBxCollection with input tag " << m_l1TauTag
                                    << "\nrequested in configuration, but not found in the event."
                                    << "\nNo taus added to filterproduct." << endl;
    } else {
      for (std::list<int>::const_iterator itObj = listTau.begin(); itObj != listTau.end(); ++itObj) {
        // Transform to begin of BxVector
        unsigned int index = taus->begin(0) - taus->begin() + *itObj;

        l1t::TauRef myref(taus, index);
        filterproduct.addObject(trigger::TriggerL1Tau, myref);
      }
    }
  }

  // ETT, HTT, ETM, HTM
  edm::Handle<l1t::EtSumBxCollection> etsums;
  iEvent.getByToken(m_l1EtSumToken, etsums);
  if (!etsums.isValid()) {
    edm::LogWarning("HLTL1TSeed") << "\nWarning: L1EtSumBxCollection with input tag " << m_l1EtSumTag
                                  << "\nrequested in configuration, but not found in the event."
                                  << "\nNo etsums added to filterproduct." << endl;
  } else {
    l1t::EtSumBxCollection::const_iterator iter;

    for (iter = etsums->begin(0); iter != etsums->end(0); ++iter) {
      l1t::EtSumRef myref(etsums, etsums->key(iter));

      switch (iter->getType()) {
        case l1t::EtSum::kTotalEt:
          if (!listETT.empty())
            filterproduct.addObject(trigger::TriggerL1ETT, myref);
          break;
        case l1t::EtSum::kTotalHt:
          if (!listHTT.empty())
            filterproduct.addObject(trigger::TriggerL1HTT, myref);
          break;
        case l1t::EtSum::kMissingEt:
          if (!listETM.empty())
            filterproduct.addObject(trigger::TriggerL1ETM, myref);
          break;
        case l1t::EtSum::kMissingHt:
          if (!listHTM.empty())
            filterproduct.addObject(trigger::TriggerL1HTM, myref);
          break;
        case l1t::EtSum::kMissingEtHF:
          if (!listETMHF.empty())
            filterproduct.addObject(trigger::TriggerL1ETMHF, myref);
          break;
        case l1t::EtSum::kCentrality:
          if (!listCentrality.empty())
            filterproduct.addObject(trigger::TriggerL1Centrality, myref);
          break;
        case l1t::EtSum::kMinBiasHFP0:
          if (!listMinBiasHFP0.empty())
            filterproduct.addObject(trigger::TriggerL1MinBiasHFP0, myref);
          break;
        case l1t::EtSum::kMinBiasHFM0:
          if (!listMinBiasHFM0.empty())
            filterproduct.addObject(trigger::TriggerL1MinBiasHFM0, myref);
          break;
        case l1t::EtSum::kMinBiasHFP1:
          if (!listMinBiasHFP1.empty())
            filterproduct.addObject(trigger::TriggerL1MinBiasHFP1, myref);
          break;
        case l1t::EtSum::kMinBiasHFM1:
          if (!listMinBiasHFM1.empty())
            filterproduct.addObject(trigger::TriggerL1MinBiasHFM1, myref);
          break;
        case l1t::EtSum::kTotalEtEm:
          if (!listTotalEtEm.empty())
            filterproduct.addObject(trigger::TriggerL1TotalEtEm, myref);
          break;
        case l1t::EtSum::kTowerCount:
          if (!listTowerCount.empty())
            filterproduct.addObject(trigger::TriggerL1TowerCount, myref);
          break;
        case l1t::EtSum::kAsymEt:
          if (!listAsymEt.empty())
            filterproduct.addObject(trigger::TriggerL1AsymEt, myref);
          break;
        case l1t::EtSum::kAsymHt:
          if (!listAsymHt.empty())
            filterproduct.addObject(trigger::TriggerL1AsymHt, myref);
          break;
        case l1t::EtSum::kAsymEtHF:
          if (!listAsymEtHF.empty())
            filterproduct.addObject(trigger::TriggerL1AsymEtHF, myref);
          break;
        case l1t::EtSum::kAsymHtHF:
          if (!listAsymHtHF.empty())
            filterproduct.addObject(trigger::TriggerL1AsymHtHF, myref);
          break;
        default:
          LogTrace("HLTL1TSeed") << "  L1EtSum seed of currently unsuported HLT TriggerType. l1t::EtSum type:      "
                                 << iter->getType() << "\n";

      }  // end switch

    }  // end for

  }  // end else

  // TODO FIXME uncomment if block when JetCounts implemented

  //    // jet counts
  //    if (!listJetCounts.empty()) {
  //        edm::Handle<l1extra::L1JetCounts> l1JetCounts;
  //        iEvent.getByToken(m_l1CollectionsToken.label(), l1JetCounts);
  //
  //        for (std::list<int>::const_iterator itObj = listJetCounts.begin();
  //                itObj != listJetCounts.end(); ++itObj) {
  //
  //            filterproduct.addObject(trigger::TriggerL1JetCounts,l1extra::L1JetCountsRefProd(l1JetCounts));
  //                  // FIXME: RefProd!
  //
  //        }
  //
  //    }

  LogTrace("HLTL1TSeed") << "\nHLTL1Seed:seedsL1TriggerObjectMaps returning " << seedsResult << endl << endl;

  return seedsResult;
}

void HLTL1TSeed::updateAlgoLogicParser ( const L1GtTriggerMenu *  , const AlgorithmMap &    )

inlineprivate

update the tokenNumber (holding the bit numbers) from m_l1AlgoLogicParser for a new L1 Trigger menu

Definition at line 63 of file HLTL1TSeed.h.

{};

void HLTL1TSeed::updateAlgoLogicParser ( const std::vector< bool > &  gtWord, const std::vector< unsigned int > &  triggerMask, const int  physicsDaqPartition  )

inlineprivate

update the tokenResult members from m_l1AlgoLogicParser for a new event

Definition at line 67 of file HLTL1TSeed.h.

                                                                  {};

Member Data Documentation

bool HLTL1TSeed::m_isDebugEnabled

private

cache edm::isDebugEnabled()

Definition at line 137 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

GlobalLogicParser HLTL1TSeed::m_l1AlgoLogicParser

private

logic parser for m_l1SeedsLogicalExpression

Definition at line 79 of file HLTL1TSeed.h.

Referenced by HLTL1TSeed(), and seedsL1TriggerObjectMaps().

std::vector<GlobalLogicParser::OperandToken> HLTL1TSeed::m_l1AlgoSeeds

private

list of required algorithms for seeding

Definition at line 82 of file HLTL1TSeed.h.

Referenced by HLTL1TSeed(), and seedsL1TriggerObjectMaps().

std::vector<std::vector<const std::vector<l1t::GlobalObject>*> > HLTL1TSeed::m_l1AlgoSeedsObjType

private

vector of object-type vectors for each condition in the required algorithms for seeding

Definition at line 88 of file HLTL1TSeed.h.

Referenced by HLTL1TSeed().

std::vector<const std::vector<GlobalLogicParser::TokenRPN>*> HLTL1TSeed::m_l1AlgoSeedsRpn

private

vector of Rpn vectors for the required algorithms for seeding

Definition at line 85 of file HLTL1TSeed.h.

Referenced by HLTL1TSeed().

edm::InputTag HLTL1TSeed::m_l1EGammaCollectionsTag

private

Meta InputTag for L1 Egamma collection.

Definition at line 114 of file HLTL1TSeed.h.

edm::InputTag HLTL1TSeed::m_l1EGammaTag

private

Definition at line 115 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1t::EGammaBxCollection> HLTL1TSeed::m_l1EGammaToken

private

Definition at line 116 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

edm::InputTag HLTL1TSeed::m_l1EtSumCollectionsTag

private

Meta InputTag for L1 Egamma collection.

Definition at line 129 of file HLTL1TSeed.h.

edm::InputTag HLTL1TSeed::m_l1EtSumTag

private

Definition at line 130 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1t::EtSumBxCollection> HLTL1TSeed::m_l1EtSumToken

private

Definition at line 131 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

bool HLTL1TSeed::m_l1GlobalDecision

private

flag to pass if L1TGlobal accept

Definition at line 134 of file HLTL1TSeed.h.

Referenced by HLTL1TSeed(), and seedsL1TriggerObjectMaps().

edm::InputTag HLTL1TSeed::m_l1GlobalTag

private

InputTag for L1 Global Trigger.

Definition at line 104 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

edm::EDGetTokenT<GlobalAlgBlkBxCollection> HLTL1TSeed::m_l1GlobalToken

private

Definition at line 105 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

edm::InputTag HLTL1TSeed::m_l1GtObjectMapTag

private

InputTag for L1 Global Trigger object maps. This is done per menu. Should be part of Run.

Definition at line 100 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

edm::EDGetTokenT<GlobalObjectMapRecord> HLTL1TSeed::m_l1GtObjectMapToken

private

Definition at line 101 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

edm::InputTag HLTL1TSeed::m_l1JetCollectionsTag

private

Meta InputTag for L1 Egamma collection.

Definition at line 119 of file HLTL1TSeed.h.

edm::InputTag HLTL1TSeed::m_l1JetTag

private

Definition at line 120 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1t::JetBxCollection> HLTL1TSeed::m_l1JetToken

private

Definition at line 121 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

edm::InputTag HLTL1TSeed::m_l1MuonCollectionsTag

private

Meta InputTag for L1 Muon collection.

Definition at line 109 of file HLTL1TSeed.h.

edm::InputTag HLTL1TSeed::m_l1MuonTag

private

Definition at line 110 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1t::MuonBxCollection> HLTL1TSeed::m_l1MuonToken

private

Definition at line 111 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

int HLTL1TSeed::m_l1NrBxInEvent

private

option used forL1UseL1TriggerObjectMaps = False only number of BxInEvent: 1: L1A=0; 3: -1, L1A=0, 1; 5: -2, -1, L1A=0, 1, 2

Definition at line 93 of file HLTL1TSeed.h.

std::string HLTL1TSeed::m_l1SeedsLogicalExpression

private

logical expression for the required L1 algorithms the algorithms are specified by name

Definition at line 97 of file HLTL1TSeed.h.

Referenced by dumpTriggerFilterObjectWithRefs(), HLTL1TSeed(), and seedsL1TriggerObjectMaps().

edm::InputTag HLTL1TSeed::m_l1TauCollectionsTag

private

Meta InputTag for L1 Egamma collection.

Definition at line 124 of file HLTL1TSeed.h.

edm::InputTag HLTL1TSeed::m_l1TauTag

private

Definition at line 125 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1t::TauBxCollection> HLTL1TSeed::m_l1TauToken

private

Definition at line 126 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().