CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes
HLTL1TSeed Class Reference

#include <HLTL1TSeed.h>

Inheritance diagram for HLTL1TSeed:
HLTStreamFilter edm::stream::EDFilter<> edm::stream::EDFilterBase edm::ProducerBase edm::EDConsumerBase edm::ProductRegistryHelper

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
template<typename T >
using BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >
 
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:

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.

33  : HLTStreamFilter(parSet),
34  //useObjectMaps_(parSet.getParameter<bool>("L1UseL1TriggerObjectMaps")),
35  m_l1SeedsLogicalExpression(parSet.getParameter<string>("L1SeedsLogicalExpression")),
36  m_l1GtObjectMapTag(parSet.getParameter<edm::InputTag>("L1ObjectMapInputTag")),
37  m_l1GtObjectMapToken(consumes<GlobalObjectMapRecord>(m_l1GtObjectMapTag)),
38  m_l1GlobalTag(parSet.getParameter<edm::InputTag>("L1GlobalInputTag")),
39  m_l1GlobalToken(consumes<GlobalAlgBlkBxCollection>(m_l1GlobalTag)),
40  m_l1MuonCollectionsTag(parSet.getParameter<edm::InputTag>("L1MuonInputTag")), // FIX WHEN UNPACKERS ADDED
41  m_l1MuonTag(m_l1MuonCollectionsTag),
42  m_l1MuonToken(consumes<l1t::MuonBxCollection>(m_l1MuonTag)),
43  m_l1MuonShowerCollectionsTag(
44  parSet.getParameter<edm::InputTag>("L1MuonShowerInputTag")), // FIX WHEN UNPACKERS ADDED
45  m_l1MuonShowerTag(m_l1MuonShowerCollectionsTag),
46  m_l1MuonShowerToken(consumes<l1t::MuonShowerBxCollection>(m_l1MuonShowerTag)),
47  m_l1EGammaCollectionsTag(parSet.getParameter<edm::InputTag>("L1EGammaInputTag")), // FIX WHEN UNPACKERS ADDED
48  m_l1EGammaTag(m_l1EGammaCollectionsTag),
49  m_l1EGammaToken(consumes<l1t::EGammaBxCollection>(m_l1EGammaTag)),
50  m_l1JetCollectionsTag(parSet.getParameter<edm::InputTag>("L1JetInputTag")), // FIX WHEN UNPACKERS ADDED
51  m_l1JetTag(m_l1JetCollectionsTag),
52  m_l1JetToken(consumes<l1t::JetBxCollection>(m_l1JetTag)),
53  m_l1TauCollectionsTag(parSet.getParameter<edm::InputTag>("L1TauInputTag")), // FIX WHEN UNPACKERS ADDED
54  m_l1TauTag(m_l1TauCollectionsTag),
55  m_l1TauToken(consumes<l1t::TauBxCollection>(m_l1TauTag)),
56  m_l1EtSumCollectionsTag(parSet.getParameter<edm::InputTag>("L1EtSumInputTag")), // FIX WHEN UNPACKERS ADDED
57  m_l1EtSumTag(m_l1EtSumCollectionsTag),
58  m_l1EtSumToken(consumes<l1t::EtSumBxCollection>(m_l1EtSumTag)),
59  m_l1GlobalDecision(false),
60  m_isDebugEnabled(edm::isDebugEnabled()) {
61  if (m_l1SeedsLogicalExpression.empty()) {
62  throw cms::Exception("FailModule") << "\nTrying to seed with an empty L1SeedsLogicalExpression.\n" << std::endl;
63 
64  } else if (m_l1SeedsLogicalExpression != "L1GlobalDecision") {
65  // check also the logical expression - add/remove spaces if needed
66  m_l1AlgoLogicParser = GlobalLogicParser(m_l1SeedsLogicalExpression);
67 
68  // list of required algorithms for seeding
69  // dummy values for tokenNumber and tokenResult
70  m_l1AlgoSeeds.reserve((m_l1AlgoLogicParser.operandTokenVector()).size());
71  m_l1AlgoSeeds = m_l1AlgoLogicParser.expressionSeedsOperandList();
72  size_t l1AlgoSeedsSize = m_l1AlgoSeeds.size();
73 
74  m_l1AlgoSeedsRpn.reserve(l1AlgoSeedsSize);
75  m_l1AlgoSeedsObjType.reserve(l1AlgoSeedsSize);
76 
77  } else {
78  m_l1GlobalDecision = true;
79  }
80 }
findQualityFiles.size
size
Write out results.
Definition: findQualityFiles.py:443
HLTL1TSeed::m_l1SeedsLogicalExpression
std::string m_l1SeedsLogicalExpression
Definition: HLTL1TSeed.h:97
edm::isDebugEnabled
bool isDebugEnabled()
Definition: MessageLogger.cc:12
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
HLTL1TSeed::m_l1EtSumToken
edm::EDGetTokenT< l1t::EtSumBxCollection > m_l1EtSumToken
Definition: HLTL1TSeed.h:136
HLTL1TSeed::m_l1AlgoSeedsRpn
std::vector< const std::vector< GlobalLogicParser::TokenRPN > * > m_l1AlgoSeedsRpn
vector of Rpn vectors for the required algorithms for seeding
Definition: HLTL1TSeed.h:85
HLTL1TSeed::m_l1MuonTag
edm::InputTag m_l1MuonTag
Definition: HLTL1TSeed.h:110
HLTL1TSeed::m_l1MuonShowerTag
edm::InputTag m_l1MuonShowerTag
Definition: HLTL1TSeed.h:115
HLTL1TSeed::m_l1EGammaCollectionsTag
edm::InputTag m_l1EGammaCollectionsTag
Meta InputTag for L1 Egamma collection.
Definition: HLTL1TSeed.h:119
HLTL1TSeed::m_l1JetCollectionsTag
edm::InputTag m_l1JetCollectionsTag
Meta InputTag for L1 Egamma collection.
Definition: HLTL1TSeed.h:124
GlobalLogicParser::expressionSeedsOperandList
std::vector< GlobalLogicParser::OperandToken > expressionSeedsOperandList()
Definition: GlobalLogicParser.cc:1079
HLTL1TSeed::m_l1JetTag
edm::InputTag m_l1JetTag
Definition: HLTL1TSeed.h:125
HLTL1TSeed::m_l1GtObjectMapTag
edm::InputTag m_l1GtObjectMapTag
InputTag for L1 Global Trigger object maps. This is done per menu. Should be part of Run...
Definition: HLTL1TSeed.h:100
HLTL1TSeed::m_l1JetToken
edm::EDGetTokenT< l1t::JetBxCollection > m_l1JetToken
Definition: HLTL1TSeed.h:126
HLTStreamFilter::HLTStreamFilter
HLTStreamFilter(const edm::ParameterSet &config)
Definition: HLTStreamFilter.cc:20
GlobalLogicParser::operandTokenVector
std::vector< OperandToken > & operandTokenVector()
return the vector of operand tokens
Definition: GlobalLogicParser.h:100
HLTL1TSeed::m_l1AlgoLogicParser
GlobalLogicParser m_l1AlgoLogicParser
logic parser for m_l1SeedsLogicalExpression
Definition: HLTL1TSeed.h:79
HLTL1TSeed::m_l1EGammaToken
edm::EDGetTokenT< l1t::EGammaBxCollection > m_l1EGammaToken
Definition: HLTL1TSeed.h:121
HLTL1TSeed::m_l1EtSumTag
edm::InputTag m_l1EtSumTag
Definition: HLTL1TSeed.h:135
HLTL1TSeed::m_l1TauTag
edm::InputTag m_l1TauTag
Definition: HLTL1TSeed.h:130
HLTL1TSeed::m_l1EtSumCollectionsTag
edm::InputTag m_l1EtSumCollectionsTag
Meta InputTag for L1 Egamma collection.
Definition: HLTL1TSeed.h:134
HLTL1TSeed::m_l1MuonShowerCollectionsTag
edm::InputTag m_l1MuonShowerCollectionsTag
Meta InputTag for L1 Muon collection.
Definition: HLTL1TSeed.h:114
HLTL1TSeed::m_l1TauCollectionsTag
edm::InputTag m_l1TauCollectionsTag
Meta InputTag for L1 Egamma collection.
Definition: HLTL1TSeed.h:129
HLTL1TSeed::m_isDebugEnabled
bool m_isDebugEnabled
cache edm::isDebugEnabled()
Definition: HLTL1TSeed.h:142
HLTL1TSeed::m_l1AlgoSeeds
std::vector< GlobalLogicParser::OperandToken > m_l1AlgoSeeds
list of required algorithms for seeding
Definition: HLTL1TSeed.h:82
HLTL1TSeed::m_l1EGammaTag
edm::InputTag m_l1EGammaTag
Definition: HLTL1TSeed.h:120
HLTL1TSeed::m_l1GlobalTag
edm::InputTag m_l1GlobalTag
InputTag for L1 Global Trigger.
Definition: HLTL1TSeed.h:104
HLTL1TSeed::m_l1GlobalToken
edm::EDGetTokenT< GlobalAlgBlkBxCollection > m_l1GlobalToken
Definition: HLTL1TSeed.h:105
HLTL1TSeed::m_l1MuonCollectionsTag
edm::InputTag m_l1MuonCollectionsTag
Meta InputTag for L1 Muon collection.
Definition: HLTL1TSeed.h:109
HLTL1TSeed::m_l1GlobalDecision
bool m_l1GlobalDecision
flag to pass if L1TGlobal accept
Definition: HLTL1TSeed.h:139
HLTL1TSeed::m_l1AlgoSeedsObjType
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 ...
Definition: HLTL1TSeed.h:88
HLTL1TSeed::m_l1MuonToken
edm::EDGetTokenT< l1t::MuonBxCollection > m_l1MuonToken
Definition: HLTL1TSeed.h:111
HLTL1TSeed::m_l1TauToken
edm::EDGetTokenT< l1t::TauBxCollection > m_l1TauToken
Definition: HLTL1TSeed.h:131
HLTL1TSeed::m_l1MuonShowerToken
edm::EDGetTokenT< l1t::MuonShowerBxCollection > m_l1MuonShowerToken
Definition: HLTL1TSeed.h:116
HLTL1TSeed::m_l1GtObjectMapToken
edm::EDGetTokenT< GlobalObjectMapRecord > m_l1GtObjectMapToken
Definition: HLTL1TSeed.h:101

