#include <HLTLevel1GTSeed.h>

Inheritance diagram for HLTLevel1GTSeed:

Public Member Functions
bool	hltFilter (edm::Event &, const edm::EventSetup &, trigger::TriggerFilterObjectWithRefs &filterproduct) override
	filter the event More...

	HLTLevel1GTSeed (const edm::ParameterSet &)
	constructor More...

	~HLTLevel1GTSeed () override
	destructor More...

Public Member Functions inherited from HLTStreamFilter
	HLTStreamFilter (const edm::ParameterSet &config)

int	module (edm::Event const &) const

const std::string *	moduleLabel () const

int	path (edm::Event const &) const

const std::string *	pathName (edm::Event const &) const

std::pair< int, int >	pmid (edm::Event const &) const

bool	saveTags () const

	~HLTStreamFilter () override

Public Member Functions inherited from edm::stream::EDFilter<>
	EDFilter ()=default

	EDFilter (const EDFilter &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDFilter &	operator= (const EDFilter &)=delete

Public Member Functions inherited from edm::stream::EDFilterBase
	EDFilterBase ()

	EDFilterBase (const EDFilterBase &)=delete

ModuleDescription const &	moduleDescription () const

const EDFilterBase &	operator= (const EDFilterBase &)=delete

	~EDFilterBase () override

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

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

	ProducerBase ()

std::vector < edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
	parameter description More...

Static Public Member Functions inherited from HLTStreamFilter
static void	makeHLTFilterDescription (edm::ParameterSetDescription &desc)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	convertStringToBitNumber ()

void	debugPrint (bool) const

void	dumpTriggerFilterObjectWithRefs (trigger::TriggerFilterObjectWithRefs &) const
	detailed print of filter content More...

const std::vector< L1GtObject > *	objectTypeVec (const int chipNumber, const std::string &cndName) const
	get the vector of object types for a condition cndName on the GTL chip chipNumber More...

bool	seedsL1Extra (edm::Event &, trigger::TriggerFilterObjectWithRefs &) const

bool	seedsL1TriggerObjectMaps (edm::Event &, trigger::TriggerFilterObjectWithRefs &, const L1GtTriggerMask , const L1GlobalTriggerReadoutRecord , const int physicsDaqPartition)
	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...

L1GtLogicParser	m_l1AlgoLogicParser
	logic parser for m_l1SeedsLogicalExpression More...

std::vector < L1GtLogicParser::OperandToken >	m_l1AlgoSeeds
	list of required algorithms for seeding More...

std::vector< std::vector < const std::vector < L1GtObject > * > >	m_l1AlgoSeedsObjType
	vector of object-type vectors for each condition in the required algorithms for seeding More...

std::vector< const std::vector < L1GtLogicParser::TokenRPN > * >	m_l1AlgoSeedsRpn
	vector of Rpn vectors for the required algorithms for seeding More...

edm::InputTag	m_l1CenJetTag

edm::EDGetTokenT < l1extra::L1JetParticleCollection >	m_l1CenJetToken

edm::InputTag	m_l1CollectionsTag
	Meta InputTag for L1 particle collections (except muon) More...

edm::InputTag	m_l1EtMissMETTag

edm::EDGetTokenT < l1extra::L1EtMissParticleCollection >	m_l1EtMissMETToken

edm::InputTag	m_l1EtMissMHTTag

edm::EDGetTokenT < l1extra::L1EtMissParticleCollection >	m_l1EtMissMHTToken

edm::InputTag	m_l1ExtraTag
	cached InputTags More...

edm::InputTag	m_l1ForJetTag

edm::EDGetTokenT < l1extra::L1JetParticleCollection >	m_l1ForJetToken

bool	m_l1GlobalDecision
	replace string "L1GlobalDecision" with bool to speed up the "if" More...

const L1GtTriggerMenu *	m_l1GtMenu
	trigger menu More...

unsigned long long	m_l1GtMenuCacheID

edm::InputTag	m_l1GtObjectMapTag
	InputTag for L1 Global Trigger object maps. More...

edm::EDGetTokenT < L1GlobalTriggerObjectMapRecord >	m_l1GtObjectMapToken

edm::InputTag	m_l1GtReadoutRecordTag
	InputTag for the L1 Global Trigger DAQ readout record. More...

edm::EDGetTokenT < L1GlobalTriggerReadoutRecord >	m_l1GtReadoutRecordToken

edm::ESGetToken < L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd > const	m_l1GtTriggerMaskAlgoTrigRcdToken

edm::ESGetToken < L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd > const	m_l1GtTriggerMaskTechTrigRcdToken

edm::ESGetToken < L1GtTriggerMenu, L1GtTriggerMenuRcd > const	m_l1GtTriggerMenuToken

edm::InputTag	m_l1IsoEGTag

edm::EDGetTokenT < l1extra::L1EmParticleCollection >	m_l1IsoEGToken

edm::InputTag	m_l1IsoTauJetTag

edm::EDGetTokenT < l1extra::L1JetParticleCollection >	m_l1IsoTauJetToken

edm::InputTag	m_l1MuonCollectionTag
	Meta InputTag for L1 muon collection. More...

edm::InputTag	m_l1MuonTag

edm::EDGetTokenT < l1extra::L1MuonParticleCollection >	m_l1MuonToken

edm::InputTag	m_l1NoIsoEGTag

edm::EDGetTokenT < l1extra::L1EmParticleCollection >	m_l1NoIsoEGToken

int	m_l1NrBxInEvent

std::string	m_l1SeedsLogicalExpression

edm::InputTag	m_l1TauJetTag

edm::EDGetTokenT < l1extra::L1JetParticleCollection >	m_l1TauJetToken

bool	m_l1TechTriggerSeeding
	seeding done via technical trigger bits, if value is "true" More...

bool	m_l1UseAliasesForSeeding
	seeding uses algorithm aliases instead of algorithm names, if value is "true" More...

bool	m_l1UseL1TriggerObjectMaps

Additional Inherited Members
Public Types inherited from edm::stream::EDFilter<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Types inherited from edm::stream::EDFilterBase
typedef EDFilterAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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
extraction of the seed objects from L1 GT object map record

Author: : Vasile Mihai Ghete - HEPHY Vienna

Definition at line 50 of file HLTLevel1GTSeed.h.

Constructor & Destructor Documentation

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

explicit

constructor

Definition at line 68 of file HLTLevel1GTSeed.cc.

References convertStringToBitNumber(), L1GtLogicParser::expressionSeedsOperandList(), LogDebug, m_l1AlgoLogicParser, m_l1AlgoSeeds, m_l1AlgoSeedsObjType, m_l1AlgoSeedsRpn, m_l1CollectionsTag, m_l1GlobalDecision, m_l1GtObjectMapTag, m_l1GtReadoutRecordTag, m_l1MuonCollectionTag, m_l1NrBxInEvent, m_l1SeedsLogicalExpression, m_l1TechTriggerSeeding, m_l1UseAliasesForSeeding, m_l1UseL1TriggerObjectMaps, L1GtLogicParser::operandTokenVector(), and findQualityFiles::size.

     : HLTStreamFilter(parSet),
       // initialize the cache
       m_l1GtMenu(nullptr),
       m_l1GtMenuCacheID(0ULL),
 
       // trigger records
       m_l1GtTriggerMenuToken(esConsumes()),
       m_l1GtTriggerMaskAlgoTrigRcdToken(esConsumes()),
       m_l1GtTriggerMaskTechTrigRcdToken(esConsumes()),
 
       // seeding done via L1 trigger object maps, with objects that fired
       m_l1UseL1TriggerObjectMaps(parSet.getParameter<bool>("L1UseL1TriggerObjectMaps")),
 
       // option used forL1UseL1TriggerObjectMaps = False only
       m_l1NrBxInEvent(parSet.getParameter<int>("L1NrBxInEvent")),
 
       // seeding done via technical trigger bits, if value is "true"
       m_l1TechTriggerSeeding(parSet.getParameter<bool>("L1TechTriggerSeeding")),
 
       // seeding uses algorithm aliases instead of algorithm names, if value is "true";
       m_l1UseAliasesForSeeding(parSet.getParameter<bool>("L1UseAliasesForSeeding")),
 
       // logical expression for the required L1 algorithms
       m_l1SeedsLogicalExpression(parSet.getParameter<std::string>("L1SeedsLogicalExpression")),
 
       // InputTag for the L1 Global Trigger DAQ readout record
       m_l1GtReadoutRecordTag(parSet.getParameter<edm::InputTag>("L1GtReadoutRecordTag")),
       m_l1GtReadoutRecordToken(consumes<L1GlobalTriggerReadoutRecord>(m_l1GtReadoutRecordTag)),
 
       // InputTag for L1 Global Trigger object maps
       m_l1GtObjectMapTag(parSet.getParameter<edm::InputTag>("L1GtObjectMapTag")),
       m_l1GtObjectMapToken(consumes<L1GlobalTriggerObjectMapRecord>(m_l1GtObjectMapTag)),
 
       // InputTag for L1 particle collections (except muon)
       m_l1CollectionsTag(parSet.getParameter<edm::InputTag>("L1CollectionsTag")),
 
       // InputTag for L1 muon collection
       m_l1MuonCollectionTag(parSet.getParameter<edm::InputTag>("L1MuonCollectionTag")),
 
       m_l1ExtraTag(edm::InputTag(m_l1CollectionsTag.label())),
       m_l1MuonTag(edm::InputTag(m_l1MuonCollectionTag.label())),
       m_l1MuonToken(consumes<l1extra::L1MuonParticleCollection>(m_l1MuonTag)),
       m_l1IsoEGTag(edm::InputTag(m_l1CollectionsTag.label(), "Isolated")),
       m_l1IsoEGToken(consumes<l1extra::L1EmParticleCollection>(m_l1IsoEGTag)),
       m_l1NoIsoEGTag(edm::InputTag(m_l1CollectionsTag.label(), "NonIsolated")),
       m_l1NoIsoEGToken(consumes<l1extra::L1EmParticleCollection>(m_l1NoIsoEGTag)),
       m_l1CenJetTag(edm::InputTag(m_l1CollectionsTag.label(), "Central")),
       m_l1CenJetToken(consumes<l1extra::L1JetParticleCollection>(m_l1CenJetTag)),
       m_l1ForJetTag(edm::InputTag(m_l1CollectionsTag.label(), "Forward")),
       m_l1ForJetToken(consumes<l1extra::L1JetParticleCollection>(m_l1ForJetTag)),
       m_l1TauJetTag(edm::InputTag(m_l1CollectionsTag.label(), "Tau")),
       m_l1TauJetToken(consumes<l1extra::L1JetParticleCollection>(m_l1TauJetTag)),
       m_l1IsoTauJetTag(edm::InputTag(m_l1CollectionsTag.label(), "IsoTau")),
       m_l1IsoTauJetToken(consumes<l1extra::L1JetParticleCollection>(m_l1IsoTauJetTag)),
       m_l1EtMissMETTag(edm::InputTag(m_l1CollectionsTag.label(), "MET")),
       m_l1EtMissMETToken(consumes<l1extra::L1EtMissParticleCollection>(m_l1EtMissMETTag)),
       m_l1EtMissMHTTag(edm::InputTag(m_l1CollectionsTag.label(), "MHT")),
       m_l1EtMissMHTToken(consumes<l1extra::L1EtMissParticleCollection>(m_l1EtMissMHTTag)),
       m_l1GlobalDecision(false),
       m_isDebugEnabled(edm::isDebugEnabled()) {
   if (m_l1SeedsLogicalExpression != "L1GlobalDecision") {
     // check also the logical expression - add/remove spaces if needed
     m_l1AlgoLogicParser = L1GtLogicParser(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;
   }
 
   // for seeding via technical triggers, convert the "name" to tokenNumber
   // (seeding via bit numbers)
   if (m_l1TechTriggerSeeding) {
     convertStringToBitNumber();
   }
 
   LogDebug("HLTLevel1GTSeed") << "\n"
                               << "L1 Seeding using L1 trigger object maps:       " << m_l1UseL1TriggerObjectMaps << "\n"
                               << "  if false: seeding with L1Extra\n"
                               << "Number of BxInEvent when seeding with L1Extra: " << m_l1NrBxInEvent << "\n"
                               << "  aka w/o object maps\n "
                               << "\n"
                               << "L1 Seeding via Technical Triggers:             " << m_l1TechTriggerSeeding << "\n"
                               << "L1 Seeding uses algorithm aliases:             " << m_l1UseAliasesForSeeding << "\n"
                               << "L1 Seeds Logical Expression:                   "
                               << "\n      " << m_l1SeedsLogicalExpression << "\n"
                               << "Input tag for L1 GT DAQ record:                " << m_l1GtReadoutRecordTag << " \n"
                               << "Input tag for L1 GT object map record:         " << m_l1GtObjectMapTag << " \n"
                               << "Input tag for L1 extra collections:            " << m_l1CollectionsTag << " \n"
                               << "Input tag for L1 muon  collections:            " << m_l1MuonCollectionTag << " \n"
                               << std::endl;
 }

HLTLevel1GTSeed::~HLTLevel1GTSeed ( )

override

destructor

Definition at line 171 of file HLTLevel1GTSeed.cc.

                                   {
   // empty now
 }

Member Function Documentation

void HLTLevel1GTSeed::convertStringToBitNumber ( )

private

for seeding via technical triggers, convert the "name" to tokenNumber (seeding via bit numbers) - done once in constructor

Definition at line 497 of file HLTLevel1GTSeed.cc.

References Exception, mps_fire::i, m_l1AlgoLogicParser, m_l1AlgoSeeds, m_l1SeedsLogicalExpression, L1GtLogicParser::operandTokenVector(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by HLTLevel1GTSeed().

                                                {
   std::vector<L1GtLogicParser::OperandToken>& algOpTokenVector = m_l1AlgoLogicParser.operandTokenVector();
 
   for (auto& i : algOpTokenVector) {
     std::string bitString = i.tokenName;
     std::istringstream bitStream(bitString);
     int bitInt;
 
     if ((bitStream >> bitInt).fail()) {
       throw cms::Exception("FailModule") << "\nL1 Seeds Logical Expression: = '" << m_l1SeedsLogicalExpression << "'"
                                          << "\n  Conversion to integer failed for " << bitString << std::endl;
     }
 
     i.tokenNumber = bitInt;
   }
 
   for (auto& m_l1AlgoSeed : m_l1AlgoSeeds) {
     std::string bitString = m_l1AlgoSeed.tokenName;
     std::istringstream bitStream(bitString);
     int bitInt;
 
     if ((bitStream >> bitInt).fail()) {
       throw cms::Exception("FailModule") << "\nL1 Seeds Logical Expression: = '" << m_l1SeedsLogicalExpression << "'"
                                          << "\n  Conversion to integer failed for " << bitString << std::endl;
     }
 
     m_l1AlgoSeed.tokenNumber = bitInt;
   }
 }

void HLTLevel1GTSeed::debugPrint ( bool newMenu ) const

private

debug print grouped in a single function can be called for a new menu (bool "true") or for a new event

Definition at line 529 of file HLTLevel1GTSeed.cc.

References L1GtTriggerMenu::gtTriggerMenuName(), mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, LogDebug, LogTrace, m_l1AlgoLogicParser, m_l1AlgoSeeds, m_l1AlgoSeedsObjType, m_l1AlgoSeedsRpn, m_l1GtMenu, m_l1TechTriggerSeeding, getGTfromDQMFile::obj, L1GtLogicParser::operandTokenVector(), and findQualityFiles::size.

Referenced by updateAlgoLogicParser().

                                                    {
   if (m_l1TechTriggerSeeding) {
     LogDebug("HLTLevel1GTSeed") << "\n\nupdateAlgoLogicParser: seeding via technical trigger"
                                 << "\n   update event quantities." << std::endl;
 
   } else {
     if (newMenu) {
       LogDebug("HLTLevel1GTSeed") << "\n\nupdateAlgoLogicParser: L1 trigger menu changed to "
                                   << m_l1GtMenu->gtTriggerMenuName() << std::endl;
     } else {
       LogDebug("HLTLevel1GTSeed") << "\n\nupdateAlgoLogicParser: L1 trigger menu unchanged ("
                                   << m_l1GtMenu->gtTriggerMenuName() << ")\n   update event quantities." << std::endl;
     }
   }
 
   std::vector<L1GtLogicParser::OperandToken> const& algOpTokenVector = m_l1AlgoLogicParser.operandTokenVector();
 
   LogTrace("HLTLevel1GTSeed") << "\n\nupdateAlgoLogicParser: algOpTokenVector.size() = " << algOpTokenVector.size()
                               << std::endl;
 
   for (auto const& i : algOpTokenVector) {
     LogTrace("HLTLevel1GTSeed") << "      " << std::setw(5) << i.tokenNumber << "\t" << std::setw(25) << i.tokenName
                                 << "\t" << i.tokenResult << std::endl;
   }
 
   LogTrace("HLTLevel1GTSeed") << std::endl;
 
   LogTrace("HLTLevel1GTSeed") << "\nupdateAlgoLogicParser: m_l1AlgoSeeds.size() = " << m_l1AlgoSeeds.size()
                               << std::endl;
 
   for (auto const& m_l1AlgoSeed : m_l1AlgoSeeds) {
     LogTrace("HLTLevel1GTSeed") << "      " << std::setw(5) << m_l1AlgoSeed.tokenNumber << "\t" << std::setw(25)
                                 << m_l1AlgoSeed.tokenName << "\t" << m_l1AlgoSeed.tokenResult << std::endl;
   }
 
   LogTrace("HLTLevel1GTSeed") << std::endl;
 
   if (!newMenu) {
     return;
   }
 
   LogTrace("HLTLevel1GTSeed") << "\nupdateAlgoLogicParser: m_l1AlgoSeedsRpn.size() = " << m_l1AlgoSeedsRpn.size()
                               << std::endl;
 
   for (auto i : m_l1AlgoSeedsRpn) {
     LogTrace("HLTLevel1GTSeed") << "  Rpn vector size: " << i->size() << std::endl;
 
     for (size_t j = 0; j < i->size(); ++j) {
       LogTrace("HLTLevel1GTSeed") << "      ( " << (*i)[j].operation << ", " << (*i)[j].operand << " )" << std::endl;
     }
   }
 
   LogTrace("HLTLevel1GTSeed") << std::endl;
 
   LogTrace("HLTLevel1GTSeed") << "\nupdateAlgoLogicParser: "
                               << "algorithms in seed expression: m_l1AlgoSeedsObjType.size() = "
                               << m_l1AlgoSeedsObjType.size() << std::endl;
 
   for (auto const& i : m_l1AlgoSeedsObjType) {
     LogTrace("HLTLevel1GTSeed") << "  Conditions for an algorithm: vector size: " << i.size() << std::endl;
 
     for (size_t j = 0; j < i.size(); ++j) {
       LogTrace("HLTLevel1GTSeed") << "    Condition object type vector: size: " << (i[j])->size() << std::endl;
 
       for (size_t k = 0; k < (i[j])->size(); ++k) {
         L1GtObject obj = (*(i[j]))[k];
         LogTrace("HLTLevel1GTSeed") << "      " << obj << " ";
       }
 
       LogTrace("HLTLevel1GTSeed") << std::endl;
     }
   }
 
   LogTrace("HLTLevel1GTSeed") << std::endl;
 }

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

private

detailed print of filter content

Definition at line 1557 of file HLTLevel1GTSeed.cc.

References trigger::TriggerRefsCollections::getObjects(), mps_fire::i, LogDebug, LogTrace, getGTfromDQMFile::obj, trigger::TriggerL1CenJet, trigger::TriggerL1ETM, trigger::TriggerL1ETT, trigger::TriggerL1ForJet, trigger::TriggerL1HTM, trigger::TriggerL1HTT, trigger::TriggerL1IsoEG, trigger::TriggerL1Mu, trigger::TriggerL1NoIsoEG, and trigger::TriggerL1TauJet.

Referenced by hltFilter().

                                                                                                              {
   LogDebug("HLTLevel1GTSeed") << "\nHLTLevel1GTSeed::hltFilter "
                               << "\n  Dump TriggerFilterObjectWithRefs\n"
                               << std::endl;
 
   std::vector<l1extra::L1MuonParticleRef> seedsL1Mu;
 
   std::vector<l1extra::L1EmParticleRef> seedsL1IsoEG;
   std::vector<l1extra::L1EmParticleRef> seedsL1NoIsoEG;
 
   std::vector<l1extra::L1JetParticleRef> seedsL1CenJet;
   std::vector<l1extra::L1JetParticleRef> seedsL1ForJet;
   std::vector<l1extra::L1JetParticleRef> seedsL1TauJet;
   std::vector<l1extra::L1JetParticleRef> seedsL1IsoTauJet;
 
   std::vector<l1extra::L1EtMissParticleRef> seedsL1ETM;
   std::vector<l1extra::L1EtMissParticleRef> seedsL1ETT;
   std::vector<l1extra::L1EtMissParticleRef> seedsL1HTT;
   std::vector<l1extra::L1EtMissParticleRef> seedsL1HTM;
 
   filterproduct.getObjects(trigger::TriggerL1Mu, seedsL1Mu);
   const size_t sizeSeedsL1Mu = seedsL1Mu.size();
 
   filterproduct.getObjects(trigger::TriggerL1IsoEG, seedsL1IsoEG);
   const size_t sizeSeedsL1IsoEG = seedsL1IsoEG.size();
 
   filterproduct.getObjects(trigger::TriggerL1NoIsoEG, seedsL1NoIsoEG);
   const size_t sizeSeedsL1NoIsoEG = seedsL1NoIsoEG.size();
 
   filterproduct.getObjects(trigger::TriggerL1CenJet, seedsL1CenJet);
   const size_t sizeSeedsL1CenJet = seedsL1CenJet.size();
 
   filterproduct.getObjects(trigger::TriggerL1ForJet, seedsL1ForJet);
   const size_t sizeSeedsL1ForJet = seedsL1ForJet.size();
 
   filterproduct.getObjects(trigger::TriggerL1TauJet, seedsL1TauJet);
   const size_t sizeSeedsL1TauJet = seedsL1TauJet.size();
 
   filterproduct.getObjects(trigger::TriggerL1TauJet, seedsL1IsoTauJet);
   const size_t sizeSeedsL1IsoTauJet = seedsL1IsoTauJet.size();
 
   filterproduct.getObjects(trigger::TriggerL1ETM, seedsL1ETM);
   const size_t sizeSeedsL1ETM = seedsL1ETM.size();
 
   filterproduct.getObjects(trigger::TriggerL1ETT, seedsL1ETT);
   const size_t sizeSeedsL1ETT = seedsL1ETT.size();
 
   filterproduct.getObjects(trigger::TriggerL1HTT, seedsL1HTT);
   const size_t sizeSeedsL1HTT = seedsL1HTT.size();
 
   filterproduct.getObjects(trigger::TriggerL1HTM, seedsL1HTM);
   const size_t sizeSeedsL1HTM = seedsL1HTM.size();
 
   LogTrace("HLTLevel1GTSeed") << "  L1Mu seeds:      " << sizeSeedsL1Mu << "\n"
                               << "  L1IsoEG seeds:   " << sizeSeedsL1IsoEG << "\n"
                               << "  L1NoIsoEG seeds: " << sizeSeedsL1NoIsoEG << "\n"
                               << "  L1CenJet seeds:  " << sizeSeedsL1CenJet << "\n"
                               << "  L1ForJet seeds:  " << sizeSeedsL1ForJet << "\n"
                               << "  L1TauJet seeds:  " << sizeSeedsL1TauJet << "\n"
                               << "  L1IsoTauJet seeds:  " << sizeSeedsL1IsoTauJet << "\n"
                               << "  L1ETM seeds:     " << sizeSeedsL1ETM << "\n"
                               << "  L1ETT seeds:     " << sizeSeedsL1ETT << "\n"
                               << "  L1HTT seeds:     " << sizeSeedsL1HTT << "\n"
                               << "  L1HTM seeds:     " << sizeSeedsL1HTM << "\n"
                               << std::endl;
 
   for (size_t i = 0; i != sizeSeedsL1Mu; i++) {
     l1extra::L1MuonParticleRef obj = l1extra::L1MuonParticleRef(seedsL1Mu[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1Mu     "
                                 << "\t"
                                 << "q*PT = " << obj->charge() * obj->pt() << "\t"
                                 << "eta =  " << obj->eta() << "\t"
                                 << "phi =  " << obj->phi() << "\t"
                                 << "BX = " << obj->bx();
   }
 
   for (size_t i = 0; i != sizeSeedsL1IsoEG; i++) {
     l1extra::L1EmParticleRef obj = l1extra::L1EmParticleRef(seedsL1IsoEG[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1IsoEG   "
                                 << "\t"
                                 << "ET =   " << obj->et() << "\t"
                                 << "eta =  " << obj->eta() << "\t"
                                 << "phi =  " << obj->phi() << "\t"
                                 << "BX = " << obj->bx();
     ;
   }
 
   for (size_t i = 0; i != sizeSeedsL1NoIsoEG; i++) {
     l1extra::L1EmParticleRef obj = l1extra::L1EmParticleRef(seedsL1NoIsoEG[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1NoIsoEG"
                                 << "\t"
                                 << "ET =   " << obj->et() << "\t"
                                 << "eta =  " << obj->eta() << "\t"
                                 << "phi =  " << obj->phi() << "\t"
                                 << "BX = " << obj->bx();
   }
 
   for (size_t i = 0; i != sizeSeedsL1CenJet; i++) {
     l1extra::L1JetParticleRef obj = l1extra::L1JetParticleRef(seedsL1CenJet[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1CenJet "
                                 << "\t"
                                 << "ET =   " << obj->et() << "\t"
                                 << "eta =  " << obj->eta() << "\t"
                                 << "phi =  " << obj->phi() << "\t"
                                 << "BX = " << obj->bx();
   }
 
   for (size_t i = 0; i != sizeSeedsL1ForJet; i++) {
     l1extra::L1JetParticleRef obj = l1extra::L1JetParticleRef(seedsL1ForJet[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1ForJet "
                                 << "\t"
                                 << "ET =   " << obj->et() << "\t"
                                 << "eta =  " << obj->eta() << "\t"
                                 << "phi =  " << obj->phi() << "\t"
                                 << "BX = " << obj->bx();
   }
 
   for (size_t i = 0; i != sizeSeedsL1TauJet; i++) {
     l1extra::L1JetParticleRef obj = l1extra::L1JetParticleRef(seedsL1TauJet[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1TauJet "
                                 << "\t"
                                 << "ET =   " << obj->et() << "\t"
                                 << "eta =  " << obj->eta() << "\t"
                                 << "phi =  " << obj->phi() << "\t"
                                 << "BX = " << obj->bx();
   }
 
   for (size_t i = 0; i != sizeSeedsL1IsoTauJet; i++) {
     l1extra::L1JetParticleRef obj = l1extra::L1JetParticleRef(seedsL1IsoTauJet[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1IsoTauJet "
                                 << "\t"
                                 << "ET =   " << obj->et() << "\t"
                                 << "eta =  " << obj->eta() << "\t"
                                 << "phi =  " << obj->phi() << "\t"
                                 << "BX = " << obj->bx();
   }
 
   for (size_t i = 0; i != sizeSeedsL1ETM; i++) {
     l1extra::L1EtMissParticleRef obj = l1extra::L1EtMissParticleRef(seedsL1ETM[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1ETM    "
                                 << "\t"
                                 << "ET =   " << obj->etMiss() << "\t"
                                 << "phi =  " << obj->phi() << "BX =  " << obj->bx();
   }
 
   for (size_t i = 0; i != sizeSeedsL1ETT; i++) {
     l1extra::L1EtMissParticleRef obj = l1extra::L1EtMissParticleRef(seedsL1ETT[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1ETT    "
                                 << "\t"
                                 << "ET =   " << obj->etTotal() << "\t"
                                 << "BX = " << obj->bx();
   }
 
   for (size_t i = 0; i != sizeSeedsL1HTT; i++) {
     l1extra::L1EtMissParticleRef obj = l1extra::L1EtMissParticleRef(seedsL1HTT[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1HTT    "
                                 << "\t"
                                 << "ET =   " << obj->etTotal() << "\t"
                                 << "BX = " << obj->bx();
   }
 
   for (size_t i = 0; i != sizeSeedsL1HTM; i++) {
     l1extra::L1EtMissParticleRef obj = l1extra::L1EtMissParticleRef(seedsL1HTM[i]);
 
     LogTrace("HLTLevel1GTSeed") << "L1HTM    "
                                 << "\t"
                                 << "ET =   " << obj->etMiss() << "\t"
                                 << "phi =  " << obj->phi() << "BX =  " << obj->bx();
   }
 
   LogTrace("HLTLevel1GTSeed") << " \n\n" << std::endl;
 }

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

static

parameter description

Definition at line 177 of file HLTLevel1GTSeed.cc.

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

                                                                                  {
   edm::ParameterSetDescription desc;
   makeHLTFilterDescription(desc);
 
   // # default: true
   // #    seeding done via L1 trigger object maps, with objects that fired
   // #    only objects from the central BxInEvent (L1A) are used
   // # if false:
   // #    seeding is done ignoring if a L1 object fired or not,
   // #    adding all L1EXtra objects corresponding to the object types
   // #    used in all conditions from the algorithms in logical expression
   // #    for a given number of BxInEvent
   desc.add<bool>("L1UseL1TriggerObjectMaps", true);
 
   // # option used forL1UseL1TriggerObjectMaps = False only
   // # number of BxInEvent: 1: L1A=0; 3: -1, L1A=0, 1; 5: -2, -1, L1A=0, 1, 2
   desc.add<int>("L1NrBxInEvent", 3);
 
   // # seeding done via technical trigger bits, if value is "true";
   // # default: false (seeding via physics algorithms)
   desc.add<bool>("L1TechTriggerSeeding", false);
 
   // # seeding done with aliases for physics algorithms
   desc.add<bool>("L1UseAliasesForSeeding", true);
 
   // # 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<std::string>("L1SeedsLogicalExpression", "");
 
   // # InputTag for the L1 Global Trigger DAQ readout record
   // #   GT Emulator = gtDigis
   // #   GT Unpacker = l1GtUnpack
   // #
   // #   cloned GT unpacker in HLT = gtDigis
   desc.add<edm::InputTag>("L1GtReadoutRecordTag", edm::InputTag("gtDigis"));
 
   // # InputTag for L1 Global Trigger object maps
   // #   only the emulator produces the object maps
   // #   GT Emulator = gtDigis
   // #
   // #   cloned GT emulator in HLT = l1GtObjectMap
   desc.add<edm::InputTag>("L1GtObjectMapTag", edm::InputTag("l1GtObjectMap"));
 
   // # InputTag for L1 particle collections (except muon)
   // #   L1 Extra = l1extraParticles
   desc.add<edm::InputTag>("L1CollectionsTag", edm::InputTag("l1extraParticles"));
 
   // # InputTag for L1 muon collection
   // #   L1 Extra = l1extraParticles
   desc.add<edm::InputTag>("L1MuonCollectionTag", edm::InputTag("l1extraParticles"));
 
   descriptions.add("hltLevel1GTSeed", desc);
 }

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

overridevirtual

filter the event

Implements HLTStreamFilter.

Definition at line 234 of file HLTLevel1GTSeed.cc.

References trigger::TriggerFilterObjectWithRefs::addCollectionTag(), dumpTriggerFilterObjectWithRefs(), L1GtLogicParser::expressionResult(), edm::EventSetup::get(), edm::Event::getByToken(), edm::EventSetup::getHandle(), edm::HandleBase::isValid(), LogTrace, m_isDebugEnabled, m_l1AlgoLogicParser, m_l1CenJetTag, m_l1EtMissMETTag, m_l1EtMissMHTTag, m_l1ExtraTag, m_l1ForJetTag, m_l1GlobalDecision, m_l1GtMenu, m_l1GtMenuCacheID, m_l1GtReadoutRecordTag, m_l1GtReadoutRecordToken, m_l1GtTriggerMaskAlgoTrigRcdToken, m_l1GtTriggerMaskTechTrigRcdToken, m_l1GtTriggerMenuToken, m_l1IsoEGTag, m_l1IsoTauJetTag, m_l1MuonTag, m_l1NoIsoEGTag, m_l1TauJetTag, m_l1TechTriggerSeeding, m_l1UseAliasesForSeeding, m_l1UseL1TriggerObjectMaps, edm::Handle< T >::product(), HLTStreamFilter::saveTags(), seedsL1Extra(), seedsL1TriggerObjectMaps(), and updateAlgoLogicParser().

                                                                                    {
   // all HLT filters must create and fill a HLT filter object,
   // recording any reconstructed physics objects satisfying
   // this HLT filter, and place it in the event.
 
   // the filter object
   if (saveTags()) {
     filterproduct.addCollectionTag(m_l1MuonTag);
     filterproduct.addCollectionTag(m_l1ExtraTag);
     filterproduct.addCollectionTag(m_l1IsoEGTag);
     filterproduct.addCollectionTag(m_l1NoIsoEGTag);
     filterproduct.addCollectionTag(m_l1CenJetTag);
     filterproduct.addCollectionTag(m_l1ForJetTag);
     filterproduct.addCollectionTag(m_l1TauJetTag);
     filterproduct.addCollectionTag(m_l1IsoTauJetTag);
     filterproduct.addCollectionTag(m_l1EtMissMETTag);
     filterproduct.addCollectionTag(m_l1EtMissMHTTag);
   }
 
   // get the trigger mask from the EventSetup
   auto const& l1GtTmAlgo = evSetup.getHandle(m_l1GtTriggerMaskAlgoTrigRcdToken);
 
   // get L1GlobalTriggerReadoutRecord and GT decision
   edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecord;
   iEvent.getByToken(m_l1GtReadoutRecordToken, gtReadoutRecord);
   const L1GlobalTriggerReadoutRecord* gtReadoutRecordPtr = gtReadoutRecord.product();
 
   if (!gtReadoutRecord.isValid()) {
     edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1GlobalTriggerReadoutRecord with input tag "
                                        << m_l1GtReadoutRecordTag
                                        << "\nrequested in configuration, but not found in the event." << std::endl;
     return false;
   }
 
   //
   uint16_t gtFinalOR = gtReadoutRecord->finalOR();
   int physicsDaqPartition = 0;
   bool gtDecision = static_cast<bool>(gtFinalOR & (1 << physicsDaqPartition));
 
   // GT global decision "false" possible only when running on MC or on random triggers
   if (!gtDecision) {
     return false;
 
   } else {
     // by convention, "L1GlobalDecision" logical expression means global decision
     if (m_l1GlobalDecision) {
       // return the full L1GlobalTriggerObjectMapRecord in filter format FIXME
       return true;
     }
   }
 
   // seeding done via technical trigger bits
   if (m_l1TechTriggerSeeding) {
     // get the technical trigger mask from the EventSetup
     auto const& l1GtTmTech = evSetup.getHandle(m_l1GtTriggerMaskTechTrigRcdToken);
 
     // get Global Trigger technical trigger word, update the tokenResult members
     // from m_l1AlgoLogicParser and get the result for the logical expression
     const std::vector<bool>& gtTechTrigWord = gtReadoutRecord->technicalTriggerWord();
     updateAlgoLogicParser(gtTechTrigWord, l1GtTmTech->gtTriggerMask(), physicsDaqPartition);
 
     // always empty filter - GT not aware of objects for technical triggers
     bool seedsResult = m_l1AlgoLogicParser.expressionResult();
 
     if (seedsResult) {
       return true;
     } else {
       return false;
     }
   }
 
   // seeding via physics algorithms
 
   // get / update the trigger menu from the EventSetup
   // local cache & check on cacheIdentifier
 
   unsigned long long l1GtMenuCacheID = evSetup.get<L1GtTriggerMenuRcd>().cacheIdentifier();
 
   if (m_l1GtMenuCacheID != l1GtMenuCacheID) {
     auto const& l1GtMenu = evSetup.getHandle(m_l1GtTriggerMenuToken);
     m_l1GtMenu = l1GtMenu.product();
     m_l1GtMenuCacheID = l1GtMenuCacheID;
 
     const AlgorithmMap& algorithmMap = l1GtMenu->gtAlgorithmMap();
     const AlgorithmMap& algorithmAliasMap = l1GtMenu->gtAlgorithmAliasMap();
 
     LogTrace("HLTLevel1GTSeed") << "\n L1 trigger menu " << l1GtMenu->gtTriggerMenuInterface()
                                 << "\n    Number of algorithm names:   " << (algorithmMap.size())
                                 << "\n    Number of algorithm aliases: " << (algorithmAliasMap.size()) << "\n"
                                 << std::endl;
 
     // update also the tokenNumber members (holding the bit numbers) from m_l1AlgoLogicParser
     if (m_l1UseAliasesForSeeding) {
       updateAlgoLogicParser(m_l1GtMenu, algorithmAliasMap);
     } else {
       updateAlgoLogicParser(m_l1GtMenu, algorithmMap);
     }
   }
 
   // FinalOR is true, it was tested before
   if (m_l1UseL1TriggerObjectMaps) {
     if (not seedsL1TriggerObjectMaps(
             iEvent, filterproduct, l1GtTmAlgo.product(), gtReadoutRecordPtr, physicsDaqPartition))
       return false;
   } else {
     if (not seedsL1Extra(iEvent, filterproduct))
       return false;
   }
 
   if (m_isDebugEnabled) {
     dumpTriggerFilterObjectWithRefs(filterproduct);
   }
 
   return true;
 }

const std::vector< L1GtObject > * HLTLevel1GTSeed::objectTypeVec	(	const int	chipNumber,
		const std::string &	cndName
	)		const

private

get the vector of object types for a condition cndName on the GTL chip chipNumber

Definition at line 352 of file HLTLevel1GTSeed.cc.

References Exception, L1GtTriggerMenu::gtConditionMap(), and m_l1GtMenu.

Referenced by updateAlgoLogicParser().

                                                                                                             {
   const ConditionMap& conditionMap = (m_l1GtMenu->gtConditionMap()).at(chipNr);
 
   auto itCond = conditionMap.find(cndName);
   if (itCond != conditionMap.end())
     return (&((itCond->second)->objectType()));
 
   // this should never be happen, all conditions are in the maps
   throw cms::Exception("FailModule") << "\nCondition " << cndName << " not found in the condition map"
                                      << " for chip number " << chipNr;
 }

bool HLTLevel1GTSeed::seedsL1Extra	(	edm::Event &	iEvent,
		trigger::TriggerFilterObjectWithRefs &	filterproduct
	)		const

private

seeding is done ignoring if a L1 object fired or not if the event is selected at L1, fill all the L1 objects of types corresponding to the L1 conditions from the seeding logical expression for bunch crosses F, 0, 1 directly from L1Extra and use them as seeds at HLT method and filter return true if at least an object is filled

Definition at line 1128 of file HLTLevel1GTSeed.cc.

Referenced by hltFilter().

                                                                                                             {
   //    if (m_isDebugEnabled) {
   //
   //        LogTrace("HLTLevel1GTSeed") << "\n Printing muons from gtDigis\n " << std::endl;
   //
   //        edm::Handle<std::vector<L1MuGMTCand> > muonData;
   //        iEvent.getByToken("gtDigis", muonData);
   //
   //        if (!muonData.isValid()) {
   //            edm::LogWarning("HLTLevel1GTSeed")
   //                    << "\nWarning: std::vector<L1MuGMTCand> with input tag "
   //                    << "gtDigis"
   //                    << "\nrequested in configuration, but not found in the event.\n"
   //                    << std::endl;
   //        } else {
   //
   //            std::vector<L1MuGMTCand>::const_iterator itMuon;
   //            for (itMuon = muonData->begin(); itMuon != muonData->end(); itMuon++) {
   //
   //                LogTrace("HLTLevel1GTSeed") << (*itMuon) << std::endl;
   //
   //            }
   //
   //        }
   //    }
 
   // define bools to prevent entering more copies of the objects
   bool includeMuon = true;
 
   bool includeIsoEG = true;
   bool includeNoIsoEG = true;
 
   bool includeCenJet = true;
   bool includeForJet = true;
   bool includeTauJet = true;
   bool includeIsoTauJet = true;
 
   bool includeETM = true;
   bool includeETT = true;
   bool includeHTT = true;
   bool includeHTM = true;
 
   bool includeJetCounts = true;
 
   //
   bool objectsInFilter = false;
 
   // loop over the list of required algorithms for seeding
   int iAlgo = -1;
 
   for (auto const& m_l1AlgoSeed : m_l1AlgoSeeds) {
     //
     iAlgo++;
     //
     int algBit = m_l1AlgoSeed.tokenNumber;
     std::string algName = m_l1AlgoSeed.tokenName;
     bool algResult = m_l1AlgoSeed.tokenResult;
 
     LogTrace("HLTLevel1GTSeed") << "\nHLTLevel1GTSeed::hltFilter "
                                 << "\n  Algorithm " << algName << " with bit number " << algBit
                                 << " in the object map seed list"
                                 << "\n  Algorithm result = " << algResult << std::endl;
 
     const std::vector<const std::vector<L1GtObject>*>& algoSeedsObjTypeVec = m_l1AlgoSeedsObjType[iAlgo];
 
     int minBxInEvent = (m_l1NrBxInEvent + 1) / 2 - m_l1NrBxInEvent;
     int maxBxInEvent = (m_l1NrBxInEvent + 1) / 2 - 1;
 
     // loop over all object types found for an algorithm and fill the lists
     //
     for (auto condObj : algoSeedsObjTypeVec) {
       for (auto itObj : (*condObj)) {
         LogTrace("HLTLevel1GTSeed") << "  Object type in conditions from this algorithm = " << itObj << std::endl;
 
         switch (itObj) {
           case Mu: {
             if (includeMuon) {
               edm::Handle<l1extra::L1MuonParticleCollection> l1Muon;
               iEvent.getByToken(m_l1MuonToken, l1Muon);
 
               if (!l1Muon.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1MuonParticleCollection with input tag " << m_l1MuonTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo muon added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1Muon->begin(); objIter != l1Muon->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1Mu, l1extra::L1MuonParticleRef(l1Muon, iObj));
                   }
                 }
               }
               includeMuon = false;
             }
           }
 
           break;
           case IsoEG: {
             if (includeIsoEG) {
               edm::Handle<l1extra::L1EmParticleCollection> l1IsoEG;
               iEvent.getByToken(m_l1IsoEGToken, l1IsoEG);
 
               if (!l1IsoEG.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1EmParticleCollection with input tag " << m_l1IsoEGTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo IsoEG added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1IsoEG->begin(); objIter != l1IsoEG->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1IsoEG, l1extra::L1EmParticleRef(l1IsoEG, iObj));
                   }
                 }
               }
               includeIsoEG = false;
             }
 
           } break;
           case NoIsoEG: {
             if (includeNoIsoEG) {
               edm::Handle<l1extra::L1EmParticleCollection> l1NoIsoEG;
               iEvent.getByToken(m_l1NoIsoEGToken, l1NoIsoEG);
 
               if (!l1NoIsoEG.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1EmParticleCollection with input tag " << m_l1NoIsoEGTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo NoIsoEG added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1NoIsoEG->begin(); objIter != l1NoIsoEG->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1NoIsoEG, l1extra::L1EmParticleRef(l1NoIsoEG, iObj));
                   }
                 }
               }
               includeNoIsoEG = false;
             }
 
           } break;
           case CenJet: {
             if (includeCenJet) {
               edm::Handle<l1extra::L1JetParticleCollection> l1CenJet;
               iEvent.getByToken(m_l1CenJetToken, l1CenJet);
 
               if (!l1CenJet.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1JetParticleCollection with input tag " << m_l1CenJetTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo CenJet added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1CenJet->begin(); objIter != l1CenJet->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1CenJet, l1extra::L1JetParticleRef(l1CenJet, iObj));
                   }
                 }
               }
               includeCenJet = false;
             }
 
           }
 
           break;
           case ForJet: {
             if (includeForJet) {
               edm::Handle<l1extra::L1JetParticleCollection> l1ForJet;
               iEvent.getByToken(m_l1ForJetToken, l1ForJet);
 
               if (!l1ForJet.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1JetParticleCollection with input tag " << m_l1ForJetTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo ForJet added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1ForJet->begin(); objIter != l1ForJet->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1ForJet, l1extra::L1JetParticleRef(l1ForJet, iObj));
                   }
                 }
               }
               includeForJet = false;
             }
 
           }
 
           break;
           case TauJet: {
             if (includeTauJet) {
               edm::Handle<l1extra::L1JetParticleCollection> l1TauJet;
               iEvent.getByToken(m_l1TauJetToken, l1TauJet);
 
               if (!l1TauJet.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1JetParticleCollection with input tag " << m_l1TauJetTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo TauJet added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1TauJet->begin(); objIter != l1TauJet->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1TauJet, l1extra::L1JetParticleRef(l1TauJet, iObj));
                   }
                 }
               }
               includeTauJet = false;
             }
           } break;
           case HfRingEtSums: {
             if (includeIsoTauJet) {
               edm::Handle<l1extra::L1JetParticleCollection> l1IsoTauJet;
               iEvent.getByToken(m_l1IsoTauJetToken, l1IsoTauJet);
 
               if (!l1IsoTauJet.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1JetParticleCollection with input tag " << m_l1IsoTauJetTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo IsoTauJet added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1IsoTauJet->begin(); objIter != l1IsoTauJet->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1TauJet, l1extra::L1JetParticleRef(l1IsoTauJet, iObj));
                   }
                 }
               }
               includeIsoTauJet = false;
             }
 
           }
 
           break;
           case ETM: {
             if (includeETM) {
               edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
               iEvent.getByToken(m_l1EtMissMETToken, l1EnergySums);
 
               if (!l1EnergySums.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMETTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo ETM added to filterproduct." << std::endl;
 
               } else if (l1EnergySums->empty()) {
                 edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag "
                                                    << m_l1EtMissMETTag << "\nfound in the event but with 0 size."
                                                    << "\nNo ETM added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1EnergySums->begin(); objIter != l1EnergySums->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1ETM, l1extra::L1EtMissParticleRef(l1EnergySums, iObj));
                   }
                 }
               }
               includeETM = false;
             }
 
           }
 
           break;
           case ETT: {
             if (includeETT) {
               edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
               iEvent.getByToken(m_l1EtMissMETToken, l1EnergySums);
 
               if (!l1EnergySums.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMETTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo ETT added to filterproduct." << std::endl;
 
               } else if (l1EnergySums->empty()) {
                 edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag "
                                                    << m_l1EtMissMETTag << "\nfound in the event but with 0 size."
                                                    << "\nNo ETT added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1EnergySums->begin(); objIter != l1EnergySums->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1ETT, l1extra::L1EtMissParticleRef(l1EnergySums, iObj));
                   }
                 }
               }
               includeETT = false;
             }
 
           }
 
           break;
           case HTT: {
             if (includeHTT) {
               edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
               iEvent.getByToken(m_l1EtMissMHTToken, l1EnergySums);
 
               if (!l1EnergySums.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMHTTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo HTT added to filterproduct." << std::endl;
 
               } else if (l1EnergySums->empty()) {
                 edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag "
                                                    << m_l1EtMissMHTTag << "\nfound in the event but with 0 size."
                                                    << "\nNo HTT added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1EnergySums->begin(); objIter != l1EnergySums->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1HTT, l1extra::L1EtMissParticleRef(l1EnergySums, iObj));
                   }
                 }
               }
               includeHTT = false;
             }
           }
 
           break;
           case HTM: {
             if (includeHTM) {
               edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
               iEvent.getByToken(m_l1EtMissMHTToken, l1EnergySums);
 
               if (!l1EnergySums.isValid()) {
                 edm::LogWarning("HLTLevel1GTSeed")
                     << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMHTTag
                     << "\nrequested in configuration, but not found in the event."
                     << "\nNo HTM added to filterproduct." << std::endl;
 
               } else if (l1EnergySums->empty()) {
                 edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag "
                                                    << m_l1EtMissMHTTag << "\nfound in the event but with 0 size."
                                                    << "\nNo HTM added to filterproduct." << std::endl;
 
               } else {
                 int iObj = -1;
                 for (auto objIter = l1EnergySums->begin(); objIter != l1EnergySums->end(); ++objIter) {
                   iObj++;
 
                   int bxNr = objIter->bx();
                   if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
                     objectsInFilter = true;
                     filterproduct.addObject(trigger::TriggerL1HTM, l1extra::L1EtMissParticleRef(l1EnergySums, iObj));
                   }
                 }
               }
               includeHTM = false;
             }
           }
 
           break;
           case JetCounts: {
             if (includeJetCounts) {
               // do nothing, JetCounts do not exist now
             }
           }
 
           break;
           default: {
             // should not arrive here
 
             LogDebug("HLTLevel1GTSeed") << "\n    HLTLevel1GTSeed::hltFilter "
                                         << "\n      Unknown object of type " << itObj << " in the seed list."
                                         << std::endl;
           } break;
         }
       }
     }
 
     LogTrace("HLTLevel1GTSeed") << std::endl;
   }
 
   return objectsInFilter;
 }

bool HLTLevel1GTSeed::seedsL1TriggerObjectMaps	(	edm::Event &	iEvent,
		trigger::TriggerFilterObjectWithRefs &	filterproduct,
		const L1GtTriggerMask *	l1GtTmAlgo,
		const L1GlobalTriggerReadoutRecord *	gtReadoutRecordPtr,
		const int	physicsDaqPartition
	)

private

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

Definition at line 606 of file HLTLevel1GTSeed.cc.

References trigger::TriggerRefsCollections::addObject(), CenJet, L1GlobalTriggerReadoutRecord::decisionWord(), ETM, ETT, L1GtLogicParser::expressionResult(), L1GtLogicParser::expressionSeedsOperandList(), ForJet, edm::Event::getByToken(), L1GlobalTriggerObjectMap::getCombinationsInCond(), L1GtTriggerMask::gtTriggerMask(), HfRingEtSums, HTM, HTT, IsoEG, edm::HandleBase::isValid(), JetCounts, LogDebug, LogTrace, m_isDebugEnabled, m_l1AlgoLogicParser, m_l1AlgoSeeds, m_l1AlgoSeedsObjType, m_l1AlgoSeedsRpn, m_l1CenJetTag, m_l1CenJetToken, m_l1EtMissMETTag, m_l1EtMissMETToken, m_l1EtMissMHTTag, m_l1EtMissMHTToken, m_l1ForJetTag, m_l1ForJetToken, m_l1GtObjectMapToken, m_l1GtReadoutRecordTag, m_l1IsoEGTag, m_l1IsoEGToken, m_l1IsoTauJetTag, m_l1IsoTauJetToken, m_l1MuonTag, m_l1MuonToken, m_l1NoIsoEGTag, m_l1NoIsoEGToken, m_l1SeedsLogicalExpression, m_l1TauJetTag, m_l1TauJetToken, Mu, NoIsoEG, L1GlobalTriggerObjectMap::operandTokenVector(), L1GlobalTriggerReadoutRecord::printGtDecision(), AlCaHLTBitMon_QueryRunRegistry::string, TauJet, trigger::TriggerL1CenJet, trigger::TriggerL1ETM, trigger::TriggerL1ETT, trigger::TriggerL1ForJet, trigger::TriggerL1HTM, trigger::TriggerL1HTT, trigger::TriggerL1IsoEG, trigger::TriggerL1Mu, trigger::TriggerL1NoIsoEG, trigger::TriggerL1TauJet, and updateAlgoLogicParser().

Referenced by hltFilter().

                                                                               {
   // get Global Trigger decision word, update the tokenResult members
   // from m_l1AlgoLogicParser and get the result for the logical expression
   const std::vector<bool>& gtDecisionWord = gtReadoutRecordPtr->decisionWord();
   updateAlgoLogicParser(gtDecisionWord, l1GtTmAlgo->gtTriggerMask(), physicsDaqPartition);
 
   bool seedsResult = m_l1AlgoLogicParser.expressionResult();
 
   if (m_isDebugEnabled) {
     // define an output stream to print into
     // it can then be directed to whatever log level is desired
     std::ostringstream myCoutStream;
     gtReadoutRecordPtr->printGtDecision(myCoutStream);
 
     LogTrace("HLTLevel1GTSeed") << myCoutStream.str() << "\nHLTLevel1GTSeed::hltFilter "
                                 << "\nLogical expression (names) = '" << m_l1SeedsLogicalExpression << "'"
                                 << "\n  Result for logical expression: " << seedsResult << "\n"
                                 << std::endl;
   }
 
   // the evaluation of the logical expression is false - skip event
   if (!seedsResult) {
     return false;
   }
 
   // define index lists for all particle types
 
   std::list<int> listMuon;
 
   std::list<int> listIsoEG;
   std::list<int> listNoIsoEG;
 
   std::list<int> listCenJet;
   std::list<int> listForJet;
   std::list<int> listTauJet;
   std::list<int> listIsoTauJet;
 
   std::list<int> listETM;
   std::list<int> listETT;
   std::list<int> listHTT;
   std::list<int> listHTM;
 
   std::list<int> listJetCounts;
 
   // get handle to object maps (one object map per algorithm)
   edm::Handle<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord;
   iEvent.getByToken(m_l1GtObjectMapToken, gtObjectMapRecord);
 
   if (!gtObjectMapRecord.isValid()) {
     edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1GlobalTriggerObjectMapRecord with input tag "
                                        << m_l1GtReadoutRecordTag
                                        << "\nrequested in configuration, but not found in the event." << std::endl;
 
     return false;
   }
 
   // TODO check that the L1GlobalTriggerObjectMapRecord corresponds to the same menu as
   // the menu run by HLTLevel1GTSeed
   //     true normally online (they are run in the same job)
   //     can be false offline, when re-running HLT without re-running the object map producer
 
   // loop over the list of required algorithms for seeding
   int iAlgo = -1;
 
   for (std::vector<L1GtLogicParser::OperandToken>::const_iterator itSeed = m_l1AlgoSeeds.begin();
        itSeed != m_l1AlgoSeeds.end();
        ++itSeed) {
     //
     iAlgo++;
     //
     int algBit = (*itSeed).tokenNumber;
     std::string algName = (*itSeed).tokenName;
     bool algResult = (*itSeed).tokenResult;
 
     LogTrace("HLTLevel1GTSeed") << "\nHLTLevel1GTSeed::hltFilter "
                                 << "\n  Algorithm " << algName << " with bit number " << algBit
                                 << " in the object map seed list"
                                 << "\n  Algorithm result = " << algResult << "\n"
                                 << std::endl;
 
     // algorithm result is false - no seeds
     if (!algResult) {
       continue;
     }
 
     // algorithm result is true - get object map, loop over conditions in the algorithm
     const L1GlobalTriggerObjectMap* objMap = gtObjectMapRecord->getObjectMap(algBit);
 
     if (objMap == nullptr) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1GlobalTriggerObjectMap for algorithm  " << algName
                                          << " (bit number " << algBit << ") does not exist.\nReturn false.\n"
                                          << std::endl;
       return false;
     }
 
     const std::vector<L1GtLogicParser::OperandToken>& opTokenVecObjMap = objMap->operandTokenVector();
 
     const std::vector<L1GtLogicParser::TokenRPN>& algoSeedsRpn = *(m_l1AlgoSeedsRpn.at(iAlgo));
 
     const std::vector<const std::vector<L1GtObject>*>& algoSeedsObjTypeVec = m_l1AlgoSeedsObjType[iAlgo];
 
     //
     L1GtLogicParser logicParserConditions(algoSeedsRpn, opTokenVecObjMap);
 
     // get list of required conditions for seeding - loop over
     std::vector<L1GtLogicParser::OperandToken> condSeeds = logicParserConditions.expressionSeedsOperandList();
 
     if (m_isDebugEnabled) {
       LogTrace("HLTLevel1GTSeed") << "\n  HLTLevel1GTSeed::hltFilter "
                                   << "\n    condSeeds.size() = " << condSeeds.size() << std::endl;
 
       for (auto& condSeed : condSeeds) {
         LogTrace("HLTLevel1GTSeed") << "      " << std::setw(5) << condSeed.tokenNumber << "\t" << std::setw(25)
                                     << condSeed.tokenName << "\t" << condSeed.tokenResult << std::endl;
       }
 
       LogTrace("HLTLevel1GTSeed") << std::endl;
     }
 
     for (std::vector<L1GtLogicParser::OperandToken>::const_iterator itCond = condSeeds.begin();
          itCond != condSeeds.end();
          itCond++) {
       std::string cndName = (*itCond).tokenName;
       int cndNumber = (*itCond).tokenNumber;
       bool cndResult = (*itCond).tokenResult;
 
       const std::vector<L1GtObject>* cndObjTypeVec = algoSeedsObjTypeVec.at(cndNumber);
 
       //LogTrace("HLTLevel1GTSeed")
       //    << "\n  HLTLevel1GTSeed::hltFilter "
       //    << "\n    Condition " << cndName << " with number " << cndNumber
       //    << " in the seed list"
       //    << "\n    Condition result = " << cndResult << "\n"
       //    << std::endl;
 
       if (!cndResult) {
         continue;
       }
 
       // loop over combinations for a given condition
 
       const CombinationsInCond* cndComb = objMap->getCombinationsInCond(cndNumber);
 
       for (auto const& itComb : (*cndComb)) {
         // loop over objects in a combination for a given condition
         int iObj = 0;
         for (auto itObject = itComb.begin(); itObject != itComb.end(); itObject++) {
           // get object type and push indices on the list
           const L1GtObject objTypeVal = (*cndObjTypeVec).at(iObj);
 
           //LogTrace("HLTLevel1GTSeed")
           //    << "\n    HLTLevel1GTSeed::hltFilter "
           //    << "\n      Add object of type " << objTypeVal
           //    << " and index " << (*itObject) << " to the seed list."
           //    << std::endl;
 
           switch (objTypeVal) {
             case Mu: {
               listMuon.push_back(*itObject);
             }
 
             break;
             case NoIsoEG: {
               listNoIsoEG.push_back(*itObject);
             }
 
             break;
             case IsoEG: {
               listIsoEG.push_back(*itObject);
             }
 
             break;
             case CenJet: {
               listCenJet.push_back(*itObject);
             }
 
             break;
             case ForJet: {
               listForJet.push_back(*itObject);
             }
 
             break;
             case TauJet: {
               listTauJet.push_back(*itObject);
             }
 
             break;
             case HfRingEtSums: {
               // Special treatment needed to match HFRingEtSums index (Ind) with corresponding l1extra item
               // Same ranking (Et) is assumed for both HFRingEtSums indexes and items in l1extra IsoTau collection
               // Each HFRingEtSums_IndN corresponds with one object (with (*itObject)=0);
               // its index (hfInd) encodded by parsing algorithm name
               int hfInd = (*itObject);
               if (cndName.find("Ind0") != std::string::npos)
                 hfInd = 0;
               else if (cndName.find("Ind1") != std::string::npos)
                 hfInd = 1;
               else if (cndName.find("Ind2") != std::string::npos)
                 hfInd = 2;
               else if (cndName.find("Ind3") != std::string::npos)
                 hfInd = 3;
               listIsoTauJet.push_back(hfInd);
             }
 
             break;
             case ETM: {
               listETM.push_back(*itObject);
 
             }
 
             break;
             case ETT: {
               listETT.push_back(*itObject);
 
             }
 
             break;
             case HTT: {
               listHTT.push_back(*itObject);
 
             }
 
             break;
             case HTM: {
               listHTM.push_back(*itObject);
 
             }
 
             break;
             case JetCounts: {
               listJetCounts.push_back(*itObject);
             }
 
             break;
             default: {
               // should not arrive here
 
               LogDebug("HLTLevel1GTSeed") << "\n    HLTLevel1GTSeed::hltFilter "
                                           << "\n      Unknown object of type " << objTypeVal << " and index "
                                           << (*itObject) << " in the seed list." << std::endl;
             } break;
           }
 
           iObj++;
         }
       }
     }
   }
 
   // eliminate duplicates
 
   listMuon.sort();
   listMuon.unique();
 
   listIsoEG.sort();
   listIsoEG.unique();
 
   listNoIsoEG.sort();
   listNoIsoEG.unique();
 
   listCenJet.sort();
   listCenJet.unique();
 
   listForJet.sort();
   listForJet.unique();
 
   listTauJet.sort();
   listTauJet.unique();
 
   listIsoTauJet.sort();
   listIsoTauJet.unique();
 
   listETM.sort();
   listETM.unique();
 
   listETT.sort();
   listETT.unique();
 
   listHTT.sort();
   listHTT.unique();
 
   listHTM.sort();
   listHTM.unique();
 
   listJetCounts.sort();
   listJetCounts.unique();
 
   //
   // record the L1 physics objects in the HLT filterproduct
   //
 
   // muon
   if (!listMuon.empty()) {
     edm::Handle<l1extra::L1MuonParticleCollection> l1Muon;
     iEvent.getByToken(m_l1MuonToken, l1Muon);
 
     if (!l1Muon.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1MuonParticleCollection with input tag " << m_l1MuonTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo muon added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listMuon.begin(); itObj != listMuon.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1Mu, l1extra::L1MuonParticleRef(l1Muon, *itObj));
       }
     }
   }
 
   // EG (isolated)
   if (!listIsoEG.empty()) {
     edm::Handle<l1extra::L1EmParticleCollection> l1IsoEG;
     iEvent.getByToken(m_l1IsoEGToken, l1IsoEG);
 
     if (!l1IsoEG.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EmParticleCollection with input tag " << m_l1IsoEGTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo IsoEG added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listIsoEG.begin(); itObj != listIsoEG.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1IsoEG, l1extra::L1EmParticleRef(l1IsoEG, *itObj));
       }
     }
   }
 
   // EG (no isolation)
   if (!listNoIsoEG.empty()) {
     edm::Handle<l1extra::L1EmParticleCollection> l1NoIsoEG;
     iEvent.getByToken(m_l1NoIsoEGToken, l1NoIsoEG);
 
     if (!l1NoIsoEG.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EmParticleCollection with input tag " << m_l1NoIsoEGTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo NoIsoEG added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listNoIsoEG.begin(); itObj != listNoIsoEG.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1NoIsoEG, l1extra::L1EmParticleRef(l1NoIsoEG, *itObj));
       }
     }
   }
 
   // central jets
   if (!listCenJet.empty()) {
     edm::Handle<l1extra::L1JetParticleCollection> l1CenJet;
     iEvent.getByToken(m_l1CenJetToken, l1CenJet);
 
     if (!l1CenJet.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1JetParticleCollection with input tag " << m_l1CenJetTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo CenJet added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listCenJet.begin(); itObj != listCenJet.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1CenJet, l1extra::L1JetParticleRef(l1CenJet, *itObj));
       }
     }
   }
 
   // forward jets
   if (!listForJet.empty()) {
     edm::Handle<l1extra::L1JetParticleCollection> l1ForJet;
     iEvent.getByToken(m_l1ForJetToken, l1ForJet);
 
     if (!l1ForJet.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1JetParticleCollection with input tag " << m_l1ForJetTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo ForJet added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listForJet.begin(); itObj != listForJet.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1ForJet, l1extra::L1JetParticleRef(l1ForJet, *itObj));
       }
     }
   }
 
   // tau jets
   if (!listTauJet.empty()) {
     edm::Handle<l1extra::L1JetParticleCollection> l1TauJet;
     iEvent.getByToken(m_l1TauJetToken, l1TauJet);
 
     if (!l1TauJet.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1JetParticleCollection with input tag " << m_l1TauJetTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo TauJet added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listTauJet.begin(); itObj != listTauJet.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1TauJet, l1extra::L1JetParticleRef(l1TauJet, *itObj));
       }
     }
   }
 
   // isotau jets
   if (!listIsoTauJet.empty()) {
     edm::Handle<l1extra::L1JetParticleCollection> l1IsoTauJet;
     iEvent.getByToken(m_l1IsoTauJetToken, l1IsoTauJet);
 
     if (!l1IsoTauJet.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1JetParticleCollection with input tag " << m_l1IsoTauJetTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo IsoTauJet added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listIsoTauJet.begin(); itObj != listIsoTauJet.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1TauJet, l1extra::L1JetParticleRef(l1IsoTauJet, *itObj));
       }
     }
   }
 
   // energy sums
   if (!listETM.empty()) {
     edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
     iEvent.getByToken(m_l1EtMissMETToken, l1EnergySums);
 
     if (!l1EnergySums.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMETTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo ETM added to filterproduct." << std::endl;
     } else if (l1EnergySums->empty()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMETTag
                                          << "\nfound in the event but with 0 size."
                                          << "\nNo ETM added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listETM.begin(); itObj != listETM.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1ETM, l1extra::L1EtMissParticleRef(l1EnergySums, *itObj));
       }
     }
   }
 
   if (!listETT.empty()) {
     edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
     iEvent.getByToken(m_l1EtMissMETToken, l1EnergySums);
 
     if (!l1EnergySums.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMETTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo ETT added to filterproduct." << std::endl;
     } else if (l1EnergySums->empty()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMETTag
                                          << "\nfound in the event but with 0 size."
                                          << "\nNo ETT added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listETT.begin(); itObj != listETT.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1ETT, l1extra::L1EtMissParticleRef(l1EnergySums, *itObj));
       }
     }
   }
 
   if (!listHTT.empty()) {
     edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
     iEvent.getByToken(m_l1EtMissMHTToken, l1EnergySums);
 
     if (!l1EnergySums.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMHTTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo HTT added to filterproduct." << std::endl;
 
     } else if (l1EnergySums->empty()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMHTTag
                                          << "\nfound in the event but with 0 size."
                                          << "\nNo HTT added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listHTT.begin(); itObj != listHTT.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1HTT, l1extra::L1EtMissParticleRef(l1EnergySums, *itObj));
       }
     }
   }
 
   if (!listHTM.empty()) {
     edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
     iEvent.getByToken(m_l1EtMissMHTToken, l1EnergySums);
 
     if (!l1EnergySums.isValid()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMHTTag
                                          << "\nrequested in configuration, but not found in the event."
                                          << "\nNo HTM added to filterproduct." << std::endl;
 
     } else if (l1EnergySums->empty()) {
       edm::LogWarning("HLTLevel1GTSeed") << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMHTTag
                                          << "\nfound in the event but with 0 size."
                                          << "\nNo HTM added to filterproduct." << std::endl;
 
     } else {
       for (std::list<int>::const_iterator itObj = listHTM.begin(); itObj != listHTM.end(); ++itObj) {
         filterproduct.addObject(trigger::TriggerL1HTM, l1extra::L1EtMissParticleRef(l1EnergySums, *itObj));
       }
     }
   }
 
   // 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!
   //
   //        }
   //
   //    }
 
   return seedsResult;
 }

