#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

std::vector< bool > const &	recordProvenanceList () 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)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~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_l1MuonShowerCollectionsTag
	Meta InputTag for L1 Muon collection. More...

edm::InputTag	m_l1MuonShowerTag

edm::EDGetTokenT< l1t::MuonShowerBxCollection >	m_l1MuonShowerToken

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
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

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

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

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::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_l1MuonShowerCollectionsTag(
           parSet.getParameter<edm::InputTag>("L1MuonShowerInputTag")),  // FIX WHEN UNPACKERS ADDED
       m_l1MuonShowerTag(m_l1MuonShowerCollectionsTag),
       m_l1MuonShowerToken(consumes<l1t::MuonShowerBxCollection>(m_l1MuonShowerTag)),
       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::~HLTL1TSeed ( )

override

destructor

Definition at line 83 of file HLTL1TSeed.cc.

                         {
   // empty now
 }

Member Function Documentation

◆ dumpTriggerFilterObjectWithRefs()

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

private

detailed print of filter content

Definition at line 148 of file HLTL1TSeed.cc.

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::MuonShowerRef> seedsL1MuShower;
   filterproduct.getObjects(trigger::TriggerL1MuShower, seedsL1MuShower);
   const size_t sizeSeedsL1MuShower = seedsL1MuShower.size();
 
   LogTrace("HLTL1TSeed") << "\n  HLTL1TSeed: seed logical expression = " << m_l1SeedsLogicalExpression << endl;
 
   LogTrace("HLTL1TSeed") << "\n  L1MuShower seeds:      " << sizeSeedsL1MuShower << endl << endl;
 
   for (size_t i = 0; i != sizeSeedsL1MuShower; i++) {
     l1t::MuonShowerRef obj = l1t::MuonShowerRef(seedsL1MuShower[i]);
 
     LogTrace("HLTL1TSeed") << "\tL1MuShower     "
                            << "\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;
 }

◆ fillDescriptions()

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

static

parameter description

Definition at line 89 of file HLTL1TSeed.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_2022v12_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("hltGtStage2Digis:Muon"));
   desc.add<edm::InputTag>("L1MuonShowerInputTag", edm::InputTag("hltGtStage2Digis:MuonShower"));
   desc.add<edm::InputTag>("L1EGammaInputTag", edm::InputTag("hltGtStage2Digis:EGamma"));
   desc.add<edm::InputTag>("L1JetInputTag", edm::InputTag("hltGtStage2Digis:Jet"));
   desc.add<edm::InputTag>("L1TauInputTag", edm::InputTag("hltGtStage2Digis:Tau"));
   desc.add<edm::InputTag>("L1EtSumInputTag", edm::InputTag("hltGtStage2Digis:EtSum"));
   descriptions.add("hltL1TSeed", desc);
 }

◆ hltFilter()

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

overridevirtual

filter the event

Implements HLTStreamFilter.