◆ ~HLTL1TSeed()

HLTL1TSeed::~HLTL1TSeed ( )
override

destructor

Definition at line 83 of file HLTL1TSeed.cc.

83  {
84  // empty now
85 }

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.

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::TriggerL1MuShower, trigger::TriggerL1Tau, and trigger::TriggerL1TowerCount.

Referenced by hltFilter().

148  {
149  LogTrace("HLTL1TSeed") << "\nHLTL1TSeed::hltFilter "
150  << "\n Dump TriggerFilterObjectWithRefs\n"
151  << endl;
152 
153  vector<l1t::MuonRef> seedsL1Mu;
154  filterproduct.getObjects(trigger::TriggerL1Mu, seedsL1Mu);
155  const size_t sizeSeedsL1Mu = seedsL1Mu.size();
156 
157  LogTrace("HLTL1TSeed") << "\n HLTL1TSeed: seed logical expression = " << m_l1SeedsLogicalExpression << endl;
158 
159  LogTrace("HLTL1TSeed") << "\n L1Mu seeds: " << sizeSeedsL1Mu << endl << endl;
160 
161  for (size_t i = 0; i != sizeSeedsL1Mu; i++) {
162  l1t::MuonRef obj = l1t::MuonRef(seedsL1Mu[i]);
163 
164  LogTrace("HLTL1TSeed") << "\tL1Mu "
165  << "\t"
166  << "q = "
167  << obj->hwCharge() // TEMP get hwCharge insead of charge which is not yet set NEED FIX.
168  << "\t"
169  << "pt = " << obj->pt() << "\t"
170  << "eta = " << obj->eta() << "\t"
171  << "phi = " << obj->phi(); //<< "\t" << "BX = " << obj->bx();
172  }
173 
174  vector<l1t::MuonShowerRef> seedsL1MuShower;
175  filterproduct.getObjects(trigger::TriggerL1MuShower, seedsL1MuShower);
176  const size_t sizeSeedsL1MuShower = seedsL1MuShower.size();
177 
178  LogTrace("HLTL1TSeed") << "\n HLTL1TSeed: seed logical expression = " << m_l1SeedsLogicalExpression << endl;
179 
180  LogTrace("HLTL1TSeed") << "\n L1MuShower seeds: " << sizeSeedsL1MuShower << endl << endl;
181 
182  for (size_t i = 0; i != sizeSeedsL1MuShower; i++) {
183  l1t::MuonShowerRef obj = l1t::MuonShowerRef(seedsL1MuShower[i]);
184 
185  LogTrace("HLTL1TSeed") << "\tL1MuShower "
186  << "\t"
187  << "pt = " << obj->pt() << "\t"
188  << "eta = " << obj->eta() << "\t"
189  << "phi = " << obj->phi(); //<< "\t" << "BX = " << obj->bx();
190  }
191 
192  vector<l1t::EGammaRef> seedsL1EG;
193  filterproduct.getObjects(trigger::TriggerL1EG, seedsL1EG);
194  const size_t sizeSeedsL1EG = seedsL1EG.size();
195 
196  LogTrace("HLTL1TSeed") << "\n L1EG seeds: " << sizeSeedsL1EG << endl << endl;
197 
198  for (size_t i = 0; i != sizeSeedsL1EG; i++) {
199  l1t::EGammaRef obj = l1t::EGammaRef(seedsL1EG[i]);
200 
201  LogTrace("HLTL1TSeed") << "\tL1EG "
202  << "\t"
203  << "pt = " << obj->pt() << "\t"
204  << "eta = " << obj->eta() << "\t"
205  << "phi = " << obj->phi(); //<< "\t" << "BX = " << obj->bx();
206  }
207 
208  vector<l1t::JetRef> seedsL1Jet;
209  filterproduct.getObjects(trigger::TriggerL1Jet, seedsL1Jet);
210  const size_t sizeSeedsL1Jet = seedsL1Jet.size();
211 
212  LogTrace("HLTL1TSeed") << "\n L1Jet seeds: " << sizeSeedsL1Jet << endl << endl;
213 
214  for (size_t i = 0; i != sizeSeedsL1Jet; i++) {
215  l1t::JetRef obj = l1t::JetRef(seedsL1Jet[i]);
216 
217  LogTrace("HLTL1TSeed") << "\tL1Jet "
218  << "\t"
219  << "pt = " << obj->pt() << "\t"
220  << "eta = " << obj->eta() << "\t"
221  << "phi = " << obj->phi(); //<< "\t" << "BX = " << obj->bx();
222  }
223 
224  vector<l1t::TauRef> seedsL1Tau;
225  filterproduct.getObjects(trigger::TriggerL1Tau, seedsL1Tau);
226  const size_t sizeSeedsL1Tau = seedsL1Tau.size();
227 
228  LogTrace("HLTL1TSeed") << "\n L1Tau seeds: " << sizeSeedsL1Tau << endl << endl;
229 
230  for (size_t i = 0; i != sizeSeedsL1Tau; i++) {
231  l1t::TauRef obj = l1t::TauRef(seedsL1Tau[i]);
232 
233  LogTrace("HLTL1TSeed") << "\tL1Tau "
234  << "\t"
235  << "pt = " << obj->pt() << "\t"
236  << "eta = " << obj->eta() << "\t"
237  << "phi = " << obj->phi(); //<< "\t" << "BX = " << obj->bx();
238  }
239 
240  vector<l1t::EtSumRef> seedsL1EtSumETT;
241  filterproduct.getObjects(trigger::TriggerL1ETT, seedsL1EtSumETT);
242  const size_t sizeSeedsL1EtSumETT = seedsL1EtSumETT.size();
243  LogTrace("HLTL1TSeed") << "\n L1EtSum ETT seeds: " << sizeSeedsL1EtSumETT << endl << endl;
244 
245  for (size_t i = 0; i != sizeSeedsL1EtSumETT; i++) {
246  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumETT[i]);
247 
248  LogTrace("HLTL1TSeed") << "\tL1EtSum ETT"
249  << "\t"
250  << "pt = " << obj->pt() << "\t"
251  << "eta = " << obj->eta() << "\t"
252  << "phi = " << obj->phi(); //<< "\t" << "BX = " << obj->bx();
253  }
254 
255  vector<l1t::EtSumRef> seedsL1EtSumHTT;
256  filterproduct.getObjects(trigger::TriggerL1HTT, seedsL1EtSumHTT);
257  const size_t sizeSeedsL1EtSumHTT = seedsL1EtSumHTT.size();
258  LogTrace("HLTL1TSeed") << "\n L1EtSum HTT seeds: " << sizeSeedsL1EtSumHTT << endl << endl;
259 
260  for (size_t i = 0; i != sizeSeedsL1EtSumHTT; i++) {
261  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumHTT[i]);
262 
263  LogTrace("HLTL1TSeed") << "\tL1EtSum HTT"
264  << "\t"
265  << "pt = " << obj->pt() << "\t"
266  << "eta = " << obj->eta() << "\t"
267  << "phi = " << obj->phi(); //<< "\t" << "BX = " << obj->bx();
268  }
269 
270  vector<l1t::EtSumRef> seedsL1EtSumETM;
271  filterproduct.getObjects(trigger::TriggerL1ETM, seedsL1EtSumETM);
272  const size_t sizeSeedsL1EtSumETM = seedsL1EtSumETM.size();
273  LogTrace("HLTL1TSeed") << "\n L1EtSum ETM seeds: " << sizeSeedsL1EtSumETM << endl << endl;
274 
275  for (size_t i = 0; i != sizeSeedsL1EtSumETM; i++) {
276  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumETM[i]);
277 
278  LogTrace("HLTL1TSeed") << "\tL1EtSum ETM"
279  << "\t"
280  << "pt = " << obj->pt() << "\t"
281  << "eta = " << obj->eta() << "\t"
282  << "phi = " << obj->phi(); //<< "\t" << "BX = " << obj->bx();
283  }
284 
285  vector<l1t::EtSumRef> seedsL1EtSumETMHF;
286  filterproduct.getObjects(trigger::TriggerL1ETMHF, seedsL1EtSumETMHF);
287  const size_t sizeSeedsL1EtSumETMHF = seedsL1EtSumETMHF.size();
288  LogTrace("HLTL1TSeed") << "\n L1EtSum ETMHF seeds: " << sizeSeedsL1EtSumETMHF << endl << endl;
289 
290  for (size_t i = 0; i != sizeSeedsL1EtSumETMHF; i++) {
291  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumETMHF[i]);
292 
293  LogTrace("HLTL1TSeed") << "\tL1EtSum ETMHF"
294  << "\t"
295  << "pt = " << obj->pt() << "\t"
296  << "eta = " << obj->eta() << "\t"
297  << "phi = " << obj->phi(); //<< "\t" << "BX = " << obj->bx();
298  }
299 
300  vector<l1t::EtSumRef> seedsL1EtSumHTM;
301  filterproduct.getObjects(trigger::TriggerL1HTM, seedsL1EtSumHTM);
302  const size_t sizeSeedsL1EtSumHTM = seedsL1EtSumHTM.size();
303  LogTrace("HLTL1TSeed") << "\n L1EtSum HTM seeds: " << sizeSeedsL1EtSumHTM << endl << endl;
304 
305  for (size_t i = 0; i != sizeSeedsL1EtSumHTM; i++) {
306  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumHTM[i]);
307 
308  LogTrace("HLTL1TSeed") << "\tL1EtSum HTM"
309  << "\t"
310  << "pt = " << obj->pt() << "\t"
311  << "eta = " << obj->eta() << "\t"
312  << "phi = " << obj->phi(); //<< "\t" << "BX = " << obj->bx();
313  }
314 
315  vector<l1t::EtSumRef> seedsL1EtSumCentrality;
316  filterproduct.getObjects(trigger::TriggerL1Centrality, seedsL1EtSumCentrality);
317  const size_t sizeSeedsL1EtSumCentrality = seedsL1EtSumCentrality.size();
318  LogTrace("HLTL1TSeed") << "\n L1EtSum Centrality seeds: " << sizeSeedsL1EtSumCentrality << endl << endl;
319 
320  for (size_t i = 0; i != sizeSeedsL1EtSumCentrality; i++) {
321  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumCentrality[i]);
322 
323  LogTrace("HLTL1TSeed") << "\tL1EtSum Centrality Bits: " << std::bitset<8>(obj->hwPt())
324  << " (hwPt = " << obj->hwPt() << ")";
325  }
326 
327  vector<l1t::EtSumRef> seedsL1EtSumMinBiasHFP0;
328  filterproduct.getObjects(trigger::TriggerL1MinBiasHFP0, seedsL1EtSumMinBiasHFP0);
329  const size_t sizeSeedsL1EtSumMinBiasHFP0 = seedsL1EtSumMinBiasHFP0.size();
330  LogTrace("HLTL1TSeed") << "\n L1EtSum MinBiasHFP0 seeds: " << sizeSeedsL1EtSumMinBiasHFP0 << endl << endl;
331 
332  for (size_t i = 0; i != sizeSeedsL1EtSumMinBiasHFP0; i++) {
333  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumMinBiasHFP0[i]);
334 
335  LogTrace("HLTL1TSeed") << "\tL1EtSum MinBiasHFP0: hwPt = " << obj->hwPt();
336  }
337 
338  vector<l1t::EtSumRef> seedsL1EtSumMinBiasHFM0;
339  filterproduct.getObjects(trigger::TriggerL1MinBiasHFM0, seedsL1EtSumMinBiasHFM0);
340  const size_t sizeSeedsL1EtSumMinBiasHFM0 = seedsL1EtSumMinBiasHFM0.size();
341  LogTrace("HLTL1TSeed") << "\n L1EtSum MinBiasHFM0 seeds: " << sizeSeedsL1EtSumMinBiasHFM0 << endl << endl;
342 
343  for (size_t i = 0; i != sizeSeedsL1EtSumMinBiasHFM0; i++) {
344  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumMinBiasHFM0[i]);
345 
346  LogTrace("HLTL1TSeed") << "\tL1EtSum MinBiasHFM0: hwPt = " << obj->hwPt();
347  }
348 
349  vector<l1t::EtSumRef> seedsL1EtSumMinBiasHFP1;
350  filterproduct.getObjects(trigger::TriggerL1MinBiasHFP1, seedsL1EtSumMinBiasHFP1);
351  const size_t sizeSeedsL1EtSumMinBiasHFP1 = seedsL1EtSumMinBiasHFP1.size();
352  LogTrace("HLTL1TSeed") << "\n L1EtSum MinBiasHFP1 seeds: " << sizeSeedsL1EtSumMinBiasHFP1 << endl << endl;
353 
354  for (size_t i = 0; i != sizeSeedsL1EtSumMinBiasHFP1; i++) {
355  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumMinBiasHFP1[i]);
356 
357  LogTrace("HLTL1TSeed") << "\tL1EtSum MinBiasHFP1: hwPt = " << obj->hwPt();
358  }
359 
360  vector<l1t::EtSumRef> seedsL1EtSumMinBiasHFM1;
361  filterproduct.getObjects(trigger::TriggerL1MinBiasHFM1, seedsL1EtSumMinBiasHFM1);
362  const size_t sizeSeedsL1EtSumMinBiasHFM1 = seedsL1EtSumMinBiasHFM1.size();
363  LogTrace("HLTL1TSeed") << "\n L1EtSum MinBiasHFM1 seeds: " << sizeSeedsL1EtSumMinBiasHFM1 << endl << endl;
364 
365  for (size_t i = 0; i != sizeSeedsL1EtSumMinBiasHFM1; i++) {
366  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumMinBiasHFM1[i]);
367 
368  LogTrace("HLTL1TSeed") << "\tL1EtSum MinBiasHFM1: hwPt = " << obj->hwPt();
369  }
370 
371  vector<l1t::EtSumRef> seedsL1EtSumTowerCount;
372  filterproduct.getObjects(trigger::TriggerL1TowerCount, seedsL1EtSumTowerCount);
373  const size_t sizeSeedsL1EtSumTowerCount = seedsL1EtSumTowerCount.size();
374  LogTrace("HLTL1TSeed") << "\n L1EtSum TowerCount seeds: " << sizeSeedsL1EtSumTowerCount << endl << endl;
375 
376  for (size_t i = 0; i != sizeSeedsL1EtSumTowerCount; i++) {
377  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumTowerCount[i]);
378 
379  LogTrace("HLTL1TSeed") << "\tL1EtSum TowerCount: hwPt = " << obj->hwPt();
380  }
381 
382  vector<l1t::EtSumRef> seedsL1EtSumAsymEt;
383  filterproduct.getObjects(trigger::TriggerL1AsymEt, seedsL1EtSumAsymEt);
384  const size_t sizeSeedsL1EtSumAsymEt = seedsL1EtSumAsymEt.size();
385  LogTrace("HLTL1TSeed") << "\n L1EtSum AsymEt seeds: " << sizeSeedsL1EtSumAsymEt << endl << endl;
386 
387  for (size_t i = 0; i != sizeSeedsL1EtSumAsymEt; i++) {
388  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumAsymEt[i]);
389 
390  LogTrace("HLTL1TSeed") << "\tL1EtSum AsymEt: hwPt = " << obj->hwPt();
391  }
392 
393  vector<l1t::EtSumRef> seedsL1EtSumAsymHt;
394  filterproduct.getObjects(trigger::TriggerL1AsymHt, seedsL1EtSumAsymHt);
395  const size_t sizeSeedsL1EtSumAsymHt = seedsL1EtSumAsymHt.size();
396  LogTrace("HLTL1TSeed") << "\n L1EtSum AsymHt seeds: " << sizeSeedsL1EtSumAsymHt << endl << endl;
397 
398  for (size_t i = 0; i != sizeSeedsL1EtSumAsymHt; i++) {
399  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumAsymHt[i]);
400 
401  LogTrace("HLTL1TSeed") << "\tL1EtSum AsymHt: hwPt = " << obj->hwPt();
402  }
403 
404  vector<l1t::EtSumRef> seedsL1EtSumAsymEtHF;
405  filterproduct.getObjects(trigger::TriggerL1AsymEtHF, seedsL1EtSumAsymEtHF);
406  const size_t sizeSeedsL1EtSumAsymEtHF = seedsL1EtSumAsymEtHF.size();
407  LogTrace("HLTL1TSeed") << "\n L1EtSum AsymEtHF seeds: " << sizeSeedsL1EtSumAsymEtHF << endl << endl;
408 
409  for (size_t i = 0; i != sizeSeedsL1EtSumAsymEtHF; i++) {
410  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumAsymEtHF[i]);
411 
412  LogTrace("HLTL1TSeed") << "\tL1EtSum AsymEtHF: hwPt = " << obj->hwPt();
413  }
414 
415  vector<l1t::EtSumRef> seedsL1EtSumAsymHtHF;
416  filterproduct.getObjects(trigger::TriggerL1AsymHtHF, seedsL1EtSumAsymHtHF);
417  const size_t sizeSeedsL1EtSumAsymHtHF = seedsL1EtSumAsymHtHF.size();
418  LogTrace("HLTL1TSeed") << "\n L1EtSum AsymHtHF seeds: " << sizeSeedsL1EtSumAsymHtHF << endl << endl;
419 
420  for (size_t i = 0; i != sizeSeedsL1EtSumAsymHtHF; i++) {
421  l1t::EtSumRef obj = l1t::EtSumRef(seedsL1EtSumAsymHtHF[i]);
422 
423  LogTrace("HLTL1TSeed") << "\tL1EtSum AsymHtHF: hwPt = " << obj->hwPt();
424  }
425 
426  LogTrace("HLTL1TSeed") << " \n\n" << endl;
427 }
HLTL1TSeed::m_l1SeedsLogicalExpression
std::string m_l1SeedsLogicalExpression
Definition: HLTL1TSeed.h:97
trigger::TriggerRefsCollections::getObjects
void getObjects(Vids &ids, VRphoton &refs) const
various physics-level getters:
Definition: TriggerRefsCollections.h:627
mps_fire.i
i
Definition: mps_fire.py:429
l1t::EGammaRef
edm::Ref< EGammaBxCollection > EGammaRef
Definition: TkEGTau.h:35
trigger::TriggerL1Mu
enum start value shifted to 81 so as to avoid clashes with PDG codes
Definition: TriggerTypeDefs.h:30
l1t::JetRef
edm::Ref< JetBxCollection > JetRef
Definition: Jet.h:12
l1t::EtSumRef
edm::Ref< EtSumBxCollection > EtSumRef
Definition: EtSum.h:12
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
l1t::TauRef
edm::Ref< TauBxCollection > TauRef
Definition: Tau.h:12
l1t::MuonShowerRef
edm::Ref< MuonShowerBxCollection > MuonShowerRef
Definition: MuonShower.h:20
l1t::MuonRef
edm::Ref< MuonBxCollection > MuonRef
Definition: Muon.h:13