void HLTLevel1GTSeed::updateAlgoLogicParser	(	const L1GtTriggerMenu *	l1GtMenu,
		const AlgorithmMap &	algorithmMap
	)

private

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

Definition at line 366 of file HLTLevel1GTSeed.cc.

References debugPrint(), Exception, L1GtTriggerMenu::gtTriggerMenuName(), mps_fire::i, m_isDebugEnabled, m_l1AlgoLogicParser, m_l1AlgoSeeds, m_l1AlgoSeedsObjType, m_l1AlgoSeedsRpn, objectTypeVec(), L1GtLogicParser::operandTokenVector(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by hltFilter(), and seedsL1TriggerObjectMaps().

                                                                                                              {
   std::vector<L1GtLogicParser::OperandToken>& algOpTokenVector = m_l1AlgoLogicParser.operandTokenVector();
 
   size_t jSeed = 0;
   size_t l1AlgoSeedsSize = m_l1AlgoSeeds.size();
 
   // clear the content from the previous menu for the vector of RPN vectors m_l1AlgoSeedsRpn
   // and for the the vector of object-type vectors m_l1AlgoSeedsObjType
   m_l1AlgoSeedsRpn.clear();
   m_l1AlgoSeedsObjType.clear();
 
   //
 
   for (auto& i : algOpTokenVector) {
     auto itAlgo = algorithmMap.find(i.tokenName);
     if (itAlgo != algorithmMap.end()) {
       int bitNr = (itAlgo->second).algoBitNumber();
       int chipNr = (itAlgo->second).algoChipNumber();
 
       i.tokenNumber = bitNr;
 
       // algOpTokenVector and m_l1AlgoSeeds must have the same ordering
       // of the algorithms
       if (jSeed < l1AlgoSeedsSize) {
         //LogTrace("HLTLevel1GTSeed") << "(m_l1AlgoSeeds[jSeed]).tokenName: "
         //    << (m_l1AlgoSeeds[jSeed]).tokenName
         //    << std::endl;
 
         if ((m_l1AlgoSeeds[jSeed]).tokenName == i.tokenName) {
           (m_l1AlgoSeeds[jSeed]).tokenNumber = bitNr;
 
           const std::vector<L1GtLogicParser::TokenRPN>& aRpnVector = (itAlgo->second).algoRpnVector();
           size_t aRpnVectorSize = aRpnVector.size();
 
           m_l1AlgoSeedsRpn.push_back(&aRpnVector);
 
           // loop over RpnVector to fill for each condition the object type
           std::vector<const std::vector<L1GtObject>*> tmpObjTypeVec;
           tmpObjTypeVec.reserve(aRpnVectorSize);
 
           for (size_t opI = 0; opI < aRpnVectorSize; ++opI) {
             std::string cName = (aRpnVector[opI]).operand;
 
             if (!cName.empty()) {
               tmpObjTypeVec.push_back(objectTypeVec(chipNr, cName));
 
               //LogTrace("HLTLevel1GTSeed")
               //    << "    Push object vector for condition: " << cName
               //    << std::endl;
             }
           }
 
           m_l1AlgoSeedsObjType.push_back(tmpObjTypeVec);
 
           jSeed++;
         }
       }
     } else {
       throw cms::Exception("FailModule") << "\nAlgorithm  " << i.tokenName
                                          << ", requested as seed by a HLT path, not found in the L1 trigger menu\n   "
                                          << l1GtMenu->gtTriggerMenuName() << "\nIncompatible L1 and HLT menus.\n"
                                          << std::endl;
     }
   }
 
   //
   if (m_isDebugEnabled) {
     bool newMenu = true;
     debugPrint(newMenu);
   }
 }

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

private

update the tokenResult members from m_l1AlgoLogicParser for a new event

Definition at line 440 of file HLTLevel1GTSeed.cc.

References debugPrint(), mps_fire::i, m_isDebugEnabled, m_l1AlgoLogicParser, m_l1AlgoSeeds, and L1GtLogicParser::operandTokenVector().

                                                                            {
   std::vector<L1GtLogicParser::OperandToken>& algOpTokenVector = m_l1AlgoLogicParser.operandTokenVector();
 
   for (auto& i : algOpTokenVector) {
     int iBit = i.tokenNumber;
     bool iResult = gtWord.at(iBit);
 
     int triggerMaskBit = triggerMask[iBit] & (1 << physicsDaqPartition);
     //LogTrace("HLTLevel1GTSeed")
     //<< "\nTrigger bit: " << iBit
     //<< " mask = " << triggerMaskBit
     //<< " DAQ partition " << physicsDaqPartition
     //<< std::endl;
 
     if (triggerMaskBit) {
       iResult = false;
 
       //LogTrace("HLTLevel1GTSeed")
       //<< "\nMasked trigger: " << iBit << ". Result set to false\n"
       //<< std::endl;
     }
 
     i.tokenResult = iResult;
   }
 
   for (auto& m_l1AlgoSeed : m_l1AlgoSeeds) {
     int iBit = m_l1AlgoSeed.tokenNumber;
     bool iResult = gtWord.at(iBit);
 
     int triggerMaskBit = triggerMask[iBit] & (1 << physicsDaqPartition);
     //LogTrace("HLTLevel1GTSeed")
     //<< "\nTrigger bit: " << iBit
     //<< " mask = " << triggerMaskBit
     //<< " DAQ partition " << physicsDaqPartition
     //<< std::endl;
 
     if (triggerMaskBit) {
       iResult = false;
 
       //LogTrace("HLTLevel1GTSeed")
       //<< "\nMasked trigger: " << iBit << ". Result set to false\n"
       //<< std::endl;
     }
 
     m_l1AlgoSeed.tokenResult = iResult;
   }
 
   if (m_isDebugEnabled) {
     bool newMenu = false;
     debugPrint(newMenu);
   }
 }

Member Data Documentation

bool HLTLevel1GTSeed::m_isDebugEnabled

private

cache edm::isDebugEnabled()

Definition at line 191 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), seedsL1TriggerObjectMaps(), and updateAlgoLogicParser().