Definition at line 110 of file HLTL1TSeed.cc.

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

                                                                               {
   bool rc = false;
 
   // the filter object
   if (saveTags()) {
     // muons
     filterproduct.addCollectionTag(m_l1MuonTag);
 
     // muon showers
     filterproduct.addCollectionTag(m_l1MuonShowerTag);
 
     // 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;
 }

◆ seedsL1TriggerObjectMaps()

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 430 of file HLTL1TSeed.cc.

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> listMuonShower;
 
   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::gtMuShower: {
               listMuonShower.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();
 
   listMuonShower.sort();
   listMuonShower.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);
       }
     }
   }
 
   // Muon Shower
   if (!listMuonShower.empty()) {
     edm::Handle<l1t::MuonShowerBxCollection> muonShowers;
     iEvent.getByToken(m_l1MuonShowerToken, muonShowers);
 
     if (!muonShowers.isValid()) {
       edm::LogWarning("HLTL1TSeed") << "\nWarning: L1MuonShowerBxCollection with input tag " << m_l1MuonShowerTag
                                     << "\nrequested in configuration, but not found in the event."
                                     << "\nNo muon showers added to filterproduct." << endl;
     } else {
       for (std::list<int>::const_iterator itObj = listMuonShower.begin(); itObj != listMuonShower.end(); ++itObj) {
         // Transform to index for Bx = 0 to begin of BxVector
         unsigned int index = muonShowers->begin(0) - muonShowers->begin() + *itObj;
 
         l1t::MuonShowerRef myref(muonShowers, index);
         filterproduct.addObject(trigger::TriggerL1MuShower, 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;
 }

◆ updateAlgoLogicParser() [1/2]

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.

63 {};

◆ updateAlgoLogicParser() [2/2]

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.

69 {};

Member Data Documentation

◆ m_isDebugEnabled

bool HLTL1TSeed::m_isDebugEnabled

private

cache edm::isDebugEnabled()

Definition at line 142 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

◆ m_l1AlgoLogicParser

GlobalLogicParser HLTL1TSeed::m_l1AlgoLogicParser

private

logic parser for m_l1SeedsLogicalExpression

Definition at line 79 of file HLTL1TSeed.h.

Referenced by HLTL1TSeed(), and seedsL1TriggerObjectMaps().

◆ m_l1AlgoSeeds

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

◆ m_l1AlgoSeedsObjType

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

◆ m_l1AlgoSeedsRpn

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

◆ m_l1EGammaCollectionsTag

edm::InputTag HLTL1TSeed::m_l1EGammaCollectionsTag

private

Meta InputTag for L1 Egamma collection.

Definition at line 119 of file HLTL1TSeed.h.

◆ m_l1EGammaTag

edm::InputTag HLTL1TSeed::m_l1EGammaTag

private

Definition at line 120 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

◆ m_l1EGammaToken

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

private

Definition at line 121 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

◆ m_l1EtSumCollectionsTag

edm::InputTag HLTL1TSeed::m_l1EtSumCollectionsTag

private

Meta InputTag for L1 Egamma collection.

Definition at line 134 of file HLTL1TSeed.h.

◆ m_l1EtSumTag

edm::InputTag HLTL1TSeed::m_l1EtSumTag

private

Definition at line 135 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

◆ m_l1EtSumToken

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

private

Definition at line 136 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

◆ m_l1GlobalDecision

bool HLTL1TSeed::m_l1GlobalDecision

private

flag to pass if L1TGlobal accept

Definition at line 139 of file HLTL1TSeed.h.

Referenced by HLTL1TSeed(), and seedsL1TriggerObjectMaps().

◆ m_l1GlobalTag

edm::InputTag HLTL1TSeed::m_l1GlobalTag

private

InputTag for L1 Global Trigger.

Definition at line 104 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

◆ m_l1GlobalToken

edm::EDGetTokenT<GlobalAlgBlkBxCollection> HLTL1TSeed::m_l1GlobalToken

private

Definition at line 105 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

◆ m_l1GtObjectMapTag

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

◆ m_l1GtObjectMapToken

edm::EDGetTokenT<GlobalObjectMapRecord> HLTL1TSeed::m_l1GtObjectMapToken

private

Definition at line 101 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

◆ m_l1JetCollectionsTag

edm::InputTag HLTL1TSeed::m_l1JetCollectionsTag

private

Meta InputTag for L1 Egamma collection.

Definition at line 124 of file HLTL1TSeed.h.

◆ m_l1JetTag

edm::InputTag HLTL1TSeed::m_l1JetTag

private

Definition at line 125 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

◆ m_l1JetToken

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

private

Definition at line 126 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

◆ m_l1MuonCollectionsTag

edm::InputTag HLTL1TSeed::m_l1MuonCollectionsTag

private

Meta InputTag for L1 Muon collection.

Definition at line 109 of file HLTL1TSeed.h.

◆ m_l1MuonShowerCollectionsTag

edm::InputTag HLTL1TSeed::m_l1MuonShowerCollectionsTag

private

Meta InputTag for L1 Muon collection.

Definition at line 114 of file HLTL1TSeed.h.

◆ m_l1MuonShowerTag

edm::InputTag HLTL1TSeed::m_l1MuonShowerTag

private

Definition at line 115 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

◆ m_l1MuonShowerToken

edm::EDGetTokenT<l1t::MuonShowerBxCollection> HLTL1TSeed::m_l1MuonShowerToken

private

Definition at line 116 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

◆ m_l1MuonTag

edm::InputTag HLTL1TSeed::m_l1MuonTag

private

Definition at line 110 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

◆ m_l1MuonToken

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

private

Definition at line 111 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

◆ m_l1NrBxInEvent

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.

◆ m_l1SeedsLogicalExpression

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

◆ m_l1TauCollectionsTag

edm::InputTag HLTL1TSeed::m_l1TauCollectionsTag

private

Meta InputTag for L1 Egamma collection.

Definition at line 129 of file HLTL1TSeed.h.

◆ m_l1TauTag

edm::InputTag HLTL1TSeed::m_l1TauTag

private

Definition at line 130 of file HLTL1TSeed.h.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

◆ m_l1TauToken

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

private

Definition at line 131 of file HLTL1TSeed.h.

Referenced by seedsL1TriggerObjectMaps().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HLTL1TSeed()

◆ ~HLTL1TSeed()

Member Function Documentation

◆ dumpTriggerFilterObjectWithRefs()

◆ fillDescriptions()

◆ hltFilter()

◆ seedsL1TriggerObjectMaps()

◆ updateAlgoLogicParser() [1/2]

◆ updateAlgoLogicParser() [2/2]

Member Data Documentation

◆ m_isDebugEnabled

◆ m_l1AlgoLogicParser

◆ m_l1AlgoSeeds

◆ m_l1AlgoSeedsObjType

◆ m_l1AlgoSeedsRpn

◆ m_l1EGammaCollectionsTag

◆ m_l1EGammaTag

◆ m_l1EGammaToken

◆ m_l1EtSumCollectionsTag

◆ m_l1EtSumTag

◆ m_l1EtSumToken

◆ m_l1GlobalDecision

◆ m_l1GlobalTag

◆ m_l1GlobalToken

◆ m_l1GtObjectMapTag

◆ m_l1GtObjectMapToken

◆ m_l1JetCollectionsTag

◆ m_l1JetTag

◆ m_l1JetToken

◆ m_l1MuonCollectionsTag

◆ m_l1MuonShowerCollectionsTag

◆ m_l1MuonShowerTag

◆ m_l1MuonShowerToken

◆ m_l1MuonTag

◆ m_l1MuonToken

◆ m_l1NrBxInEvent

◆ m_l1SeedsLogicalExpression

◆ m_l1TauCollectionsTag

◆ m_l1TauTag

◆ m_l1TauToken