◆ fillDescriptions()

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

parameter description

Definition at line 89 of file HLTL1TSeed.cc.

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

89  {
90  edm::ParameterSetDescription desc;
91  makeHLTFilterDescription(desc);
92 
93  // # logical expression for the required L1 algorithms;
94  // # the algorithms are specified by name
95  // # allowed operators: "AND", "OR", "NOT", "(", ")"
96  // #
97  // # by convention, "L1GlobalDecision" logical expression means global decision
98  desc.add<string>("L1SeedsLogicalExpression", "");
99  desc.add<edm::InputTag>("L1ObjectMapInputTag", edm::InputTag("hltGtStage2ObjectMap"));
100  desc.add<edm::InputTag>("L1GlobalInputTag", edm::InputTag("hltGtStage2Digis"));
101  desc.add<edm::InputTag>("L1MuonInputTag", edm::InputTag("hltGtStage2Digis:Muon"));
102  desc.add<edm::InputTag>("L1MuonShowerInputTag", edm::InputTag("hltGtStage2Digis:MuonShower"));
103  desc.add<edm::InputTag>("L1EGammaInputTag", edm::InputTag("hltGtStage2Digis:EGamma"));
104  desc.add<edm::InputTag>("L1JetInputTag", edm::InputTag("hltGtStage2Digis:Jet"));
105  desc.add<edm::InputTag>("L1TauInputTag", edm::InputTag("hltGtStage2Digis:Tau"));
106  desc.add<edm::InputTag>("L1EtSumInputTag", edm::InputTag("hltGtStage2Digis:EtSum"));
107  descriptions.add("hltL1TSeed", desc);
108 }
ProducerED_cfi.InputTag
InputTag
Definition: ProducerED_cfi.py:5
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
HLTStreamFilter::makeHLTFilterDescription
static void makeHLTFilterDescription(edm::ParameterSetDescription &desc)
Definition: HLTStreamFilter.cc:26

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