L1GtLogicParser HLTLevel1GTSeed::m_l1AlgoLogicParser

private

logic parser for m_l1SeedsLogicalExpression

Definition at line 116 of file HLTLevel1GTSeed.h.

Referenced by convertStringToBitNumber(), debugPrint(), hltFilter(), HLTLevel1GTSeed(), seedsL1TriggerObjectMaps(), and updateAlgoLogicParser().

std::vector<L1GtLogicParser::OperandToken> HLTLevel1GTSeed::m_l1AlgoSeeds

private

list of required algorithms for seeding

Definition at line 119 of file HLTLevel1GTSeed.h.

Referenced by convertStringToBitNumber(), debugPrint(), HLTLevel1GTSeed(), seedsL1Extra(), seedsL1TriggerObjectMaps(), and updateAlgoLogicParser().

std::vector<std::vector<const std::vector<L1GtObject> *> > HLTLevel1GTSeed::m_l1AlgoSeedsObjType

private

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

Definition at line 125 of file HLTLevel1GTSeed.h.

Referenced by debugPrint(), HLTLevel1GTSeed(), seedsL1Extra(), seedsL1TriggerObjectMaps(), and updateAlgoLogicParser().

std::vector<const std::vector<L1GtLogicParser::TokenRPN> *> HLTLevel1GTSeed::m_l1AlgoSeedsRpn

private

vector of Rpn vectors for the required algorithms for seeding

Definition at line 122 of file HLTLevel1GTSeed.h.

Referenced by debugPrint(), HLTLevel1GTSeed(), seedsL1TriggerObjectMaps(), and updateAlgoLogicParser().

edm::InputTag HLTLevel1GTSeed::m_l1CenJetTag

private

Definition at line 174 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1extra::L1JetParticleCollection> HLTLevel1GTSeed::m_l1CenJetToken

private

Definition at line 175 of file HLTLevel1GTSeed.h.

Referenced by seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::InputTag HLTLevel1GTSeed::m_l1CollectionsTag

private

Meta InputTag for L1 particle collections (except muon)

Definition at line 161 of file HLTLevel1GTSeed.h.

Referenced by HLTLevel1GTSeed().

edm::InputTag HLTLevel1GTSeed::m_l1EtMissMETTag

private

Definition at line 182 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1extra::L1EtMissParticleCollection> HLTLevel1GTSeed::m_l1EtMissMETToken

private

Definition at line 183 of file HLTLevel1GTSeed.h.

Referenced by seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::InputTag HLTLevel1GTSeed::m_l1EtMissMHTTag

private

Definition at line 184 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1extra::L1EtMissParticleCollection> HLTLevel1GTSeed::m_l1EtMissMHTToken