112  {
113  bool rc = false;
114 
115  // the filter object
116  if (saveTags()) {
117  // muons
118  filterproduct.addCollectionTag(m_l1MuonTag);
119 
120  // muon showers
121  filterproduct.addCollectionTag(m_l1MuonShowerTag);
122 
123  // egamma
124  filterproduct.addCollectionTag(m_l1EGammaTag);
125 
126  // jet
127  filterproduct.addCollectionTag(m_l1JetTag);
128 
129  // tau
130  filterproduct.addCollectionTag(m_l1TauTag);
131 
132  // etsum
133  filterproduct.addCollectionTag(m_l1EtSumTag);
134  }
135 
136  // Get all the seeding from iEvent (i.e. L1TriggerObjectMapRecord)
137  //
138  rc = seedsL1TriggerObjectMaps(iEvent, filterproduct);
139 
140  if (m_isDebugEnabled) {
141  dumpTriggerFilterObjectWithRefs(filterproduct);
142  }
143 
144  return rc;
145 }
HLTStreamFilter::saveTags
bool saveTags() const
Definition: HLTStreamFilter.h:47
HLTL1TSeed::m_l1MuonTag
edm::InputTag m_l1MuonTag
Definition: HLTL1TSeed.h:110
HLTL1TSeed::m_l1MuonShowerTag
edm::InputTag m_l1MuonShowerTag
Definition: HLTL1TSeed.h:115
HLTL1TSeed::seedsL1TriggerObjectMaps
bool seedsL1TriggerObjectMaps(edm::Event &, trigger::TriggerFilterObjectWithRefs &)
seeding is done via L1 trigger object maps, considering the objects which fired in L1 ...
Definition: HLTL1TSeed.cc:430
HLTL1TSeed::dumpTriggerFilterObjectWithRefs
void dumpTriggerFilterObjectWithRefs(trigger::TriggerFilterObjectWithRefs &) const
detailed print of filter content
Definition: HLTL1TSeed.cc:148
iEvent
int iEvent
Definition: GenABIO.cc:224
HLTL1TSeed::m_l1JetTag
edm::InputTag m_l1JetTag
Definition: HLTL1TSeed.h:125
HLTL1TSeed::m_l1EtSumTag
edm::InputTag m_l1EtSumTag
Definition: HLTL1TSeed.h:135
HLTL1TSeed::m_l1TauTag
edm::InputTag m_l1TauTag
Definition: HLTL1TSeed.h:130
HLTL1TSeed::m_isDebugEnabled
bool m_isDebugEnabled
cache edm::isDebugEnabled()
Definition: HLTL1TSeed.h:142
HLTL1TSeed::m_l1EGammaTag
edm::InputTag m_l1EGammaTag
Definition: HLTL1TSeed.h:120
trigger::TriggerFilterObjectWithRefs::addCollectionTag
void addCollectionTag(const edm::InputTag &collectionTag)
collectionTags
Definition: TriggerFilterObjectWithRefs.h:55

◆ 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.

References trigger::TriggerRefsCollections::addObject(), GlobalObjectMap::algoBitNumber(), GlobalObjectMap::algoGtlResult(), MillePedeAlignmentAlgorithm_cfi::algoName, GlobalObjectMap::algoName(), cms::cuda::assert(), BXVector< T >::at(), BXVector< T >::begin(), triggerObjects_cff::bit, GlobalObjectMap::combinationVector(), HLT_2023v12_cff::distance, BXVector< T >::end(), Exception, GlobalLogicParser::expressionResult(), GlobalObjectMap::getCombinationsInCond(), GlobalObjectMapRecord::getObjectMap(), 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::gtMuShower, GlobalObjectMapRecord::gtObjectMap(), l1t::gtTau, l1t::gtTowerCount, mps_fire::i, iEvent, BXVector< T >::isEmpty(), edm::HandleBase::isValid(), PDWG_EXODelayedJetMET_cff::jets, l1t::EtSum::kAsymEt, l1t::EtSum::kAsymEtHF, l1t::EtSum::kAsymHt, l1t::EtSum::kAsymHtHF, l1t::EtSum::kCentrality, BXVector< T >::key(), 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_l1MuonShowerTag, m_l1MuonShowerToken, m_l1MuonTag, m_l1MuonToken, m_l1SeedsLogicalExpression, m_l1TauTag, m_l1TauToken, PDWG_BPHSkim_cff::muons, GlobalObjectMap::objectTypeVector(), GlobalObjectMap::operandTokenVector(), GlobalLogicParser::operandTokenVector(), BXVector< T >::size(), AlCaHLTBitMon_QueryRunRegistry::string, Tau3MuMonitor_cff::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::TriggerL1MuShower, trigger::TriggerL1Tau, trigger::TriggerL1TotalEtEm, and trigger::TriggerL1TowerCount.