private

Definition at line 185 of file HLTLevel1GTSeed.h.

Referenced by seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::InputTag HLTLevel1GTSeed::m_l1ExtraTag

private

cached InputTags

Definition at line 167 of file HLTLevel1GTSeed.h.

Referenced by hltFilter().

edm::InputTag HLTLevel1GTSeed::m_l1ForJetTag

private

Definition at line 176 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1extra::L1JetParticleCollection> HLTLevel1GTSeed::m_l1ForJetToken

private

Definition at line 177 of file HLTLevel1GTSeed.h.

Referenced by seedsL1Extra(), and seedsL1TriggerObjectMaps().

bool HLTLevel1GTSeed::m_l1GlobalDecision

private

replace string "L1GlobalDecision" with bool to speed up the "if"

Definition at line 188 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), and HLTLevel1GTSeed().

const L1GtTriggerMenu* HLTLevel1GTSeed::m_l1GtMenu

private

trigger menu

Definition at line 107 of file HLTLevel1GTSeed.h.

Referenced by debugPrint(), hltFilter(), and objectTypeVec().

unsigned long long HLTLevel1GTSeed::m_l1GtMenuCacheID

private

Definition at line 108 of file HLTLevel1GTSeed.h.

Referenced by hltFilter().

edm::InputTag HLTLevel1GTSeed::m_l1GtObjectMapTag

private

InputTag for L1 Global Trigger object maps.

Definition at line 157 of file HLTLevel1GTSeed.h.

Referenced by HLTLevel1GTSeed().

edm::EDGetTokenT<L1GlobalTriggerObjectMapRecord> HLTLevel1GTSeed::m_l1GtObjectMapToken

private

Definition at line 158 of file HLTLevel1GTSeed.h.

Referenced by seedsL1TriggerObjectMaps().

edm::InputTag HLTLevel1GTSeed::m_l1GtReadoutRecordTag

private

InputTag for the L1 Global Trigger DAQ readout record.

Definition at line 153 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), HLTLevel1GTSeed(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<L1GlobalTriggerReadoutRecord> HLTLevel1GTSeed::m_l1GtReadoutRecordToken

private

Definition at line 154 of file HLTLevel1GTSeed.h.

Referenced by hltFilter().

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd> const HLTLevel1GTSeed::m_l1GtTriggerMaskAlgoTrigRcdToken

private

Definition at line 112 of file HLTLevel1GTSeed.h.

Referenced by hltFilter().

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd> const HLTLevel1GTSeed::m_l1GtTriggerMaskTechTrigRcdToken

private

Definition at line 113 of file HLTLevel1GTSeed.h.

Referenced by hltFilter().

edm::ESGetToken<L1GtTriggerMenu, L1GtTriggerMenuRcd> const HLTLevel1GTSeed::m_l1GtTriggerMenuToken

private

Definition at line 111 of file HLTLevel1GTSeed.h.

Referenced by hltFilter().

edm::InputTag HLTLevel1GTSeed::m_l1IsoEGTag

private

Definition at line 170 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1extra::L1EmParticleCollection> HLTLevel1GTSeed::m_l1IsoEGToken

private

Definition at line 171 of file HLTLevel1GTSeed.h.

Referenced by seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::InputTag HLTLevel1GTSeed::m_l1IsoTauJetTag

private

Definition at line 180 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1extra::L1JetParticleCollection> HLTLevel1GTSeed::m_l1IsoTauJetToken

private

Definition at line 181 of file HLTLevel1GTSeed.h.

Referenced by seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::InputTag HLTLevel1GTSeed::m_l1MuonCollectionTag

private

Meta InputTag for L1 muon collection.

Definition at line 164 of file HLTLevel1GTSeed.h.

Referenced by HLTLevel1GTSeed().

edm::InputTag HLTLevel1GTSeed::m_l1MuonTag

private

Definition at line 168 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1extra::L1MuonParticleCollection> HLTLevel1GTSeed::m_l1MuonToken

private

Definition at line 169 of file HLTLevel1GTSeed.h.

Referenced by seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::InputTag HLTLevel1GTSeed::m_l1NoIsoEGTag

private

Definition at line 172 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1extra::L1EmParticleCollection> HLTLevel1GTSeed::m_l1NoIsoEGToken

private

Definition at line 173 of file HLTLevel1GTSeed.h.

Referenced by seedsL1Extra(), and seedsL1TriggerObjectMaps().

int HLTLevel1GTSeed::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 140 of file HLTLevel1GTSeed.h.

Referenced by HLTLevel1GTSeed(), and seedsL1Extra().

std::string HLTLevel1GTSeed::m_l1SeedsLogicalExpression

private

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

Definition at line 150 of file HLTLevel1GTSeed.h.

Referenced by convertStringToBitNumber(), HLTLevel1GTSeed(), and seedsL1TriggerObjectMaps().

edm::InputTag HLTLevel1GTSeed::m_l1TauJetTag

private

Definition at line 178 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), seedsL1Extra(), and seedsL1TriggerObjectMaps().