Referenced by hltFilter().

430  {
431  // Two GT objects are obtained from the Event: (1) the unpacked GT and (2) the emulated GT.
432  // Return value of the function is the score of seeding logical expression, evaluated using (1).
433  // Seeding is performed (per l1_algo) if ACCEPT both in (1) and (2). Seed objects are identified
434  // and only available from ObjectMaps created in (2).
435 
436  // define index lists for all particle types
437 
438  std::list<int> listMuon;
439  std::list<int> listMuonShower;
440 
441  std::list<int> listEG;
442 
443  std::list<int> listJet;
444  std::list<int> listTau;
445 
446  std::list<int> listETM;
447  std::list<int> listETT;
448  std::list<int> listHTT;
449  std::list<int> listHTM;
450  std::list<int> listETMHF;
451 
452  std::list<int> listJetCounts;
453 
454  std::list<int> listCentrality;
455  std::list<int> listMinBiasHFP0;
456  std::list<int> listMinBiasHFM0;
457  std::list<int> listMinBiasHFP1;
458  std::list<int> listMinBiasHFM1;
459  std::list<int> listTotalEtEm;
460  std::list<int> listMissingEtHF;
461  std::list<int> listTowerCount;
462  std::list<int> listAsymEt;
463  std::list<int> listAsymHt;
464  std::list<int> listAsymEtHF;
465  std::list<int> listAsymHtHF;
466 
467  // get handle to unpacked GT
468  edm::Handle<GlobalAlgBlkBxCollection> uGtAlgoBlocks;
469  iEvent.getByToken(m_l1GlobalToken, uGtAlgoBlocks);
470 
471  if (!uGtAlgoBlocks.isValid()) {
472  edm::LogWarning("HLTL1TSeed") << " Warning: GlobalAlgBlkBxCollection with input tag " << m_l1GlobalTag
473  << " requested in configuration, but not found in the event." << std::endl;
474 
475  return false;
476  }
477 
478  // check size (all BXs)
479  if (uGtAlgoBlocks->size() == 0) {
480  edm::LogWarning("HLTL1TSeed") << " Warning: GlobalAlgBlkBxCollection with input tag " << m_l1GlobalTag
481  << " is empty for all BXs.";
482  return false;
483  }
484 
485  // check size (BX 0)
486  if (uGtAlgoBlocks->isEmpty(0)) {
487  edm::LogWarning("HLTL1TSeed") << " Warning: GlobalAlgBlkBxCollection with input tag " << m_l1GlobalTag
488  << " is empty for BX=0.";
489  return false;
490  }
491 
492  // get handle to object maps from emulator (one object map per algorithm)
493  edm::Handle<GlobalObjectMapRecord> gtObjectMapRecord;
494  iEvent.getByToken(m_l1GtObjectMapToken, gtObjectMapRecord);
495 
496  if (!gtObjectMapRecord.isValid()) {
497  edm::LogWarning("HLTL1TSeed") << " Warning: GlobalObjectMapRecord with input tag " << m_l1GtObjectMapTag
498  << " requested in configuration, but not found in the event." << std::endl;
499 
500  return false;
501  }
502 
503  if (m_isDebugEnabled) {
504  const std::vector<GlobalObjectMap>& objMaps = gtObjectMapRecord->gtObjectMap();
505 
506  LogTrace("HLTL1TSeed") << "\nHLTL1Seed"
507  << "\n--------------------------------------------------------------------------------------"
508  "-------------------------------";
509 
510  LogTrace("HLTL1TSeed")
511  << "\n\tAlgorithms in L1TriggerObjectMapRecord and GT results ( emulated | initial | prescaled | final ) "
512  << endl;
513 
514  LogTrace("HLTL1TSeed") << "\n\tmap"
515  << "\tAlgoBit" << std::setw(40) << "algoName"
516  << "\t (emul|ini|pre|fin)" << endl;
517 
518  LogTrace("HLTL1TSeed") << "----------------------------------------------------------------------------------------"
519  "-----------------------------";
520 
521  for (size_t imap = 0; imap < objMaps.size(); imap++) {
522  int bit = objMaps[imap].algoBitNumber(); // same as bit from L1T Menu
523 
524  int emulDecision = objMaps[imap].algoGtlResult();
525 
526  // For bx=0 , get 0th AlgoBlock, so in BXvector at(bx=0,i=0)
527  int initDecision = (uGtAlgoBlocks->at(0, 0)).getAlgoDecisionInitial(bit);
528  int presDecision = (uGtAlgoBlocks->at(0, 0)).getAlgoDecisionInterm(bit);
529  int finlDecision = (uGtAlgoBlocks->at(0, 0)).getAlgoDecisionFinal(bit);
530 
531  if (emulDecision != initDecision) {
532  LogTrace("HLTL1TSeed") << "L1T decision (emulated vs. unpacked initial) is not the same:"
533  << "\n\tbit = " << std::setw(3) << bit << std::setw(40) << objMaps[imap].algoName()
534  << "\t emulated decision = " << emulDecision
535  << "\t unpacked initial decision = " << initDecision
536  << "\nThis should not happen. Include the L1TGtEmulCompare module in the sequence."
537  << endl;
538  }
539 
540  LogTrace("HLTL1TSeed") << "\t" << std::setw(3) << imap << "\tbit = " << std::setw(3) << bit << std::setw(40)
541  << objMaps[imap].algoName() << "\t ( " << emulDecision << " | " << initDecision << " | "
542  << presDecision << " | " << finlDecision << " ) ";
543  }
544  LogTrace("HLTL1TSeed") << endl;
545  }
546 
547  // Filter decision in case of "L1GlobalDecision" logical expression.
548  // By convention, it means global decision.
549  // /////////////////////////////////////////////////////////////////
550  if (m_l1GlobalDecision) {
551  // For bx=0 , get 0th AlgoBlock, so in BXvector at(bx=0,i=0)
552  return (uGtAlgoBlocks->at(0, 0)).getFinalOR();
553  }
554 
555  // Update/Reset m_l1AlgoLogicParser by reseting token result
556  // /////////////////////////////////////////////////////////
557  std::vector<GlobalLogicParser::OperandToken>& algOpTokenVector = m_l1AlgoLogicParser.operandTokenVector();
558 
559  for (auto& i : algOpTokenVector) {
560  // rest token result
561  //
562  i.tokenResult = false;
563  }
564 
565  // Update m_l1AlgoLogicParser and store emulator results for algOpTokens
566  // /////////////////////////////////////////////////////////////////////
567  for (auto& i : algOpTokenVector) {
568  std::string algoName = i.tokenName;
569 
570  const GlobalObjectMap* objMap = gtObjectMapRecord->getObjectMap(algoName);
571 
572  if (objMap == nullptr) {
573  throw cms::Exception("FailModule")
574  << "\nAlgorithm " << algoName
575  << ", requested as seed by a HLT path, cannot be matched to a L1 algo name in any GlobalObjectMap\n"
576  << "Please check if algorithm " << algoName << " is present in the L1 menu\n"
577  << std::endl;
578 
579  } else {
580  //(algOpTokenVector[i]).tokenResult = objMap->algoGtlResult();
581 
582  int bit = objMap->algoBitNumber();
583  bool finalAlgoDecision = (uGtAlgoBlocks->at(0, 0)).getAlgoDecisionFinal(bit);
584  i.tokenResult = finalAlgoDecision;
585  }
586  }
587 
588  // Filter decision
589  // ///////////////
590  bool seedsResult = m_l1AlgoLogicParser.expressionResult();
591 
592  if (m_isDebugEnabled) {
593  LogTrace("HLTL1TSeed") << "\nHLTL1TSeed: l1SeedsLogicalExpression (names) = '" << m_l1SeedsLogicalExpression << "'"
594  << "\n Result for logical expression after update of algOpTokens: " << seedsResult << "\n"
595  << std::endl;
596  }
597 
600 
601  for (std::vector<GlobalLogicParser::OperandToken>::const_iterator itSeed = m_l1AlgoSeeds.begin();
602  itSeed != m_l1AlgoSeeds.end();
603  ++itSeed) {
604  std::string algoSeedName = (*itSeed).tokenName;
605 
606  LogTrace("HLTL1TSeed") << "\n ---------------- algo seed name = " << algoSeedName << endl;
607 
608  const GlobalObjectMap* objMap = gtObjectMapRecord->getObjectMap(algoSeedName);
609 
610  if (objMap == nullptr) {
611  // Should not get here
612  //
613  throw cms::Exception("FailModule")
614  << "\nAlgorithm " << algoSeedName
615  << ", requested as seed by a HLT path, cannot be matched to a L1 algo name in any GlobalObjectMap\n"
616  << "Please check if algorithm " << algoSeedName << " is present in the L1 menu\n"
617  << std::endl;
618  }
619 
620  int algoSeedBitNumber = objMap->algoBitNumber();
621  bool algoSeedResult = objMap->algoGtlResult();
622 
623  // unpacked GT results: uGtAlgoBlock has decisions initial, prescaled, and final after masks
624  bool algoSeedResultMaskAndPresc = uGtAlgoBlocks->at(0, 0).getAlgoDecisionFinal(algoSeedBitNumber);
625 
626  LogTrace("HLTL1TSeed") << "\n\tAlgo seed " << algoSeedName << " result emulated | final = " << algoSeedResult
627  << " | " << algoSeedResultMaskAndPresc << endl;
628 
631  if (!algoSeedResultMaskAndPresc)
632  continue;
633 
635  // This should not happen if the emulated and unpacked GT are consistent
637  if (!algoSeedResult)
638  continue;
639 
640  const std::vector<GlobalLogicParser::OperandToken>& opTokenVecObjMap = objMap->operandTokenVector();
641  const std::vector<L1TObjectTypeInCond>& condObjTypeVec = objMap->objectTypeVector();
642  const std::vector<CombinationsInCond>& condCombinations = objMap->combinationVector();
643 
644  LogTrace("HLTL1TSeed") << "\n\talgoName =" << objMap->algoName() << "\talgoBitNumber = " << algoSeedBitNumber
645  << "\talgoGtlResult = " << algoSeedResult << endl
646  << endl;
647 
648  if (opTokenVecObjMap.size() != condObjTypeVec.size()) {
649  edm::LogWarning("HLTL1TSeed")
650  << "\nWarning: GlobalObjectMapRecord with input tag " << m_l1GtObjectMapTag
651  << "\nhas object map for bit number " << algoSeedBitNumber
652  << " which contains different size vectors of operand tokens and of condition object types!" << std::endl;
653 
654  assert(opTokenVecObjMap.size() == condObjTypeVec.size());
655  }
656 
657  if (opTokenVecObjMap.size() != condCombinations.size()) {
658  edm::LogWarning("HLTL1TSeed")
659  << "\nWarning: GlobalObjectMapRecord with input tag " << m_l1GtObjectMapTag
660  << "\nhas object map for bit number " << algoSeedBitNumber
661  << " which contains different size vectors of operand tokens and of condition object combinations!"
662  << std::endl;
663 
664  assert(opTokenVecObjMap.size() == condCombinations.size());
665  }
666 
667  // operands are conditions of L1 algo
668  //
669  for (size_t condNumber = 0; condNumber < opTokenVecObjMap.size(); condNumber++) {
670  std::vector<l1t::GlobalObject> condObjType = condObjTypeVec[condNumber];
671 
672  for (auto& jOb : condObjType) {
673  LogTrace("HLTL1TSeed") << setw(15) << "\tcondObjType = " << jOb << endl;
674  }
675 
676  const std::string condName = opTokenVecObjMap[condNumber].tokenName;
677  bool condResult = opTokenVecObjMap[condNumber].tokenResult;
678 
679  // only procede for conditions that passed
680  //
681  if (!condResult) {
682  continue;
683  }
684 
685  // loop over combinations for a given condition
686  //
687  const CombinationsInCond* condComb = objMap->getCombinationsInCond(condNumber);
688 
689  LogTrace("HLTL1TSeed") << setw(15) << "\tcondCombinations = " << condComb->size() << endl;
690 
691  for (auto const& itComb : (*condComb)) {
692  LogTrace("HLTL1TSeed") << setw(15) << "\tnew combination" << endl;
693 
694  // loop over objects in a combination for a given condition
695  //
696  for (auto itObject = itComb.begin(); itObject != itComb.end(); itObject++) {
697  // in case of object-less triggers (e.g. L1_ZeroBias) condObjType vector is empty, so don't seed!
698  //
699  if (condObjType.empty()) {
700  LogTrace("HLTL1TSeed")
701  << "\talgoName = " << objMap->algoName()
702  << " is object-less L1 algorithm, so do not attempt to store any objects to the list of seeds.\n"
703  << std::endl;
704  continue;
705  }
706 
707  // the index of the object type is the same as the index of the object
708  size_t iType = std::distance(itComb.begin(), itObject);
709 
710  // get object type and push indices on the list
711  //
712  const l1t::GlobalObject objTypeVal = condObjType.at(iType);
713 
714  LogTrace("HLTL1TSeed") << "\tAdd object of type " << objTypeVal << " and index " << (*itObject)
715  << " to the seed list." << std::endl;
716 
717  // THESE OBJECT CASES ARE CURRENTLY MISSING:
718  //gtMinBias,
719  //gtExternal,
720  //ObjNull
721 
722  switch (objTypeVal) {
723  case l1t::gtMu: {
724  listMuon.push_back(*itObject);
725  } break;
726  case l1t::gtMuShower: {
727  listMuonShower.push_back(*itObject);
728  } break;
729  case l1t::gtEG: {
730  listEG.push_back(*itObject);
731  } break;
732  case l1t::gtJet: {
733  listJet.push_back(*itObject);
734  } break;
735  case l1t::gtTau: {
736  listTau.push_back(*itObject);
737  } break;
738  case l1t::gtETM: {
739  listETM.push_back(*itObject);
740  } break;
741  case l1t::gtETT: {
742  listETT.push_back(*itObject);
743  } break;
744  case l1t::gtHTT: {
745  listHTT.push_back(*itObject);
746  } break;
747  case l1t::gtHTM: {
748  listHTM.push_back(*itObject);
749  } break;
750  case l1t::gtETMHF: {
751  listETMHF.push_back(*itObject);
752  } break;
753  case l1t::gtTowerCount: {
754  listTowerCount.push_back(*itObject);
755  } break;
756  case l1t::gtMinBiasHFP0: {
757  listMinBiasHFP0.push_back(*itObject);
758  } break;
759  case l1t::gtMinBiasHFM0: {
760  listMinBiasHFM0.push_back(*itObject);
761  } break;
762  case l1t::gtMinBiasHFP1: {
763  listMinBiasHFP1.push_back(*itObject);
764  } break;
765  case l1t::gtMinBiasHFM1: {
766  listMinBiasHFM1.push_back(*itObject);
767  } break;
768  case l1t::gtETTem: {
769  listTotalEtEm.push_back(*itObject);
770  } break;
771  case l1t::gtAsymmetryEt: {
772  listAsymEt.push_back(*itObject);
773  } break;
774  case l1t::gtAsymmetryHt: {
775  listAsymHt.push_back(*itObject);
776  } break;
777  case l1t::gtAsymmetryEtHF: {
778  listAsymEtHF.push_back(*itObject);
779  } break;
780  case l1t::gtAsymmetryHtHF: {
781  listAsymHtHF.push_back(*itObject);
782  } break;
783  case l1t::gtCentrality0:
784  case l1t::gtCentrality1:
785  case l1t::gtCentrality2:
786  case l1t::gtCentrality3:
787  case l1t::gtCentrality4:
788  case l1t::gtCentrality5:
789  case l1t::gtCentrality6:
790  case l1t::gtCentrality7: {
791  listCentrality.push_back(*itObject);
792  } break;
793 
794  //case JetCounts: {
795  // listJetCounts.push_back(*itObject);
796  //}
797 
798  break;
799  default: {
800  // should not arrive here
801 
802  LogTrace("HLTL1TSeed") << "\n HLTL1TSeed::hltFilter "
803  << "\n Unknown object of type " << objTypeVal << " and index " << (*itObject)
804  << " in the seed list." << std::endl;
805  } break;
806 
807  } // end switch objTypeVal
808 
809  } // end for itObj
810 
811  } // end for itComb
812 
813  } // end for condition
814 
815  } // end for itSeed
816 
817  // eliminate duplicates
818 
819  listMuon.sort();
820  listMuon.unique();
821 
822  listMuonShower.sort();
823  listMuonShower.unique();
824 
825  listEG.sort();
826  listEG.unique();
827 
828  listJet.sort();
829  listJet.unique();
830 
831  listTau.sort();
832  listTau.unique();
833 
834  listETM.sort();
835  listETM.unique();
836 
837  listETT.sort();
838  listETT.unique();
839 
840  listHTT.sort();
841  listHTT.unique();
842 
843  listHTM.sort();
844  listHTM.unique();
845 
846  listETMHF.sort();
847  listETMHF.unique();
848 
849  listJetCounts.sort();
850  listJetCounts.unique();
851 
852  listCentrality.sort();
853  listCentrality.unique();
854 
855  listMinBiasHFP0.sort();
856  listMinBiasHFP0.unique();
857 
858  listMinBiasHFM0.sort();
859  listMinBiasHFM0.unique();
860 
861  listMinBiasHFP1.sort();
862  listMinBiasHFP1.unique();
863 
864  listMinBiasHFM1.sort();
865  listMinBiasHFM1.unique();
866 
867  listTotalEtEm.sort();
868  listTotalEtEm.unique();
869 
870  listMissingEtHF.sort();
871  listMissingEtHF.unique();
872 
873  listTowerCount.sort();
874  listTowerCount.unique();
875 
876  listAsymEt.sort();
877  listAsymEt.unique();
878 
879  listAsymHt.sort();
880  listAsymHt.unique();
881 
882  listAsymEtHF.sort();
883  listAsymEtHF.unique();
884 
885  listAsymHtHF.sort();
886  listAsymHtHF.unique();
887 
888  // record the L1 physics objects in the HLT filterproduct
889  // //////////////////////////////////////////////////////
890 
891  // Muon
892  if (!listMuon.empty()) {
893  edm::Handle<l1t::MuonBxCollection> muons;
894  iEvent.getByToken(m_l1MuonToken, muons);
895 
896  if (!muons.isValid()) {
897  edm::LogWarning("HLTL1TSeed") << "\nWarning: L1MuonBxCollection with input tag " << m_l1MuonTag
898  << "\nrequested in configuration, but not found in the event."
899  << "\nNo muons added to filterproduct." << endl;
900  } else {
901  for (std::list<int>::const_iterator itObj = listMuon.begin(); itObj != listMuon.end(); ++itObj) {
902  // Transform to index for Bx = 0 to begin of BxVector
903  unsigned int index = muons->begin(0) - muons->begin() + *itObj;
904 
905  l1t::MuonRef myref(muons, index);
906  filterproduct.addObject(trigger::TriggerL1Mu, myref);
907  }
908  }
909  }
910 
911  // Muon Shower
912  if (!listMuonShower.empty()) {
913  edm::Handle<l1t::MuonShowerBxCollection> muonShowers;
914  iEvent.getByToken(m_l1MuonShowerToken, muonShowers);
915 
916  if (!muonShowers.isValid()) {
917  edm::LogWarning("HLTL1TSeed") << "\nWarning: L1MuonShowerBxCollection with input tag " << m_l1MuonShowerTag
918  << "\nrequested in configuration, but not found in the event."
919  << "\nNo muon showers added to filterproduct." << endl;
920  } else {
921  for (std::list<int>::const_iterator itObj = listMuonShower.begin(); itObj != listMuonShower.end(); ++itObj) {
922  // Transform to index for Bx = 0 to begin of BxVector
923  unsigned int index = muonShowers->begin(0) - muonShowers->begin() + *itObj;
924 
925  l1t::MuonShowerRef myref(muonShowers, index);
926  filterproduct.addObject(trigger::TriggerL1MuShower, myref);
927  }
928  }
929  }
930 
931  // EG (isolated)
932  if (!listEG.empty()) {
933  edm::Handle<l1t::EGammaBxCollection> egammas;
934  iEvent.getByToken(m_l1EGammaToken, egammas);
935  if (!egammas.isValid()) {
936  edm::LogWarning("HLTL1TSeed") << "\nWarning: L1EGammaBxCollection with input tag " << m_l1EGammaTag
937  << "\nrequested in configuration, but not found in the event."
938  << "\nNo egammas added to filterproduct." << endl;
939  } else {
940  for (std::list<int>::const_iterator itObj = listEG.begin(); itObj != listEG.end(); ++itObj) {
941  // Transform to begin of BxVector
942  unsigned int index = egammas->begin(0) - egammas->begin() + *itObj;
943 
944  l1t::EGammaRef myref(egammas, index);
945  filterproduct.addObject(trigger::TriggerL1EG, myref);
946  }
947  }
948  }
949 
950  // Jet
951  if (!listJet.empty()) {
952  edm::Handle<l1t::JetBxCollection> jets;
953  iEvent.getByToken(m_l1JetToken, jets);
954 
955  if (!jets.isValid()) {
956  edm::LogWarning("HLTL1TSeed") << "\nWarning: L1JetBxCollection with input tag " << m_l1JetTag
957  << "\nrequested in configuration, but not found in the event."
958  << "\nNo jets added to filterproduct." << endl;
959  } else {
960  for (std::list<int>::const_iterator itObj = listJet.begin(); itObj != listJet.end(); ++itObj) {
961  // Transform to begin of BxVector
962  unsigned int index = jets->begin(0) - jets->begin() + *itObj;
963 
964  l1t::JetRef myref(jets, index);
965  filterproduct.addObject(trigger::TriggerL1Jet, myref);
966  }
967  }
968  }
969 
970  // Tau
971  if (!listTau.empty()) {
972  edm::Handle<l1t::TauBxCollection> taus;
973  iEvent.getByToken(m_l1TauToken, taus);
974 
975  if (!taus.isValid()) {
976  edm::LogWarning("HLTL1TSeed") << "\nWarning: L1TauBxCollection with input tag " << m_l1TauTag
977  << "\nrequested in configuration, but not found in the event."
978  << "\nNo taus added to filterproduct." << endl;
979  } else {
980  for (std::list<int>::const_iterator itObj = listTau.begin(); itObj != listTau.end(); ++itObj) {
981  // Transform to begin of BxVector
982  unsigned int index = taus->begin(0) - taus->begin() + *itObj;
983 
984  l1t::TauRef myref(taus, index);
985  filterproduct.addObject(trigger::TriggerL1Tau, myref);
986  }
987  }
988  }
989 
990  // ETT, HTT, ETM, HTM
991  edm::Handle<l1t::EtSumBxCollection> etsums;
992  iEvent.getByToken(m_l1EtSumToken, etsums);
993  if (!etsums.isValid()) {
994  edm::LogWarning("HLTL1TSeed") << "\nWarning: L1EtSumBxCollection with input tag " << m_l1EtSumTag
995  << "\nrequested in configuration, but not found in the event."
996  << "\nNo etsums added to filterproduct." << endl;
997  } else {
998  l1t::EtSumBxCollection::const_iterator iter;
999 
1000  for (iter = etsums->begin(0); iter != etsums->end(0); ++iter) {
1001  l1t::EtSumRef myref(etsums, etsums->key(iter));
1002 
1003  switch (iter->getType()) {
1004  case l1t::EtSum::kTotalEt:
1005  if (!listETT.empty())
1006  filterproduct.addObject(trigger::TriggerL1ETT, myref);
1007  break;
1008  case l1t::EtSum::kTotalHt:
1009  if (!listHTT.empty())
1010  filterproduct.addObject(trigger::TriggerL1HTT, myref);
1011  break;
1012  case l1t::EtSum::kMissingEt:
1013  if (!listETM.empty())
1014  filterproduct.addObject(trigger::TriggerL1ETM, myref);
1015  break;
1016  case l1t::EtSum::kMissingHt:
1017  if (!listHTM.empty())
1018  filterproduct.addObject(trigger::TriggerL1HTM, myref);
1019  break;
1020  case l1t::EtSum::kMissingEtHF:
1021  if (!listETMHF.empty())
1022  filterproduct.addObject(trigger::TriggerL1ETMHF, myref);
1023  break;
1024  case l1t::EtSum::kCentrality:
1025  if (!listCentrality.empty())
1026  filterproduct.addObject(trigger::TriggerL1Centrality, myref);
1027  break;
1028  case l1t::EtSum::kMinBiasHFP0:
1029  if (!listMinBiasHFP0.empty())
1030  filterproduct.addObject(trigger::TriggerL1MinBiasHFP0, myref);
1031  break;
1032  case l1t::EtSum::kMinBiasHFM0:
1033  if (!listMinBiasHFM0.empty())
1034  filterproduct.addObject(trigger::TriggerL1MinBiasHFM0, myref);
1035  break;
1036  case l1t::EtSum::kMinBiasHFP1:
1037  if (!listMinBiasHFP1.empty())
1038  filterproduct.addObject(trigger::TriggerL1MinBiasHFP1, myref);
1039  break;
1040  case l1t::EtSum::kMinBiasHFM1:
1041  if (!listMinBiasHFM1.empty())
1042  filterproduct.addObject(trigger::TriggerL1MinBiasHFM1, myref);
1043  break;
1044  case l1t::EtSum::kTotalEtEm:
1045  if (!listTotalEtEm.empty())
1046  filterproduct.addObject(trigger::TriggerL1TotalEtEm, myref);
1047  break;
1048  case l1t::EtSum::kTowerCount:
1049  if (!listTowerCount.empty())
1050  filterproduct.addObject(trigger::TriggerL1TowerCount, myref);
1051  break;
1052  case l1t::EtSum::kAsymEt:
1053  if (!listAsymEt.empty())
1054  filterproduct.addObject(trigger::TriggerL1AsymEt, myref);
1055  break;
1056  case l1t::EtSum::kAsymHt:
1057  if (!listAsymHt.empty())
1058  filterproduct.addObject(trigger::TriggerL1AsymHt, myref);
1059  break;
1060  case l1t::EtSum::kAsymEtHF:
1061  if (!listAsymEtHF.empty())
1062  filterproduct.addObject(trigger::TriggerL1AsymEtHF, myref);
1063  break;
1064  case l1t::EtSum::kAsymHtHF:
1065  if (!listAsymHtHF.empty())
1066  filterproduct.addObject(trigger::TriggerL1AsymHtHF, myref);
1067  break;
1068  default:
1069  LogTrace("HLTL1TSeed") << " L1EtSum seed of currently unsuported HLT TriggerType. l1t::EtSum type: "
1070  << iter->getType() << "\n";
1071 
1072  } // end switch
1073 
1074  } // end for
1075 
1076  } // end else
1077 
1078  // TODO FIXME uncomment if block when JetCounts implemented
1079 
1080  // // jet counts
1081  // if (!listJetCounts.empty()) {
1082  // edm::Handle<l1extra::L1JetCounts> l1JetCounts;
1083  // iEvent.getByToken(m_l1CollectionsToken.label(), l1JetCounts);
1084  //
1085  // for (std::list<int>::const_iterator itObj = listJetCounts.begin();
1086  // itObj != listJetCounts.end(); ++itObj) {
1087  //
1088  // filterproduct.addObject(trigger::TriggerL1JetCounts,l1extra::L1JetCountsRefProd(l1JetCounts));
1089  // // FIXME: RefProd!
1090  //
1091  // }
1092  //
1093  // }
1094 
1095  LogTrace("HLTL1TSeed") << "\nHLTL1Seed:seedsL1TriggerObjectMaps returning " << seedsResult << endl << endl;
1096 
1097  return seedsResult;
1098 }
GlobalObjectMap::objectTypeVector
const std::vector< L1TObjectTypeInCond > & objectTypeVector() const
Definition: GlobalObjectMap.h:81
HLTL1TSeed::m_l1SeedsLogicalExpression
std::string m_l1SeedsLogicalExpression
Definition: HLTL1TSeed.h:97
HLTL1TSeed::m_l1EtSumToken
edm::EDGetTokenT< l1t::EtSumBxCollection > m_l1EtSumToken
Definition: HLTL1TSeed.h:136
mps_fire.i
i
Definition: mps_fire.py:429
BXVector::key
unsigned int key(const_iterator &iter) const
Definition: BXVector.h:101
HLTL1TSeed::m_l1MuonTag
edm::InputTag m_l1MuonTag
Definition: HLTL1TSeed.h:110
HLTL1TSeed::m_l1MuonShowerTag
edm::InputTag m_l1MuonShowerTag
Definition: HLTL1TSeed.h:115
trigger::TriggerL1Mu
enum start value shifted to 81 so as to avoid clashes with PDG codes
Definition: TriggerTypeDefs.h:30
l1t::GlobalObject
GlobalObject
Definition: GlobalObject.h:16
GlobalObjectMap::combinationVector
const std::vector< CombinationsInCond > & combinationVector() const
Definition: GlobalObjectMap.h:59
MillePedeAlignmentAlgorithm_cfi.algoName
algoName
Definition: MillePedeAlignmentAlgorithm_cfi.py:10
PDWG_EXODelayedJetMET_cff.jets
jets
Definition: PDWG_EXODelayedJetMET_cff.py:14
BXVector::isEmpty
bool isEmpty(int bx) const
cms::cuda::assert
assert(be >=bs)
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
GlobalObjectMap::getCombinationsInCond
const CombinationsInCond * getCombinationsInCond(const std::string &condNameVal) const
return all the combinations passing the requirements imposed in condition condNameVal ...
Definition: GlobalObjectMap.cc:33
BXVector::begin
const_iterator begin(int bx) const
BXVector::size
unsigned size(int bx) const
trigger::TriggerRefsCollections::addObject
void addObject(int id, const reco::RecoEcalCandidateRef &ref)
setters for L3 collections: (id=physics type, and Ref<C>)
Definition: TriggerRefsCollections.h:316
BXVector::const_iterator
std::vector< T >::const_iterator const_iterator
Definition: BXVector.h:18
GlobalObjectMap::algoGtlResult
bool algoGtlResult() const
Definition: GlobalObjectMap.h:53
iEvent
int iEvent
Definition: GenABIO.cc:224
HLTL1TSeed::m_l1JetTag
edm::InputTag m_l1JetTag
Definition: HLTL1TSeed.h:125
HLTL1TSeed::m_l1GtObjectMapTag
edm::InputTag m_l1GtObjectMapTag
InputTag for L1 Global Trigger object maps. This is done per menu. Should be part of Run...
Definition: HLTL1TSeed.h:100
HLTL1TSeed::m_l1JetToken
edm::EDGetTokenT< l1t::JetBxCollection > m_l1JetToken
Definition: HLTL1TSeed.h:126
GlobalLogicParser::operandTokenVector
std::vector< OperandToken > & operandTokenVector()
return the vector of operand tokens
Definition: GlobalLogicParser.h:100
HLTL1TSeed::m_l1AlgoLogicParser
GlobalLogicParser m_l1AlgoLogicParser
logic parser for m_l1SeedsLogicalExpression
Definition: HLTL1TSeed.h:79
HLTL1TSeed::m_l1EGammaToken
edm::EDGetTokenT< l1t::EGammaBxCollection > m_l1EGammaToken
Definition: HLTL1TSeed.h:121
HLTL1TSeed::m_l1EtSumTag
edm::InputTag m_l1EtSumTag
Definition: HLTL1TSeed.h:135
HLTL1TSeed::m_l1TauTag
edm::InputTag m_l1TauTag
Definition: HLTL1TSeed.h:130
BXVector::at
const T & at(int bx, unsigned i) const
GlobalObjectMap::operandTokenVector
const std::vector< GlobalLogicParser::OperandToken > & operandTokenVector() const
Definition: GlobalObjectMap.h:70
GlobalObjectMapRecord::gtObjectMap
const std::vector< GlobalObjectMap > & gtObjectMap() const
get / set the vector of object maps
Definition: GlobalObjectMapRecord.h:64
HLTL1TSeed::m_isDebugEnabled
bool m_isDebugEnabled
cache edm::isDebugEnabled()
Definition: HLTL1TSeed.h:142
HLTL1TSeed::m_l1AlgoSeeds
std::vector< GlobalLogicParser::OperandToken > m_l1AlgoSeeds
list of required algorithms for seeding
Definition: HLTL1TSeed.h:82
GlobalObjectMapRecord::getObjectMap
const GlobalObjectMap * getObjectMap(const std::string &algoNameVal) const
return the object map for the algorithm algoNameVal
Definition: GlobalObjectMapRecord.cc:30
HLTL1TSeed::m_l1EGammaTag
edm::InputTag m_l1EGammaTag
Definition: HLTL1TSeed.h:120
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
GlobalObjectMap::algoName
const std::string & algoName() const
destructor
Definition: GlobalObjectMap.h:42
GlobalObjectMap::algoBitNumber
int algoBitNumber() const
get / set bit number for algorithm in the object map
Definition: GlobalObjectMap.h:47
HLTL1TSeed::m_l1GlobalTag
edm::InputTag m_l1GlobalTag
InputTag for L1 Global Trigger.
Definition: HLTL1TSeed.h:104
HLTL1TSeed::m_l1GlobalToken
edm::EDGetTokenT< GlobalAlgBlkBxCollection > m_l1GlobalToken
Definition: HLTL1TSeed.h:105
BXVector::end
const_iterator end(int bx) const
triggerObjects_cff.bit
bit
Definition: triggerObjects_cff.py:275
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
Tau3MuMonitor_cff.taus
taus
Definition: Tau3MuMonitor_cff.py:7
HLTL1TSeed::m_l1GlobalDecision
bool m_l1GlobalDecision
flag to pass if L1TGlobal accept
Definition: HLTL1TSeed.h:139
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
GlobalLogicParser::expressionResult
virtual const bool expressionResult() const
Definition: GlobalLogicParser.cc:593
CombinationsInCond
std::vector< SingleCombInCond > CombinationsInCond
all the object combinations evaluated to true in the condition
Definition: L1GlobalTriggerObjectMapFwd.h:32
HLTL1TSeed::m_l1MuonToken
edm::EDGetTokenT< l1t::MuonBxCollection > m_l1MuonToken
Definition: HLTL1TSeed.h:111
HLTL1TSeed::m_l1TauToken
edm::EDGetTokenT< l1t::TauBxCollection > m_l1TauToken
Definition: HLTL1TSeed.h:131
HLT_2023v12_cff.distance
distance
Definition: HLT_2023v12_cff.py:5853
HLTL1TSeed::m_l1MuonShowerToken
edm::EDGetTokenT< l1t::MuonShowerBxCollection > m_l1MuonShowerToken
Definition: HLTL1TSeed.h:116
HLTL1TSeed::m_l1GtObjectMapToken
edm::EDGetTokenT< GlobalObjectMapRecord > m_l1GtObjectMapToken
Definition: HLTL1TSeed.h:101

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

Generated for CMSSW Reference Manual by doxygen 1.8.14