edm::EDGetTokenT<l1extra::L1JetParticleCollection> HLTLevel1GTSeed::m_l1TauJetToken

private

Definition at line 179 of file HLTLevel1GTSeed.h.

Referenced by seedsL1Extra(), and seedsL1TriggerObjectMaps().

bool HLTLevel1GTSeed::m_l1TechTriggerSeeding

private

seeding done via technical trigger bits, if value is "true"

Definition at line 143 of file HLTLevel1GTSeed.h.

Referenced by debugPrint(), hltFilter(), and HLTLevel1GTSeed().

bool HLTLevel1GTSeed::m_l1UseAliasesForSeeding

private

seeding uses algorithm aliases instead of algorithm names, if value is "true"

Definition at line 146 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), and HLTLevel1GTSeed().

bool HLTLevel1GTSeed::m_l1UseL1TriggerObjectMaps

private

if true: seeding done via L1 trigger object maps, with objects that fired only objects from the central BxInEvent (L1A) are used if false: seeding is done ignoring if a L1 object fired or not, adding all L1EXtra objects corresponding to the object types used in all conditions from the algorithms in logical expression for a given number of BxInEvent

Definition at line 136 of file HLTLevel1GTSeed.h.

Referenced by hltFilter(), and HLTLevel1GTSeed().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation