Produces the full or stand-alone PAT trigger information collections. More...

Inheritance diagram for pat::PATTriggerProducer:

Classes
class	ModuleLabelToPathAndFlags

Public Member Functions
	PATTriggerProducer (const edm::ParameterSet &iConfig)

	~PATTriggerProducer () override

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

	EDProducer (const EDProducer &)=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 EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
void	beginLuminosityBlock (const edm::LuminosityBlock &iLuminosityBlock, const edm::EventSetup &iSetup) override

void	beginRun (const edm::Run &iRun, const edm::EventSetup &iSetup) override

void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override

Private Attributes
bool	addL1Algos_

bool	addPathModuleLabels_

bool	autoProcessName_

bool	autoProcessNameL1ExtraCenJet_

bool	autoProcessNameL1ExtraETM_

bool	autoProcessNameL1ExtraForJet_

bool	autoProcessNameL1ExtraHTM_

bool	autoProcessNameL1ExtraIsoEG_

bool	autoProcessNameL1ExtraMu_

bool	autoProcessNameL1ExtraNoIsoEG_

bool	autoProcessNameL1ExtraTauJet_

std::vector< std::string >	exludeCollections_

bool	firstInRun_

const edm::ESGetToken< L1GtTriggerMenu, L1GtTriggerMenuRcd >	handleL1GtTriggerMenuToken_

bool	hltConfigInit_

std::string	hltPrescaleLabel_

HLTPrescaleProvider	hltPrescaleProvider_

edm::GetterOfProducts< trigger::HLTPrescaleTable >	hltPrescaleTableEventGetter_

trigger::HLTPrescaleTable	hltPrescaleTableLumi_

edm::GetterOfProducts< trigger::HLTPrescaleTable >	hltPrescaleTableLumiGetter_

trigger::HLTPrescaleTable	hltPrescaleTableRun_

edm::GetterOfProducts< trigger::HLTPrescaleTable >	hltPrescaleTableRunGetter_

edm::GetterOfProducts< l1extra::L1JetParticleCollection >	l1ExtraCenJetGetter_

edm::GetterOfProducts< l1extra::L1EtMissParticleCollection >	l1ExtraETMGetter_

edm::GetterOfProducts< l1extra::L1JetParticleCollection >	l1ExtraForJetGetter_

edm::GetterOfProducts< l1extra::L1EtMissParticleCollection >	l1ExtraHTMGetter_

edm::GetterOfProducts< l1extra::L1EmParticleCollection >	l1ExtraIsoEGGetter_

edm::GetterOfProducts< l1extra::L1MuonParticleCollection >	l1ExtraMuGetter_

edm::GetterOfProducts< l1extra::L1EmParticleCollection >	l1ExtraNoIsoEGGetter_

edm::GetterOfProducts< l1extra::L1JetParticleCollection >	l1ExtraTauJetGetter_

edm::EDGetTokenT< L1GlobalTriggerObjectMaps >	l1GlobalTriggerObjectMapsToken_

edm::ParameterSet *	l1PSet_

std::string	labelHltPrescaleTable_

bool	mainBxOnly_

ModuleLabelToPathAndFlags	moduleLabelToPathAndFlags_

std::string	nameProcess_

bool	onlyStandAlone_

bool	packLabels_

bool	packPathNames_

bool	packPrescales_

bool	saveL1Refs_

edm::InputTag	tagL1ExtraCenJet_

edm::InputTag	tagL1ExtraETM_

edm::InputTag	tagL1ExtraForJet_

edm::InputTag	tagL1ExtraHTM_

edm::InputTag	tagL1ExtraIsoEG_

edm::InputTag	tagL1ExtraMu_

edm::InputTag	tagL1ExtraNoIsoEG_

edm::InputTag	tagL1ExtraTauJet_

edm::InputTag	tagL1GlobalTriggerObjectMaps_

edm::InputTag	tagTriggerEvent_

edm::InputTag	tagTriggerResults_

edm::GetterOfProducts< trigger::TriggerEvent >	triggerEventGetter_

edm::GetterOfProducts< edm::TriggerResults >	triggerResultsGetter_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
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

Detailed Description

Produces the full or stand-alone PAT trigger information collections.

This producer extracts the trigger information from

the edm::TriggerResults written by the HLT process,
the corresponding trigger::TriggerEvent,
the provenance information,
the process history,
the GlobalTrigger information in the event and the event setup and
the L1 object collections ("l1extra") re-arranges it and writes it either (full mode) to
a pat::TriggerObjectCollection,
a pat::TriggerFilterCollection,
a pat::TriggerPathCollection,
a pat::TriggerAlgorithmCollection (optionally filled or empty) and
a pat::TriggerConditionCollection (optionally filled or empty) or (stand-alone mode) to
a pat::TriggerObjectStandAloneCollection

For me information, s. https://twiki.cern.ch/twiki/bin/view/CMS/SWGuidePATTrigger

Author: Volker Adler

Version

Id: PATTriggerProducer.h,v 1.20 2012/09/11 22:45:29 vadler Exp

Definition at line 72 of file PATTriggerProducer.cc.

Constructor & Destructor Documentation

◆ PATTriggerProducer()

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

explicit

Definition at line 176 of file PATTriggerProducer.cc.

     : nameProcess_(iConfig.getParameter<std::string>("processName")),
       autoProcessName_(nameProcess_ == "*"),
       onlyStandAlone_(iConfig.getParameter<bool>("onlyStandAlone")),
       firstInRun_(true),
       // L1 configuration parameters
       addL1Algos_(false),
       tagL1GlobalTriggerObjectMaps_("l1L1GtObjectMap"),
       tagL1ExtraMu_(),
       tagL1ExtraNoIsoEG_(),
       tagL1ExtraIsoEG_(),
       tagL1ExtraCenJet_(),
       tagL1ExtraForJet_(),
       tagL1ExtraTauJet_(),
       tagL1ExtraETM_(),
       tagL1ExtraHTM_(),
       autoProcessNameL1ExtraMu_(false),
       autoProcessNameL1ExtraNoIsoEG_(false),
       autoProcessNameL1ExtraIsoEG_(false),
       autoProcessNameL1ExtraCenJet_(false),
       autoProcessNameL1ExtraForJet_(false),
       autoProcessNameL1ExtraTauJet_(false),
       autoProcessNameL1ExtraETM_(false),
       autoProcessNameL1ExtraHTM_(false),
       mainBxOnly_(true),
       saveL1Refs_(false),
       hltPrescaleProvider_(iConfig, consumesCollector(), *this),
       hltConfigInit_(false),
       // HLT configuration parameters
       tagTriggerResults_("TriggerResults"),
       tagTriggerEvent_("hltTriggerSummaryAOD"),
       hltPrescaleLabel_(),
       labelHltPrescaleTable_(),
       hltPrescaleTableRun_(),
       hltPrescaleTableLumi_(),
       addPathModuleLabels_(false),
       packPathNames_(iConfig.existsAs<bool>("packTriggerPathNames") ? iConfig.getParameter<bool>("packTriggerPathNames")
                                                                     : false),
       packLabels_(iConfig.existsAs<bool>("packTriggerLabels") ? iConfig.getParameter<bool>("packTriggerLabels") : true),
       packPrescales_(iConfig.existsAs<bool>("packTriggerPrescales") ? iConfig.getParameter<bool>("packTriggerPrescales")
                                                                     : true),
       handleL1GtTriggerMenuToken_{esConsumes()} {
   // L1 configuration parameters
   if (iConfig.exists("addL1Algos"))
     addL1Algos_ = iConfig.getParameter<bool>("addL1Algos");
   if (iConfig.exists("l1GlobalTriggerObjectMaps"))
     tagL1GlobalTriggerObjectMaps_ = iConfig.getParameter<InputTag>("l1GlobalTriggerObjectMaps");
   l1GlobalTriggerObjectMapsToken_ = mayConsume<L1GlobalTriggerObjectMaps>(tagL1GlobalTriggerObjectMaps_);
   if (iConfig.exists("l1ExtraMu")) {
     tagL1ExtraMu_ = iConfig.getParameter<InputTag>("l1ExtraMu");
     if (tagL1ExtraMu_.process() == "*") {
       if (autoProcessName_)
         autoProcessNameL1ExtraMu_ = true;
       else
         tagL1ExtraMu_ = InputTag(tagL1ExtraMu_.label(), tagL1ExtraMu_.instance(), nameProcess_);
     }
     l1ExtraMuGetter_ = GetterOfProducts<l1extra::L1MuonParticleCollection>(
         InputTagMatch(InputTag(tagL1ExtraMu_.label(), tagL1ExtraMu_.instance())), this);
   }
   if (iConfig.exists("l1ExtraNoIsoEG")) {
     tagL1ExtraNoIsoEG_ = iConfig.getParameter<InputTag>("l1ExtraNoIsoEG");
     if (tagL1ExtraNoIsoEG_.process() == "*") {
       if (autoProcessName_)
         autoProcessNameL1ExtraNoIsoEG_ = true;
       else
         tagL1ExtraNoIsoEG_ = InputTag(tagL1ExtraNoIsoEG_.label(), tagL1ExtraNoIsoEG_.instance(), nameProcess_);
     }
     l1ExtraNoIsoEGGetter_ = GetterOfProducts<l1extra::L1EmParticleCollection>(
         InputTagMatch(InputTag(tagL1ExtraNoIsoEG_.label(), tagL1ExtraNoIsoEG_.instance())), this);
   }
   if (iConfig.exists("l1ExtraIsoEG")) {
     tagL1ExtraIsoEG_ = iConfig.getParameter<InputTag>("l1ExtraIsoEG");
     if (tagL1ExtraIsoEG_.process() == "*") {
       if (autoProcessName_)
         autoProcessNameL1ExtraIsoEG_ = true;
       else
         tagL1ExtraIsoEG_ = InputTag(tagL1ExtraIsoEG_.label(), tagL1ExtraIsoEG_.instance(), nameProcess_);
     }
     l1ExtraIsoEGGetter_ = GetterOfProducts<l1extra::L1EmParticleCollection>(
         InputTagMatch(InputTag(tagL1ExtraIsoEG_.label(), tagL1ExtraIsoEG_.instance())), this);
   }
   if (iConfig.exists("l1ExtraCenJet")) {
     tagL1ExtraCenJet_ = iConfig.getParameter<InputTag>("l1ExtraCenJet");
     if (tagL1ExtraCenJet_.process() == "*") {
       if (autoProcessName_)
         autoProcessNameL1ExtraCenJet_ = true;
       else
         tagL1ExtraCenJet_ = InputTag(tagL1ExtraCenJet_.label(), tagL1ExtraCenJet_.instance(), nameProcess_);
     }
     l1ExtraCenJetGetter_ = GetterOfProducts<l1extra::L1JetParticleCollection>(
         InputTagMatch(InputTag(tagL1ExtraCenJet_.label(), tagL1ExtraCenJet_.instance())), this);
   }
   if (iConfig.exists("l1ExtraForJet")) {
     tagL1ExtraForJet_ = iConfig.getParameter<InputTag>("l1ExtraForJet");
     if (tagL1ExtraForJet_.process() == "*") {
       if (autoProcessName_)
         autoProcessNameL1ExtraForJet_ = true;
       else
         tagL1ExtraForJet_ = InputTag(tagL1ExtraForJet_.label(), tagL1ExtraForJet_.instance(), nameProcess_);
     }
     l1ExtraForJetGetter_ = GetterOfProducts<l1extra::L1JetParticleCollection>(
         InputTagMatch(InputTag(tagL1ExtraForJet_.label(), tagL1ExtraForJet_.instance())), this);
   }
   if (iConfig.exists("l1ExtraTauJet")) {
     tagL1ExtraTauJet_ = iConfig.getParameter<InputTag>("l1ExtraTauJet");
     if (tagL1ExtraTauJet_.process() == "*") {
       if (autoProcessName_)
         autoProcessNameL1ExtraTauJet_ = true;
       else
         tagL1ExtraTauJet_ = InputTag(tagL1ExtraTauJet_.label(), tagL1ExtraTauJet_.instance(), nameProcess_);
     }
     l1ExtraTauJetGetter_ = GetterOfProducts<l1extra::L1JetParticleCollection>(
         InputTagMatch(InputTag(tagL1ExtraTauJet_.label(), tagL1ExtraTauJet_.instance())), this);
   }
   if (iConfig.exists("l1ExtraETM")) {
     tagL1ExtraETM_ = iConfig.getParameter<InputTag>("l1ExtraETM");
     if (tagL1ExtraETM_.process() == "*") {
       if (autoProcessName_)
         autoProcessNameL1ExtraETM_ = true;
       else
         tagL1ExtraETM_ = InputTag(tagL1ExtraETM_.label(), tagL1ExtraETM_.instance(), nameProcess_);
     }
     l1ExtraETMGetter_ = GetterOfProducts<l1extra::L1EtMissParticleCollection>(
         InputTagMatch(InputTag(tagL1ExtraETM_.label(), tagL1ExtraETM_.instance())), this);
   }
   if (iConfig.exists("l1ExtraHTM")) {
     tagL1ExtraHTM_ = iConfig.getParameter<InputTag>("l1ExtraHTM");
     if (tagL1ExtraHTM_.process() == "*") {
       if (autoProcessName_)
         autoProcessNameL1ExtraHTM_ = true;
       else
         tagL1ExtraHTM_ = InputTag(tagL1ExtraHTM_.label(), tagL1ExtraHTM_.instance(), nameProcess_);
     }
     l1ExtraHTMGetter_ = GetterOfProducts<l1extra::L1EtMissParticleCollection>(
         InputTagMatch(InputTag(tagL1ExtraHTM_.label(), tagL1ExtraHTM_.instance())), this);
   }
   if (iConfig.exists("mainBxOnly"))
     mainBxOnly_ = iConfig.getParameter<bool>("mainBxOnly");
   if (iConfig.exists("saveL1Refs"))
     saveL1Refs_ = iConfig.getParameter<bool>("saveL1Refs");
  
   // HLT configuration parameters
   if (iConfig.exists("triggerResults"))
     tagTriggerResults_ = iConfig.getParameter<InputTag>("triggerResults");
   triggerResultsGetter_ =
       GetterOfProducts<TriggerResults>(InputTagMatch(InputTag(tagTriggerResults_.label(),
                                                               tagTriggerResults_.instance(),
                                                               autoProcessName_ ? std::string("") : nameProcess_)),
                                        this);
   if (iConfig.exists("triggerEvent"))
     tagTriggerEvent_ = iConfig.getParameter<InputTag>("triggerEvent");
   triggerEventGetter_ = GetterOfProducts<trigger::TriggerEvent>(
       InputTagMatch(InputTag(tagTriggerEvent_.label(), tagTriggerEvent_.instance())), this);
   if (iConfig.exists("hltPrescaleLabel"))
     hltPrescaleLabel_ = iConfig.getParameter<std::string>("hltPrescaleLabel");
   if (iConfig.exists("hltPrescaleTable")) {
     labelHltPrescaleTable_ = iConfig.getParameter<std::string>("hltPrescaleTable");
     hltPrescaleTableRunGetter_ = GetterOfProducts<trigger::HLTPrescaleTable>(
         InputTagMatch(InputTag(labelHltPrescaleTable_, "Run")), this, InRun);
     hltPrescaleTableLumiGetter_ = GetterOfProducts<trigger::HLTPrescaleTable>(
         InputTagMatch(InputTag(labelHltPrescaleTable_, "Lumi")), this, InLumi);
     hltPrescaleTableEventGetter_ =
         GetterOfProducts<trigger::HLTPrescaleTable>(InputTagMatch(InputTag(labelHltPrescaleTable_, "Event")), this);
   }
   if (iConfig.exists("addPathModuleLabels"))
     addPathModuleLabels_ = iConfig.getParameter<bool>("addPathModuleLabels");
   exludeCollections_.clear();
   if (iConfig.exists("exludeCollections"))
     exludeCollections_ = iConfig.getParameter<std::vector<std::string> >("exludeCollections");
  
   callWhenNewProductsRegistered([this, &iConfig](BranchDescription const& bd) {
     if (iConfig.exists("l1ExtraMu"))
       l1ExtraMuGetter_(bd);
     if (iConfig.exists("l1ExtraNoIsoEG"))
       l1ExtraNoIsoEGGetter_(bd);
     if (iConfig.exists("l1ExtraIsoEG"))
       l1ExtraIsoEGGetter_(bd);
     if (iConfig.exists("l1ExtraCenJet"))
       l1ExtraCenJetGetter_(bd);
     if (iConfig.exists("l1ExtraForJet"))
       l1ExtraForJetGetter_(bd);
     if (iConfig.exists("l1ExtraTauJet"))
       l1ExtraTauJetGetter_(bd);
     if (iConfig.exists("l1ExtraETM"))
       l1ExtraETMGetter_(bd);
     if (iConfig.exists("l1ExtraHTM"))
       l1ExtraHTMGetter_(bd);
     if (not(this->autoProcessName_ and bd.processName() == this->moduleDescription().processName())) {
       triggerResultsGetter_(bd);
     }
     triggerEventGetter_(bd);
     if (iConfig.exists("hltPrescaleTable")) {
       hltPrescaleTableRunGetter_(bd);
       hltPrescaleTableLumiGetter_(bd);
       hltPrescaleTableEventGetter_(bd);
     }
   });
  
   if (!onlyStandAlone_) {
     produces<TriggerAlgorithmCollection>();
     produces<TriggerConditionCollection>();
     produces<TriggerPathCollection>();
     produces<TriggerFilterCollection>();
     produces<TriggerObjectCollection>();
   }
   if (packPrescales_) {
     produces<PackedTriggerPrescales>();
     produces<PackedTriggerPrescales>("l1max");
     produces<PackedTriggerPrescales>("l1min");
   }
   produces<TriggerObjectStandAloneCollection>();
 }

References DeDxTools::esConsumes().

◆ ~PATTriggerProducer()

pat::PATTriggerProducer::~PATTriggerProducer ( )

inlineoverride

Definition at line 75 of file PATTriggerProducer.cc.

75 {};

Member Function Documentation

◆ beginLuminosityBlock()

void PATTriggerProducer::beginLuminosityBlock	(	const edm::LuminosityBlock &	iLuminosityBlock,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 481 of file PATTriggerProducer.cc.

                                                                                                                {
   // Terminate, if auto process name determination failed
   if (nameProcess_ == "*")
     return;
  
   // Extract pre-scales
   if (hltConfigInit_) {
     // Start from run
     hltPrescaleTableLumi_ = trigger::HLTPrescaleTable(
         hltPrescaleTableRun_.set(), hltPrescaleTableRun_.labels(), hltPrescaleTableRun_.table());
     // Try lumi product, if configured and available
     if (!labelHltPrescaleTable_.empty()) {
       Handle<trigger::HLTPrescaleTable> handleHltPrescaleTable;
       iLuminosityBlock.getByLabel(InputTag(labelHltPrescaleTable_, "Lumi", nameProcess_), handleHltPrescaleTable);
       if (handleHltPrescaleTable.isValid()) {
         hltPrescaleTableLumi_ = trigger::HLTPrescaleTable(
             handleHltPrescaleTable->set(), handleHltPrescaleTable->labels(), handleHltPrescaleTable->table());
       }
     }
   }
 }

References edm::LuminosityBlock::getByLabel(), hltConfigInit_, hltPrescaleTableLumi_, hltPrescaleTableRun_, HLT_FULL_cff::InputTag, edm::HandleBase::isValid(), labelHltPrescaleTable_, trigger::HLTPrescaleTable::labels(), nameProcess_, trigger::HLTPrescaleTable::set(), and trigger::HLTPrescaleTable::table().

◆ beginRun()

void PATTriggerProducer::beginRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 389 of file PATTriggerProducer.cc.

                                                                            {
   // Initialize
   firstInRun_ = true;
   l1PSet_ = nullptr;
   hltConfigInit_ = false;
  
   // Initialize process name
   if (autoProcessName_) {
     // reset
     nameProcess_ = "*";
     // determine process name from last run TriggerSummaryProducerAOD module in process history of input
     const ProcessHistory& processHistory(iRun.processHistory());
     ProcessConfiguration processConfiguration;
     ParameterSet processPSet;
     // unbroken loop, which relies on time ordering (accepts the last found entry)
     for (ProcessHistory::const_iterator iHist = processHistory.begin(); iHist != processHistory.end(); ++iHist) {
       if (processHistory.getConfigurationForProcess(iHist->processName(), processConfiguration) &&
           pset::Registry::instance()->getMapped(processConfiguration.parameterSetID(), processPSet) &&
           processPSet.exists(tagTriggerEvent_.label())) {
         nameProcess_ = iHist->processName();
         LogDebug("autoProcessName") << "HLT process name '" << nameProcess_ << "' discovered";
       }
     }
     // terminate, if nothing is found
     if (nameProcess_ == "*") {
       LogError("autoProcessName") << "trigger::TriggerEvent product with label '" << tagTriggerEvent_.label()
                                   << "' not produced according to process history of input data\n"
                                   << "No trigger information produced";
       return;
     }
     LogInfo("autoProcessName") << "HLT process name' " << nameProcess_ << "' used for PAT trigger information";
   }
   // adapt configuration of used input tags
   if (tagTriggerResults_.process().empty() || tagTriggerResults_.process() == "*") {
     tagTriggerResults_ = InputTag(tagTriggerResults_.label(), tagTriggerResults_.instance(), nameProcess_);
   } else if (tagTriggerEvent_.process() != nameProcess_) {
     LogWarning("inputTags") << "TriggerResults process name '" << tagTriggerResults_.process()
                             << "' differs from HLT process name '" << nameProcess_ << "'";
   }
   if (tagTriggerEvent_.process().empty() || tagTriggerEvent_.process() == "*") {
     tagTriggerEvent_ = InputTag(tagTriggerEvent_.label(), tagTriggerEvent_.instance(), nameProcess_);
   } else if (tagTriggerEvent_.process() != nameProcess_) {
     LogWarning("inputTags") << "TriggerEvent process name '" << tagTriggerEvent_.process()
                             << "' differs from HLT process name '" << nameProcess_ << "'";
   }
   if (autoProcessNameL1ExtraMu_)
     tagL1ExtraMu_ = InputTag(tagL1ExtraMu_.label(), tagL1ExtraMu_.instance(), nameProcess_);
   if (autoProcessNameL1ExtraNoIsoEG_)
     tagL1ExtraNoIsoEG_ = InputTag(tagL1ExtraNoIsoEG_.label(), tagL1ExtraNoIsoEG_.instance(), nameProcess_);
   if (autoProcessNameL1ExtraIsoEG_)
     tagL1ExtraIsoEG_ = InputTag(tagL1ExtraIsoEG_.label(), tagL1ExtraIsoEG_.instance(), nameProcess_);
   if (autoProcessNameL1ExtraCenJet_)
     tagL1ExtraCenJet_ = InputTag(tagL1ExtraCenJet_.label(), tagL1ExtraCenJet_.instance(), nameProcess_);
   if (autoProcessNameL1ExtraForJet_)
     tagL1ExtraForJet_ = InputTag(tagL1ExtraForJet_.label(), tagL1ExtraForJet_.instance(), nameProcess_);
   if (autoProcessNameL1ExtraTauJet_)
     tagL1ExtraTauJet_ = InputTag(tagL1ExtraTauJet_.label(), tagL1ExtraTauJet_.instance(), nameProcess_);
   if (autoProcessNameL1ExtraETM_)
     tagL1ExtraETM_ = InputTag(tagL1ExtraETM_.label(), tagL1ExtraETM_.instance(), nameProcess_);
   if (autoProcessNameL1ExtraHTM_)
     tagL1ExtraHTM_ = InputTag(tagL1ExtraHTM_.label(), tagL1ExtraHTM_.instance(), nameProcess_);
  
   // Initialize HLTConfigProvider
   HLTConfigProvider const& hltConfig = hltPrescaleProvider_.hltConfigProvider();
   bool changed(true);
   if (!hltPrescaleProvider_.init(iRun, iSetup, nameProcess_, changed)) {
     LogError("hltConfig") << "HLT config extraction error with process name '" << nameProcess_ << "'";
   } else if (hltConfig.size() <= 0) {
     LogError("hltConfig") << "HLT config size error";
   } else
     hltConfigInit_ = true;
  
   // Update mapping from filter names to path names
   if (hltConfigInit_ && changed)
     moduleLabelToPathAndFlags_.init(hltConfig);
  
   // Extract pre-scales
   if (hltConfigInit_) {
     // Start empty
     hltPrescaleTableRun_ = trigger::HLTPrescaleTable();
     // Try run product, if configured
     if (!labelHltPrescaleTable_.empty()) {
       Handle<trigger::HLTPrescaleTable> handleHltPrescaleTable;
       iRun.getByLabel(InputTag(labelHltPrescaleTable_, "Run", nameProcess_), handleHltPrescaleTable);
       if (handleHltPrescaleTable.isValid()) {
         hltPrescaleTableRun_ = trigger::HLTPrescaleTable(
             handleHltPrescaleTable->set(), handleHltPrescaleTable->labels(), handleHltPrescaleTable->table());
       }
     }
   }
 }

◆ produce()

void PATTriggerProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 503 of file PATTriggerProducer.cc.

                                                                         {
   // Terminate, if auto process name determination failed
   if (nameProcess_ == "*")
     return;
  
   auto triggerObjects = std::make_unique<TriggerObjectCollection>();
   auto triggerObjectsStandAlone = std::make_unique<TriggerObjectStandAloneCollection>();
   std::unique_ptr<PackedTriggerPrescales> packedPrescales, packedPrescalesL1min, packedPrescalesL1max;
  
   // HLT
   HLTConfigProvider const& hltConfig = hltPrescaleProvider_.hltConfigProvider();
  
   // Get and check HLT event data
   Handle<trigger::TriggerEvent> handleTriggerEvent;
   iEvent.getByLabel(tagTriggerEvent_, handleTriggerEvent);
   Handle<TriggerResults> handleTriggerResults;
   iEvent.getByLabel(tagTriggerResults_, handleTriggerResults);
   bool goodHlt(hltConfigInit_);
   if (goodHlt) {
     if (!handleTriggerResults.isValid()) {
       LogError("triggerResultsValid") << "TriggerResults product with InputTag '" << tagTriggerResults_.encode()
                                       << "' not in event\n"
                                       << "No HLT information produced";
       goodHlt = false;
     } else if (!handleTriggerEvent.isValid()) {
       LogError("triggerEventValid") << "trigger::TriggerEvent product with InputTag '" << tagTriggerEvent_.encode()
                                     << "' not in event\n"
                                     << "No HLT information produced";
       goodHlt = false;
     }
   }
  
   // Produce HLT paths and determine status of modules
  
   if (goodHlt) {
     // Extract pre-scales
     // Start from lumi
     trigger::HLTPrescaleTable hltPrescaleTable(
         hltPrescaleTableLumi_.set(), hltPrescaleTableLumi_.labels(), hltPrescaleTableLumi_.table());
     // Try event product, if configured and available
     if (!labelHltPrescaleTable_.empty()) {
       Handle<trigger::HLTPrescaleTable> handleHltPrescaleTable;
       iEvent.getByLabel(InputTag(labelHltPrescaleTable_, "Event", nameProcess_), handleHltPrescaleTable);
       if (handleHltPrescaleTable.isValid()) {
         hltPrescaleTable = trigger::HLTPrescaleTable(
             handleHltPrescaleTable->set(), handleHltPrescaleTable->labels(), handleHltPrescaleTable->table());
       }
     }
     // Try event setup, if no product
     if (hltPrescaleTable.size() == 0) {
       if (!labelHltPrescaleTable_.empty()) {
         LogWarning("hltPrescaleInputTag") << "HLTPrescaleTable product with label '" << labelHltPrescaleTable_
                                           << "' not found in process" << nameProcess_ << "\n"
                                           << "Using default from event setup";
       }
       if (hltConfig.prescaleSize() > 0) {
         if (hltPrescaleProvider_.prescaleSet(iEvent, iSetup) != -1) {
           hltPrescaleTable = trigger::HLTPrescaleTable(
               hltPrescaleProvider_.prescaleSet(iEvent, iSetup), hltConfig.prescaleLabels(), hltConfig.prescaleTable());
           LogDebug("hltPrescaleTable") << "HLT prescale table found in event setup";
         } else {
           LogWarning("hltPrescaleSet") << "HLTPrescaleTable from event setup has error";
         }
       }
     }
     unsigned set(hltPrescaleTable.set());
     if (hltPrescaleTable.size() > 0) {
       if (!hltPrescaleLabel_.empty()) {
         bool foundPrescaleLabel(false);
         for (unsigned iLabel = 0; iLabel < hltPrescaleTable.labels().size(); ++iLabel) {
           if (hltPrescaleTable.labels().at(iLabel) == hltPrescaleLabel_) {
             set = iLabel;
             foundPrescaleLabel = true;
             break;
           }
         }
         if (!foundPrescaleLabel) {
           LogWarning("hltPrescaleLabel") << "HLT prescale label '" << hltPrescaleLabel_ << "' not in prescale table\n"
                                          << "Using default";
         }
       }
     } else if (iEvent.isRealData()) {
       if ((labelHltPrescaleTable_.empty() && firstInRun_) || !labelHltPrescaleTable_.empty()) {
         LogError("hltPrescaleTable") << "No HLT prescale table found\n"
                                      << "Using default empty table with all prescales 1";
       }
     }
  
     const unsigned sizePaths(hltConfig.size());
     const unsigned sizeFilters(handleTriggerEvent->sizeFilters());
     const unsigned sizeObjects(handleTriggerEvent->sizeObjects());
  
     std::map<std::string, int> moduleStates;
  
     if (!onlyStandAlone_) {
       auto triggerPaths = std::make_unique<TriggerPathCollection>();
       triggerPaths->reserve(sizePaths);
       const std::vector<std::string>& pathNames = hltConfig.triggerNames();
       for (size_t indexPath = 0; indexPath < sizePaths; ++indexPath) {
         const std::string& namePath = pathNames.at(indexPath);
         unsigned indexLastFilterPathModules(handleTriggerResults->index(indexPath) + 1);
         const unsigned sizeModulesPath(hltConfig.size(indexPath));
         //protection for paths with zero filters (needed for reco, digi, etc paths)
         if (sizeModulesPath != 0) {
           while (indexLastFilterPathModules > 0) {
             --indexLastFilterPathModules;
             const std::string& labelLastFilterPathModules(hltConfig.moduleLabel(indexPath, indexLastFilterPathModules));
             unsigned indexLastFilterFilters =
                 handleTriggerEvent->filterIndex(InputTag(labelLastFilterPathModules, "", nameProcess_));
             if (indexLastFilterFilters < sizeFilters) {
               if (hltConfig.moduleType(labelLastFilterPathModules) == "HLTBool")
                 continue;
               break;
             }
           }
         } else {
           indexLastFilterPathModules = 0;
         }
         TriggerPath triggerPath(namePath,
                                 indexPath,
                                 hltConfig.prescaleValue(set, namePath),
                                 handleTriggerResults->wasrun(indexPath),
                                 handleTriggerResults->accept(indexPath),
                                 handleTriggerResults->error(indexPath),
                                 indexLastFilterPathModules,
                                 hltConfig.saveTagsModules(namePath).size());
         // add module names to path and states' map
  
         assert(indexLastFilterPathModules < sizeModulesPath || sizeModulesPath == 0);
         std::map<unsigned, std::string> indicesModules;
         for (size_t iM = 0; iM < sizeModulesPath; ++iM) {
           const std::string& nameModule(hltConfig.moduleLabel(indexPath, iM));
           if (addPathModuleLabels_) {
             triggerPath.addModule(nameModule);
           }
           const unsigned indexFilter(handleTriggerEvent->filterIndex(InputTag(nameModule, "", nameProcess_)));
           if (indexFilter < sizeFilters) {
             triggerPath.addFilterIndex(indexFilter);
           }
           const unsigned slotModule(hltConfig.moduleIndex(indexPath, nameModule));
           indicesModules.insert(std::pair<unsigned, std::string>(slotModule, nameModule));
         }
         // add L1 seeds
         const L1SeedCollection& l1Seeds(hltConfig.hltL1GTSeeds(namePath));
         for (L1SeedCollection::const_iterator iSeed = l1Seeds.begin(); iSeed != l1Seeds.end(); ++iSeed) {
           triggerPath.addL1Seed(*iSeed);
         }
         // store path
         triggerPaths->push_back(triggerPath);
         // cache module states to be used for the filters
         for (std::map<unsigned, std::string>::const_iterator iM = indicesModules.begin(); iM != indicesModules.end();
              ++iM) {
           if (iM->first < indexLastFilterPathModules) {
             moduleStates[iM->second] = 1;
           } else if (iM->first == indexLastFilterPathModules) {
             moduleStates[iM->second] = handleTriggerResults->accept(indexPath);
           } else if (moduleStates.find(iM->second) == moduleStates.end()) {
             moduleStates[iM->second] = -1;
           }
         }
       }
       // Put HLT paths to event
       iEvent.put(std::move(triggerPaths));
     }
  
     // Store used trigger objects and their types for HLT filters
     // (only active filter(s) available from trigger::TriggerEvent)
  
     std::multimap<trigger::size_type, int> objectTypes;
     std::multimap<trigger::size_type, std::string> filterLabels;
  
     for (size_t iF = 0; iF < sizeFilters; ++iF) {
       const std::string nameFilter(handleTriggerEvent->filterLabel(iF));
       const trigger::Keys& keys = handleTriggerEvent->filterKeys(iF);
       const trigger::Vids& types = handleTriggerEvent->filterIds(iF);
       assert(types.size() == keys.size());
       for (size_t iK = 0; iK < keys.size(); ++iK) {
         filterLabels.insert(std::pair<trigger::size_type, std::string>(keys[iK], nameFilter));
         objectTypes.insert(std::pair<trigger::size_type, int>(keys[iK], types[iK]));
       }
     }
  
     // HLT objects
  
     triggerObjects->reserve(onlyStandAlone_ ? 0 : sizeObjects);
     triggerObjectsStandAlone->reserve(sizeObjects);
  
     const trigger::Keys& collectionKeys(handleTriggerEvent->collectionKeys());
     std::map<trigger::size_type, trigger::size_type> newObjectKeys;
     for (size_t iO = 0, iC = 0, nC = handleTriggerEvent->sizeCollections(); iO < sizeObjects && iC < nC; ++iO) {
       const trigger::TriggerObject tobj = handleTriggerEvent->getObjects().at(iO);
       TriggerObject triggerObject(reco::Particle::PolarLorentzVector(tobj.pt(), tobj.eta(), tobj.phi(), tobj.mass()),
                                   tobj.id());
       // set collection
       while (iO >= collectionKeys[iC])
         ++iC;  // relies on well ordering of trigger objects with respect to the collections
       triggerObject.setCollection(handleTriggerEvent->collectionTagEncoded(iC));
       // set filter ID
       typedef std::multimap<trigger::size_type, int>::const_iterator it_type;
       for (std::pair<it_type, it_type> trange = objectTypes.equal_range(iO); trange.first != trange.second;
            ++trange.first) {
         triggerObject.addTriggerObjectType(trange.first->second);
       }
  
       // stand-alone trigger object
       TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
       // check for excluded collections
       bool excluded(false);
       for (size_t iE = 0; iE < exludeCollections_.size(); ++iE) {
         if (triggerObjectStandAlone.hasCollection(exludeCollections_.at(iE))) {
           if (!onlyStandAlone_)
             newObjectKeys[iO] = trigger::size_type(sizeObjects);
           excluded = true;
           break;
         }
       }
       if (excluded)
         continue;
       typedef std::multimap<trigger::size_type, std::string>::const_iterator it_fl;
       for (std::pair<it_fl, it_fl> frange = filterLabels.equal_range(iO); frange.first != frange.second;
            ++frange.first) {
         triggerObjectStandAlone.addFilterLabel(frange.first->second);
         const std::vector<ModuleLabelToPathAndFlags::PathAndFlags>& paths =
             moduleLabelToPathAndFlags_[frange.first->second];
         for (std::vector<ModuleLabelToPathAndFlags::PathAndFlags>::const_iterator iP = paths.begin(); iP != paths.end();
              ++iP) {
           bool pathFired = handleTriggerResults->wasrun(iP->pathIndex) && handleTriggerResults->accept(iP->pathIndex);
           triggerObjectStandAlone.addPathName(iP->pathName, pathFired && iP->lastFilter, pathFired && iP->l3Filter);
         }
       }
  
       triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
       if (!onlyStandAlone_) {
         triggerObjects->push_back(triggerObject);
         newObjectKeys[iO] = trigger::size_type(triggerObjects->size() - 1);
       }
     }
  
     // Re-iterate HLT filters and finally produce them in order to account for optionally skipped objects
     if (!onlyStandAlone_) {
       auto triggerFilters = std::make_unique<TriggerFilterCollection>();
       triggerFilters->reserve(sizeFilters);
       for (size_t iF = 0; iF < sizeFilters; ++iF) {
         const std::string nameFilter(handleTriggerEvent->filterTag(iF).label());
         const trigger::Keys& keys = handleTriggerEvent->filterKeys(iF);  // not cached
         const trigger::Vids& types = handleTriggerEvent->filterIds(iF);  // not cached
         TriggerFilter triggerFilter(nameFilter);
         // set filter type
         const std::string typeFilter(hltConfig.moduleType(nameFilter));
         triggerFilter.setType(typeFilter);
         triggerFilter.setSaveTags(hltConfig.saveTags(nameFilter));
         // set keys and trigger object types of used objects
         for (size_t iK = 0; iK < keys.size(); ++iK) {  // identical to types.size()
           // check, if current object is excluded
           if (newObjectKeys.find(keys.at(iK)) != newObjectKeys.end()) {
             if (newObjectKeys[keys.at(iK)] == sizeObjects)
               continue;
             triggerFilter.addObjectKey(newObjectKeys[keys.at(iK)]);
             triggerFilter.addTriggerObjectType(types.at(iK));
           } else {
             LogWarning("triggerObjectKey") << "TriggerFilter '" << nameFilter
                                            << "' requests non-existing TriggerObject key " << keys.at(iK) << "\n"
                                            << "Skipping object assignment";
           }
         }
         // set status from path info
         std::map<std::string, int>::iterator iS(moduleStates.find(nameFilter));
         if (iS != moduleStates.end()) {
           if (!triggerFilter.setStatus(iS->second)) {
             triggerFilter.setStatus(-1);  // FIXME different code for "unvalid status determined" needed?
           }
         } else {
           triggerFilter.setStatus(-1);  // FIXME different code for "unknown" needed?
         }
         // store filter
         triggerFilters->push_back(triggerFilter);
       }
       // put HLT filters to event
       iEvent.put(std::move(triggerFilters));
     }
  
     if (packPrescales_) {
       packedPrescales = std::make_unique<PackedTriggerPrescales>(handleTriggerResults);
       packedPrescalesL1min = std::make_unique<PackedTriggerPrescales>(handleTriggerResults);
       packedPrescalesL1max = std::make_unique<PackedTriggerPrescales>(handleTriggerResults);
       const edm::TriggerNames& names = iEvent.triggerNames(*handleTriggerResults);
       //std::cout << "Run " << iEvent.id().run() << ", LS " << iEvent.id().luminosityBlock() << ": pset " << set << std::endl;
       for (unsigned int i = 0, n = names.size(); i < n; ++i) {
         auto pvdet = hltPrescaleProvider_.prescaleValuesInDetail(iEvent, iSetup, names.triggerName(i));
         //int hltprescale = hltConfig_.prescaleValue(set, names.triggerName(i));
         if (pvdet.first.empty()) {
           packedPrescalesL1max->addPrescaledTrigger(i, 1);
           packedPrescalesL1min->addPrescaledTrigger(i, 1);
         } else {
           int pmin = -1, pmax = -1;
           for (const auto& p : pvdet.first) {
             pmax = std::max(pmax, p.second);
             if (p.second > 0 && (pmin == -1 || pmin > p.second))
               pmin = p.second;
           }
           packedPrescalesL1max->addPrescaledTrigger(i, pmax);
           packedPrescalesL1min->addPrescaledTrigger(i, pmin);
           //std::cout << "\tTrigger " << names.triggerName(i) << ", L1 ps " << pmin << "-" << pmax << ", HLT ps " << hltprescale << std::endl;
         }
         packedPrescales->addPrescaledTrigger(i, pvdet.second);
         //assert( hltprescale == pvdet.second );
       }
       iEvent.put(std::move(packedPrescales));
       iEvent.put(std::move(packedPrescalesL1max), "l1max");
       iEvent.put(std::move(packedPrescalesL1min), "l1min");
     }
  
   }  // if ( goodHlt )
  
   // L1 objects
   // (needs to be done after HLT objects, since their x-links with filters rely on their collection keys)
  
   // map for assignments of objects to conditions
   std::map<L1GtObject, std::vector<unsigned> > l1ObjectTypeMap;
   if (!tagL1ExtraMu_.label().empty()) {
     Handle<l1extra::L1MuonParticleCollection> handleL1ExtraMu;
     iEvent.getByLabel(tagL1ExtraMu_, handleL1ExtraMu);
     if (handleL1ExtraMu.isValid()) {
       std::vector<unsigned> muKeys;
       for (size_t l1Mu = 0; l1Mu < handleL1ExtraMu->size(); ++l1Mu) {
         if (mainBxOnly_ && handleL1ExtraMu->at(l1Mu).bx() != 0)
           continue;
         TriggerObject triggerObject;
         if (saveL1Refs_) {
           const reco::CandidateBaseRef leafCandRef(l1extra::L1MuonParticleRef(handleL1ExtraMu, l1Mu));
           triggerObject = TriggerObject(leafCandRef);
         } else {
           const reco::LeafCandidate leafCandidate(*(handleL1ExtraMu->at(l1Mu).reco::LeafCandidate::clone()));
           triggerObject = TriggerObject(leafCandidate);
         }
         triggerObject.setCollection(tagL1ExtraMu_);
         triggerObject.addTriggerObjectType(trigger::TriggerL1Mu);
         if (!onlyStandAlone_)
           triggerObjects->push_back(triggerObject);
         TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
         triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
         if (handleL1ExtraMu->at(l1Mu).bx() == 0)
           muKeys.push_back(triggerObjectsStandAlone->size() - 1);
       }
       l1ObjectTypeMap.insert(std::make_pair(Mu, muKeys));
     } else
       LogError("l1ExtraValid") << "l1extra::L1MuonParticleCollection product with InputTag '" << tagL1ExtraMu_.encode()
                                << "' not in event";
   }
   if (!tagL1ExtraNoIsoEG_.label().empty()) {
     Handle<l1extra::L1EmParticleCollection> handleL1ExtraNoIsoEG;
     iEvent.getByLabel(tagL1ExtraNoIsoEG_, handleL1ExtraNoIsoEG);
     if (handleL1ExtraNoIsoEG.isValid()) {
       std::vector<unsigned> noIsoEGKeys;
       for (size_t l1NoIsoEG = 0; l1NoIsoEG < handleL1ExtraNoIsoEG->size(); ++l1NoIsoEG) {
         if (mainBxOnly_ && handleL1ExtraNoIsoEG->at(l1NoIsoEG).bx() != 0)
           continue;
         TriggerObject triggerObject;
         if (saveL1Refs_) {
           const reco::CandidateBaseRef leafCandRef(l1extra::L1EmParticleRef(handleL1ExtraNoIsoEG, l1NoIsoEG));
           triggerObject = TriggerObject(leafCandRef);
         } else {
           const reco::LeafCandidate leafCandidate(*(handleL1ExtraNoIsoEG->at(l1NoIsoEG).reco::LeafCandidate::clone()));
           triggerObject = TriggerObject(leafCandidate);
         }
         triggerObject.setCollection(tagL1ExtraNoIsoEG_);
         triggerObject.addTriggerObjectType(trigger::TriggerL1NoIsoEG);
         if (!onlyStandAlone_)
           triggerObjects->push_back(triggerObject);
         TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
         triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
         if (handleL1ExtraNoIsoEG->at(l1NoIsoEG).bx() == 0)
           noIsoEGKeys.push_back(triggerObjectsStandAlone->size() - 1);
       }
       l1ObjectTypeMap.insert(std::make_pair(NoIsoEG, noIsoEGKeys));
     } else
       LogError("l1ExtraValid") << "l1extra::L1EmParticleCollection product with InputTag '"
                                << tagL1ExtraNoIsoEG_.encode() << "' not in event";
   }
   if (!tagL1ExtraIsoEG_.label().empty()) {
     Handle<l1extra::L1EmParticleCollection> handleL1ExtraIsoEG;
     iEvent.getByLabel(tagL1ExtraIsoEG_, handleL1ExtraIsoEG);
     if (handleL1ExtraIsoEG.isValid()) {
       std::vector<unsigned> isoEGKeys;
       for (size_t l1IsoEG = 0; l1IsoEG < handleL1ExtraIsoEG->size(); ++l1IsoEG) {
         if (mainBxOnly_ && handleL1ExtraIsoEG->at(l1IsoEG).bx() != 0)
           continue;
         TriggerObject triggerObject;
         if (saveL1Refs_) {
           const reco::CandidateBaseRef leafCandRef(l1extra::L1EmParticleRef(handleL1ExtraIsoEG, l1IsoEG));
           triggerObject = TriggerObject(leafCandRef);
         } else {
           const reco::LeafCandidate leafCandidate(*(handleL1ExtraIsoEG->at(l1IsoEG).reco::LeafCandidate::clone()));
           triggerObject = TriggerObject(leafCandidate);
         }
         triggerObject.setCollection(tagL1ExtraIsoEG_);
         triggerObject.addTriggerObjectType(trigger::TriggerL1IsoEG);
         if (!onlyStandAlone_)
           triggerObjects->push_back(triggerObject);
         TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
         triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
         if (handleL1ExtraIsoEG->at(l1IsoEG).bx() == 0)
           isoEGKeys.push_back(triggerObjectsStandAlone->size() - 1);
       }
       l1ObjectTypeMap.insert(std::make_pair(IsoEG, isoEGKeys));
     } else
       LogError("l1ExtraValid") << "l1extra::L1EmParticleCollection product with InputTag '" << tagL1ExtraIsoEG_.encode()
                                << "' not in event";
   }
   if (!tagL1ExtraCenJet_.label().empty()) {
     Handle<l1extra::L1JetParticleCollection> handleL1ExtraCenJet;
     iEvent.getByLabel(tagL1ExtraCenJet_, handleL1ExtraCenJet);
     if (handleL1ExtraCenJet.isValid()) {
       std::vector<unsigned> cenJetKeys;
       for (size_t l1CenJet = 0; l1CenJet < handleL1ExtraCenJet->size(); ++l1CenJet) {
         if (mainBxOnly_ && handleL1ExtraCenJet->at(l1CenJet).bx() != 0)
           continue;
         TriggerObject triggerObject;
         if (saveL1Refs_) {
           const reco::CandidateBaseRef leafCandRef(l1extra::L1JetParticleRef(handleL1ExtraCenJet, l1CenJet));
           triggerObject = TriggerObject(leafCandRef);
         } else {
           const reco::LeafCandidate leafCandidate(*(handleL1ExtraCenJet->at(l1CenJet).reco::LeafCandidate::clone()));
           triggerObject = TriggerObject(leafCandidate);
         }
         triggerObject.setCollection(tagL1ExtraCenJet_);
         triggerObject.addTriggerObjectType(trigger::TriggerL1CenJet);
         if (!onlyStandAlone_)
           triggerObjects->push_back(triggerObject);
         TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
         triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
         if (handleL1ExtraCenJet->at(l1CenJet).bx() == 0)
           cenJetKeys.push_back(triggerObjectsStandAlone->size() - 1);
       }
       l1ObjectTypeMap.insert(std::make_pair(CenJet, cenJetKeys));
     } else
       LogError("l1ExtraValid") << "l1extra::L1JetParticleCollection product with InputTag '"
                                << tagL1ExtraCenJet_.encode() << "' not in event";
   }
   if (!tagL1ExtraForJet_.label().empty()) {
     Handle<l1extra::L1JetParticleCollection> handleL1ExtraForJet;
     iEvent.getByLabel(tagL1ExtraForJet_, handleL1ExtraForJet);
     if (handleL1ExtraForJet.isValid()) {
       std::vector<unsigned> forJetKeys;
       for (size_t l1ForJet = 0; l1ForJet < handleL1ExtraForJet->size(); ++l1ForJet) {
         if (mainBxOnly_ && handleL1ExtraForJet->at(l1ForJet).bx() != 0)
           continue;
         TriggerObject triggerObject;
         if (saveL1Refs_) {
           const reco::CandidateBaseRef leafCandRef(l1extra::L1JetParticleRef(handleL1ExtraForJet, l1ForJet));
           triggerObject = TriggerObject(leafCandRef);
         } else {
           const reco::LeafCandidate leafCandidate(*(handleL1ExtraForJet->at(l1ForJet).reco::LeafCandidate::clone()));
           triggerObject = TriggerObject(leafCandidate);
         }
         triggerObject.setCollection(tagL1ExtraForJet_);
         triggerObject.addTriggerObjectType(trigger::TriggerL1ForJet);
         if (!onlyStandAlone_)
           triggerObjects->push_back(triggerObject);
         TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
         triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
         if (handleL1ExtraForJet->at(l1ForJet).bx() == 0)
           forJetKeys.push_back(triggerObjectsStandAlone->size() - 1);
       }
       l1ObjectTypeMap.insert(std::make_pair(ForJet, forJetKeys));
     } else
       LogError("l1ExtraValid") << "l1extra::L1JetParticleCollection product with InputTag '"
                                << tagL1ExtraForJet_.encode() << "' not in event";
   }
   if (!tagL1ExtraTauJet_.label().empty()) {
     Handle<l1extra::L1JetParticleCollection> handleL1ExtraTauJet;
     iEvent.getByLabel(tagL1ExtraTauJet_, handleL1ExtraTauJet);
     if (handleL1ExtraTauJet.isValid()) {
       std::vector<unsigned> tauJetKeys;
       for (size_t l1TauJet = 0; l1TauJet < handleL1ExtraTauJet->size(); ++l1TauJet) {
         if (mainBxOnly_ && handleL1ExtraTauJet->at(l1TauJet).bx() != 0)
           continue;
         TriggerObject triggerObject;
         if (saveL1Refs_) {
           const reco::CandidateBaseRef leafCandRef(l1extra::L1JetParticleRef(handleL1ExtraTauJet, l1TauJet));
           triggerObject = TriggerObject(leafCandRef);
         } else {
           const reco::LeafCandidate leafCandidate(*(handleL1ExtraTauJet->at(l1TauJet).reco::LeafCandidate::clone()));
           triggerObject = TriggerObject(leafCandidate);
         }
         triggerObject.setCollection(tagL1ExtraTauJet_);
         triggerObject.addTriggerObjectType(trigger::TriggerL1TauJet);
         if (!onlyStandAlone_)
           triggerObjects->push_back(triggerObject);
         TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
         triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
         if (handleL1ExtraTauJet->at(l1TauJet).bx() == 0)
           tauJetKeys.push_back(triggerObjectsStandAlone->size() - 1);
       }
       l1ObjectTypeMap.insert(std::make_pair(TauJet, tauJetKeys));
     } else
       LogError("l1ExtraValid") << "l1extra::L1JetParticleCollection product with InputTag '"
                                << tagL1ExtraTauJet_.encode() << "' not in event";
   }
   if (!tagL1ExtraETM_.label().empty()) {
     Handle<l1extra::L1EtMissParticleCollection> handleL1ExtraETM;
     iEvent.getByLabel(tagL1ExtraETM_, handleL1ExtraETM);
     if (handleL1ExtraETM.isValid()) {
       std::vector<unsigned> etmKeys;
       for (size_t l1ETM = 0; l1ETM < handleL1ExtraETM->size(); ++l1ETM) {
         if (mainBxOnly_ && handleL1ExtraETM->at(l1ETM).bx() != 0)
           continue;
         TriggerObject triggerObject;
         if (saveL1Refs_) {
           const reco::CandidateBaseRef leafCandRef(l1extra::L1EtMissParticleRef(handleL1ExtraETM, l1ETM));
           triggerObject = TriggerObject(leafCandRef);
         } else {
           const reco::LeafCandidate leafCandidate(*(handleL1ExtraETM->at(l1ETM).reco::LeafCandidate::clone()));
           triggerObject = TriggerObject(leafCandidate);
         }
         triggerObject.setCollection(tagL1ExtraETM_);
         triggerObject.addTriggerObjectType(trigger::TriggerL1ETM);
         if (!onlyStandAlone_)
           triggerObjects->push_back(triggerObject);
         TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
         triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
         if (handleL1ExtraETM->at(l1ETM).bx() == 0)
           etmKeys.push_back(triggerObjectsStandAlone->size() - 1);
       }
       l1ObjectTypeMap.insert(std::make_pair(ETM, etmKeys));
     } else
       LogError("l1ExtraValid") << "l1extra::L1EtMissParticleCollection product with InputTag '"
                                << tagL1ExtraETM_.encode() << "' not in event";
   }
   if (!tagL1ExtraHTM_.label().empty()) {
     Handle<l1extra::L1EtMissParticleCollection> handleL1ExtraHTM;
     iEvent.getByLabel(tagL1ExtraHTM_, handleL1ExtraHTM);
     if (handleL1ExtraHTM.isValid()) {
       std::vector<unsigned> htmKeys;
       for (size_t l1HTM = 0; l1HTM < handleL1ExtraHTM->size(); ++l1HTM) {
         if (mainBxOnly_ && handleL1ExtraHTM->at(l1HTM).bx() != 0)
           continue;
         TriggerObject triggerObject;
         if (saveL1Refs_) {
           const reco::CandidateBaseRef leafCandRef(l1extra::L1EtMissParticleRef(handleL1ExtraHTM, l1HTM));
           triggerObject = TriggerObject(leafCandRef);
         } else {
           const reco::LeafCandidate leafCandidate(*(handleL1ExtraHTM->at(l1HTM).reco::LeafCandidate::clone()));
           triggerObject = TriggerObject(leafCandidate);
         }
         triggerObject.setCollection(tagL1ExtraHTM_);
         triggerObject.addTriggerObjectType(trigger::TriggerL1HTM);
         if (!onlyStandAlone_)
           triggerObjects->push_back(triggerObject);
         TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
         triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
         if (handleL1ExtraHTM->at(l1HTM).bx() == 0)
           htmKeys.push_back(triggerObjectsStandAlone->size() - 1);
       }
       l1ObjectTypeMap.insert(std::make_pair(HTM, htmKeys));
     } else
       LogError("l1ExtraValid") << "l1extra::L1EtMissParticleCollection product with InputTag '"
                                << tagL1ExtraHTM_.encode() << "' not in event";
   }
  
   // Put trigger objects to event
   if (!onlyStandAlone_)
     iEvent.put(std::move(triggerObjects));
  
   // L1 algorithms
   if (!onlyStandAlone_) {
     auto triggerAlgos = std::make_unique<TriggerAlgorithmCollection>();
     auto triggerConditions = std::make_unique<TriggerConditionCollection>();
     if (addL1Algos_) {
       // create trigger object types transalation map (yes, it's ugly!)
       std::map<L1GtObject, trigger::TriggerObjectType> mapObjectTypes;
       mapObjectTypes.insert(std::make_pair(Mu, trigger::TriggerL1Mu));
       mapObjectTypes.insert(std::make_pair(NoIsoEG, trigger::TriggerL1NoIsoEG));
       mapObjectTypes.insert(std::make_pair(IsoEG, trigger::TriggerL1IsoEG));
       mapObjectTypes.insert(std::make_pair(CenJet, trigger::TriggerL1CenJet));
       mapObjectTypes.insert(std::make_pair(ForJet, trigger::TriggerL1ForJet));
       mapObjectTypes.insert(std::make_pair(TauJet, trigger::TriggerL1TauJet));
       mapObjectTypes.insert(std::make_pair(ETM, trigger::TriggerL1ETM));
       mapObjectTypes.insert(std::make_pair(HTM, trigger::TriggerL1HTM));
       // get and cache L1 menu
       L1GtUtils const& l1GtUtils = hltPrescaleProvider_.l1GtUtils();
       auto handleL1GtTriggerMenu = iSetup.getHandle(handleL1GtTriggerMenuToken_);
       auto const& l1GtAlgorithms = handleL1GtTriggerMenu->gtAlgorithmMap();
       auto const& l1GtTechTriggers = handleL1GtTriggerMenu->gtTechnicalTriggerMap();
       auto const& l1GtConditionsVector = handleL1GtTriggerMenu->gtConditionMap();
       // cache conditions in one single condition map
       ConditionMap l1GtConditions;
       for (size_t iCv = 0; iCv < l1GtConditionsVector.size(); ++iCv) {
         l1GtConditions.insert(l1GtConditionsVector.at(iCv).begin(), l1GtConditionsVector.at(iCv).end());
       }
       triggerAlgos->reserve(l1GtAlgorithms.size() + l1GtTechTriggers.size());
       Handle<L1GlobalTriggerObjectMaps> handleL1GlobalTriggerObjectMaps;
       iEvent.getByToken(l1GlobalTriggerObjectMapsToken_, handleL1GlobalTriggerObjectMaps);
       if (!handleL1GlobalTriggerObjectMaps.isValid()) {
         LogError("l1ObjectMap") << "L1GlobalTriggerObjectMaps product with InputTag '"
                                 << tagL1GlobalTriggerObjectMaps_.encode() << "' not in event\n"
                                 << "No L1 objects and GTL results available for physics algorithms";
       }
       handleL1GlobalTriggerObjectMaps->consistencyCheck();
       if (firstInRun_) {
         l1PSet_ = (ParameterSet*)(pset::Registry::instance()->getMapped(
             handleL1GlobalTriggerObjectMaps->namesParameterSetID()));
         if (l1PSet_ == nullptr) {
           LogError("l1ObjectMap") << "ParameterSet registry not available\n"
                                   << "Skipping conditions for all L1 physics algorithm names in this run";
         }
       } else {
         if (l1PSet_ == nullptr) {
           LogInfo("l1ObjectMap") << "ParameterSet registry not available\n"
                                  << "Skipping conditions for all L1 physics algorithm names in this event";
         }
       }
       // physics algorithms
       for (CItAlgo iAlgo = l1GtAlgorithms.begin(); iAlgo != l1GtAlgorithms.end(); ++iAlgo) {
         const std::string& algoName(iAlgo->second.algoName());
         if (!(iAlgo->second.algoBitNumber() < int(L1GlobalTriggerReadoutSetup::NumberPhysTriggers))) {
           LogError("l1Algo") << "L1 physics algorithm '" << algoName << "' has bit number "
                              << iAlgo->second.algoBitNumber()
                              << " >= " << L1GlobalTriggerReadoutSetup::NumberPhysTriggers << "\n"
                              << "Skipping";
           continue;
         }
         L1GtUtils::TriggerCategory category;
         int bit;
         if (!l1GtUtils.l1AlgoTechTrigBitNumber(algoName, category, bit)) {
           LogError("l1Algo") << "L1 physics algorithm '" << algoName << "' not found in the L1 menu\n"
                              << "Skipping";
           continue;
         }
         if (category != L1GtUtils::AlgorithmTrigger) {
           LogError("l1Algo") << "L1 physics algorithm '" << algoName
                              << "' does not have category 'AlgorithmTrigger' from 'L1GtUtils'\n"
                              << "Skipping";
           continue;
         }
         bool decisionBeforeMask;
         bool decisionAfterMask;
         int prescale;
         int mask;
         int error(l1GtUtils.l1Results(iEvent, algoName, decisionBeforeMask, decisionAfterMask, prescale, mask));
         if (error) {
           LogError("l1Algo") << "L1 physics algorithm '" << algoName << "' decision has error code " << error
                              << " from 'L1GtUtils'\n"
                              << "Skipping";
           continue;
         }
         TriggerAlgorithm triggerAlgo(algoName,
                                      iAlgo->second.algoAlias(),
                                      category == L1GtUtils::TechnicalTrigger,
                                      (unsigned)bit,
                                      (unsigned)prescale,
                                      (bool)mask,
                                      decisionBeforeMask,
                                      decisionAfterMask);
         triggerAlgo.setLogicalExpression(iAlgo->second.algoLogicalExpression());
         // GTL result and used conditions in physics algorithm
         if (!handleL1GlobalTriggerObjectMaps.isValid()) {
           triggerAlgos->push_back(triggerAlgo);
           continue;  // LogWarning already earlier (before loop)
         }
         if (!handleL1GlobalTriggerObjectMaps->algorithmExists(bit)) {
           LogError("l1ObjectMap") << "L1 physics algorithm '" << algoName
                                   << "' is missing in L1GlobalTriggerObjectMaps\n"
                                   << "Skipping conditions and GTL result";
           triggerAlgos->push_back(triggerAlgo);
           continue;
         }
         bool algorithmResult = handleL1GlobalTriggerObjectMaps->algorithmResult(bit);
         //         if ( ( algorithmResult != decisionBeforeMask ) && ( decisionBeforeMask == true || prescale == 1 ) ) {
         if ((algorithmResult != decisionBeforeMask) &&
             (decisionBeforeMask == true)) {  // FIXME: understand the difference for un-prescaled algos 118, 119, 123
           LogInfo("l1ObjectMap") << "L1 physics algorithm '" << algoName << "' with different decisions in\n"
                                  << "L1GlobalTriggerObjectMaps (GTL result)        : " << algorithmResult << "\n"
                                  << "L1GlobalTriggerReadoutRecord (decision before mask): " << decisionBeforeMask;
         }
         triggerAlgo.setGtlResult(algorithmResult);
         // conditions in algorithm
         L1GlobalTriggerObjectMaps::ConditionsInAlgorithm conditions =
             handleL1GlobalTriggerObjectMaps->getConditionsInAlgorithm(bit);
         if (l1PSet_ == nullptr) {
           triggerAlgos->push_back(triggerAlgo);
           continue;
         }
         if (!l1PSet_->exists(algoName)) {
           if (firstInRun_) {
             LogError("l1ObjectMap") << "L1 physics algorithm name '" << algoName
                                     << "' not available in ParameterSet registry\n"
                                     << "Skipping conditions for this algorithm in this run";
           } else {
             LogInfo("l1ObjectMap") << "L1 physics algorithm name '" << algoName
                                    << "' not available in ParameterSet registry\n"
                                    << "Skipping conditions for this algorithm in this event";
           }
           triggerAlgos->push_back(triggerAlgo);
           continue;
         }
         std::vector<std::string> conditionNames(l1PSet_->getParameter<std::vector<std::string> >(algoName));
  
         for (unsigned iT = 0; iT < conditionNames.size(); ++iT) {
           size_t key(triggerConditions->size());
           for (size_t iC = 0; iC < triggerConditions->size(); ++iC) {
             if (conditionNames.at(iT) == triggerConditions->at(iC).name()) {
               key = iC;
               break;
             }
           }
           if (key == triggerConditions->size()) {
             if (iT >= conditions.nConditions()) {
               LogError("l1CondMap") << "More condition names from ParameterSet registry than the "
                                     << conditions.nConditions() << " conditions in L1GlobalTriggerObjectMaps\n"
                                     << "Skipping condition " << conditionNames.at(iT) << " in algorithm " << algoName;
               break;
             }
             TriggerCondition triggerCond(conditionNames[iT], conditions.getConditionResult(iT));
             if (l1GtConditions.find(triggerCond.name()) != l1GtConditions.end()) {
               triggerCond.setCategory(l1GtConditions[triggerCond.name()]->condCategory());
               triggerCond.setType(l1GtConditions[triggerCond.name()]->condType());
               const std::vector<L1GtObject> l1ObjectTypes(l1GtConditions[triggerCond.name()]->objectType());
               for (size_t iType = 0; iType < l1ObjectTypes.size(); ++iType) {
                 triggerCond.addTriggerObjectType(mapObjectTypes[l1ObjectTypes.at(iType)]);
               }
               // objects in condition
               L1GlobalTriggerObjectMaps::CombinationsInCondition combinations =
                   handleL1GlobalTriggerObjectMaps->getCombinationsInCondition(bit, iT);
               for (size_t iVV = 0; iVV < combinations.nCombinations(); ++iVV) {
                 for (size_t iV = 0; iV < combinations.nObjectsPerCombination(); ++iV) {
                   unsigned objectIndex = combinations.getObjectIndex(iVV, iV);
                   if (iV >= l1ObjectTypes.size()) {
                     LogError("l1CondMap") << "Index " << iV << " in combinations vector overshoots size "
                                           << l1ObjectTypes.size() << " of types vector in conditions map\n"
                                           << "Skipping object key in condition " << triggerCond.name();
                   } else if (l1ObjectTypeMap.find(l1ObjectTypes.at(iV)) != l1ObjectTypeMap.end()) {
                     if (objectIndex >= l1ObjectTypeMap[l1ObjectTypes.at(iV)].size()) {
                       LogError("l1CondMap")
                           << "Index " << objectIndex << " in combination overshoots number "
                           << l1ObjectTypeMap[l1ObjectTypes.at(iV)].size() << "of according trigger objects\n"
                           << "Skipping object key in condition " << triggerCond.name();
                     }
                     const unsigned objectKey(l1ObjectTypeMap[l1ObjectTypes.at(iV)].at(objectIndex));
                     triggerCond.addObjectKey(objectKey);
                     // add current condition and algorithm also to the according stand-alone trigger object
                     triggerObjectsStandAlone->at(objectKey).addAlgorithmName(
                         triggerAlgo.name(), (triggerAlgo.decision() && triggerCond.wasAccept()));
                     triggerObjectsStandAlone->at(objectKey).addConditionName(triggerCond.name());
                   }
                 }
               }
             } else {
               LogWarning("l1CondMap") << "L1 conditions '" << triggerCond.name() << "' not found in the L1 menu\n"
                                       << "Remains incomplete";
             }
             triggerConditions->push_back(triggerCond);
           }
           triggerAlgo.addConditionKey(key);
         }
         triggerAlgos->push_back(triggerAlgo);
       }
       // technical triggers
       for (CItAlgo iAlgo = l1GtTechTriggers.begin(); iAlgo != l1GtTechTriggers.end(); ++iAlgo) {
         const std::string& algoName(iAlgo->second.algoName());
         if (!(iAlgo->second.algoBitNumber() < int(L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers))) {
           LogError("l1Algo") << "L1 technical trigger '" << algoName << "' has bit number "
                              << iAlgo->second.algoBitNumber()
                              << " >= " << L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers << "\n"
                              << "Skipping";
           continue;
         }
         L1GtUtils::TriggerCategory category;
         int bit;
         if (!l1GtUtils.l1AlgoTechTrigBitNumber(algoName, category, bit)) {
           LogError("l1Algo") << "L1 technical trigger '" << algoName << "' not found in the L1 menu\n"
                              << "Skipping";
           continue;
         }
         if (category != L1GtUtils::TechnicalTrigger) {
           LogError("l1Algo") << "L1 technical trigger '" << algoName
                              << "' does not have category 'TechnicalTrigger' from 'L1GtUtils'\n"
                              << "Skipping";
           continue;
         }
         bool decisionBeforeMask;
         bool decisionAfterMask;
         int prescale;
         int mask;
         int error(l1GtUtils.l1Results(iEvent, algoName, decisionBeforeMask, decisionAfterMask, prescale, mask));
         if (error) {
           LogError("l1Algo") << "L1 technical trigger '" << algoName << "' decision has error code " << error
                              << " from 'L1GtUtils'\n"
                              << "Skipping";
           continue;
         }
         TriggerAlgorithm triggerAlgo(algoName,
                                      iAlgo->second.algoAlias(),
                                      category == L1GtUtils::TechnicalTrigger,
                                      (unsigned)bit,
                                      (unsigned)prescale,
                                      (bool)mask,
                                      decisionBeforeMask,
                                      decisionAfterMask);
         triggerAlgo.setLogicalExpression(iAlgo->second.algoLogicalExpression());
         triggerAlgos->push_back(triggerAlgo);
       }
     }
  
     // Put L1 algorithms and conditions to event
     iEvent.put(std::move(triggerAlgos));
     iEvent.put(std::move(triggerConditions));
   }
  
   edm::ProcessConfiguration config;
   iEvent.processHistory().getConfigurationForProcess(nameProcess_, config);
  
   const edm::TriggerNames& names = iEvent.triggerNames(*handleTriggerResults);
   for (pat::TriggerObjectStandAlone& obj : *triggerObjectsStandAlone) {
     obj.setPSetID(config.parameterSetID());
     if (packPathNames_)
       obj.packPathNames(names);
     if (packLabels_)
       obj.packFilterLabels(iEvent, *handleTriggerResults);
   }
  
   // Put (finally) stand-alone trigger objects to event
   iEvent.put(std::move(triggerObjectsStandAlone));
  
   firstInRun_ = false;
 }

Member Data Documentation

◆ addL1Algos_

bool pat::PATTriggerProducer::addL1Algos_

private

Definition at line 88 of file PATTriggerProducer.cc.

Referenced by produce().

◆ addPathModuleLabels_

bool pat::PATTriggerProducer::addPathModuleLabels_

private

Definition at line 131 of file PATTriggerProducer.cc.

Referenced by produce().

◆ autoProcessName_

bool pat::PATTriggerProducer::autoProcessName_

private

Definition at line 83 of file PATTriggerProducer.cc.

Referenced by beginRun().

◆ autoProcessNameL1ExtraCenJet_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraCenJet_

private

Definition at line 110 of file PATTriggerProducer.cc.

Referenced by beginRun().

◆ autoProcessNameL1ExtraETM_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraETM_

private

Definition at line 113 of file PATTriggerProducer.cc.

Referenced by beginRun().

◆ autoProcessNameL1ExtraForJet_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraForJet_

private

Definition at line 111 of file PATTriggerProducer.cc.

Referenced by beginRun().

◆ autoProcessNameL1ExtraHTM_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraHTM_

private

Definition at line 114 of file PATTriggerProducer.cc.

Referenced by beginRun().

◆ autoProcessNameL1ExtraIsoEG_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraIsoEG_

private

Definition at line 109 of file PATTriggerProducer.cc.

Referenced by beginRun().

◆ autoProcessNameL1ExtraMu_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraMu_

private

Definition at line 107 of file PATTriggerProducer.cc.

Referenced by beginRun().

◆ autoProcessNameL1ExtraNoIsoEG_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraNoIsoEG_

private

Definition at line 108 of file PATTriggerProducer.cc.

Referenced by beginRun().

◆ autoProcessNameL1ExtraTauJet_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraTauJet_

private

Definition at line 112 of file PATTriggerProducer.cc.

Referenced by beginRun().

◆ exludeCollections_

std::vector<std::string> pat::PATTriggerProducer::exludeCollections_

private

Definition at line 132 of file PATTriggerProducer.cc.

Referenced by produce().

◆ firstInRun_

bool pat::PATTriggerProducer::firstInRun_

private

Definition at line 85 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ handleL1GtTriggerMenuToken_

const edm::ESGetToken<L1GtTriggerMenu, L1GtTriggerMenuRcd> pat::PATTriggerProducer::handleL1GtTriggerMenuToken_

private

Definition at line 136 of file PATTriggerProducer.cc.

Referenced by produce().

◆ hltConfigInit_

bool pat::PATTriggerProducer::hltConfigInit_

private

Definition at line 119 of file PATTriggerProducer.cc.

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

◆ hltPrescaleLabel_

std::string pat::PATTriggerProducer::hltPrescaleLabel_

private

Definition at line 124 of file PATTriggerProducer.cc.

Referenced by produce().

◆ hltPrescaleProvider_

HLTPrescaleProvider pat::PATTriggerProducer::hltPrescaleProvider_

private

Definition at line 118 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ hltPrescaleTableEventGetter_

edm::GetterOfProducts<trigger::HLTPrescaleTable> pat::PATTriggerProducer::hltPrescaleTableEventGetter_

private

Definition at line 128 of file PATTriggerProducer.cc.

◆ hltPrescaleTableLumi_

trigger::HLTPrescaleTable pat::PATTriggerProducer::hltPrescaleTableLumi_

private

Definition at line 130 of file PATTriggerProducer.cc.

Referenced by beginLuminosityBlock(), and produce().

◆ hltPrescaleTableLumiGetter_

edm::GetterOfProducts<trigger::HLTPrescaleTable> pat::PATTriggerProducer::hltPrescaleTableLumiGetter_

private

Definition at line 127 of file PATTriggerProducer.cc.

◆ hltPrescaleTableRun_

trigger::HLTPrescaleTable pat::PATTriggerProducer::hltPrescaleTableRun_

private

Definition at line 129 of file PATTriggerProducer.cc.

Referenced by beginLuminosityBlock(), and beginRun().

◆ hltPrescaleTableRunGetter_

edm::GetterOfProducts<trigger::HLTPrescaleTable> pat::PATTriggerProducer::hltPrescaleTableRunGetter_

private

Definition at line 126 of file PATTriggerProducer.cc.

◆ l1ExtraCenJetGetter_

edm::GetterOfProducts<l1extra::L1JetParticleCollection> pat::PATTriggerProducer::l1ExtraCenJetGetter_

private

Definition at line 98 of file PATTriggerProducer.cc.

◆ l1ExtraETMGetter_

edm::GetterOfProducts<l1extra::L1EtMissParticleCollection> pat::PATTriggerProducer::l1ExtraETMGetter_

private

Definition at line 104 of file PATTriggerProducer.cc.

◆ l1ExtraForJetGetter_

edm::GetterOfProducts<l1extra::L1JetParticleCollection> pat::PATTriggerProducer::l1ExtraForJetGetter_

private

Definition at line 100 of file PATTriggerProducer.cc.

◆ l1ExtraHTMGetter_

edm::GetterOfProducts<l1extra::L1EtMissParticleCollection> pat::PATTriggerProducer::l1ExtraHTMGetter_

private

Definition at line 106 of file PATTriggerProducer.cc.

◆ l1ExtraIsoEGGetter_

edm::GetterOfProducts<l1extra::L1EmParticleCollection> pat::PATTriggerProducer::l1ExtraIsoEGGetter_

private

Definition at line 96 of file PATTriggerProducer.cc.

◆ l1ExtraMuGetter_

edm::GetterOfProducts<l1extra::L1MuonParticleCollection> pat::PATTriggerProducer::l1ExtraMuGetter_

private

Definition at line 92 of file PATTriggerProducer.cc.

◆ l1ExtraNoIsoEGGetter_

edm::GetterOfProducts<l1extra::L1EmParticleCollection> pat::PATTriggerProducer::l1ExtraNoIsoEGGetter_

private

Definition at line 94 of file PATTriggerProducer.cc.

◆ l1ExtraTauJetGetter_

edm::GetterOfProducts<l1extra::L1JetParticleCollection> pat::PATTriggerProducer::l1ExtraTauJetGetter_

private

Definition at line 102 of file PATTriggerProducer.cc.

◆ l1GlobalTriggerObjectMapsToken_

edm::EDGetTokenT<L1GlobalTriggerObjectMaps> pat::PATTriggerProducer::l1GlobalTriggerObjectMapsToken_

private

Definition at line 90 of file PATTriggerProducer.cc.

Referenced by produce().

◆ l1PSet_

edm::ParameterSet* pat::PATTriggerProducer::l1PSet_

private

Definition at line 87 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ labelHltPrescaleTable_

std::string pat::PATTriggerProducer::labelHltPrescaleTable_

private

Definition at line 125 of file PATTriggerProducer.cc.

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

◆ mainBxOnly_

bool pat::PATTriggerProducer::mainBxOnly_

private

Definition at line 115 of file PATTriggerProducer.cc.

Referenced by produce().

◆ moduleLabelToPathAndFlags_

ModuleLabelToPathAndFlags pat::PATTriggerProducer::moduleLabelToPathAndFlags_

private

Definition at line 164 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ nameProcess_

std::string pat::PATTriggerProducer::nameProcess_

private

Definition at line 82 of file PATTriggerProducer.cc.

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

◆ onlyStandAlone_

bool pat::PATTriggerProducer::onlyStandAlone_

private

Definition at line 84 of file PATTriggerProducer.cc.

Referenced by produce().

◆ packLabels_

bool pat::PATTriggerProducer::packLabels_

private

Definition at line 134 of file PATTriggerProducer.cc.

Referenced by produce().

◆ packPathNames_

bool pat::PATTriggerProducer::packPathNames_

private

Definition at line 133 of file PATTriggerProducer.cc.

Referenced by produce().

◆ packPrescales_

bool pat::PATTriggerProducer::packPrescales_

private

Definition at line 135 of file PATTriggerProducer.cc.

Referenced by produce().

◆ saveL1Refs_

bool pat::PATTriggerProducer::saveL1Refs_

private

Definition at line 116 of file PATTriggerProducer.cc.

Referenced by produce().

◆ tagL1ExtraCenJet_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraCenJet_

private

Definition at line 97 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ tagL1ExtraETM_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraETM_

private

Definition at line 103 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ tagL1ExtraForJet_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraForJet_

private

Definition at line 99 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ tagL1ExtraHTM_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraHTM_

private

Definition at line 105 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ tagL1ExtraIsoEG_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraIsoEG_

private

Definition at line 95 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ tagL1ExtraMu_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraMu_

private

Definition at line 91 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ tagL1ExtraNoIsoEG_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraNoIsoEG_

private

Definition at line 93 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ tagL1ExtraTauJet_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraTauJet_

private

Definition at line 101 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ tagL1GlobalTriggerObjectMaps_

edm::InputTag pat::PATTriggerProducer::tagL1GlobalTriggerObjectMaps_

private

Definition at line 89 of file PATTriggerProducer.cc.

Referenced by produce().

◆ tagTriggerEvent_

edm::InputTag pat::PATTriggerProducer::tagTriggerEvent_

private

Definition at line 122 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ tagTriggerResults_

edm::InputTag pat::PATTriggerProducer::tagTriggerResults_

private

Definition at line 120 of file PATTriggerProducer.cc.

Referenced by beginRun(), and produce().

◆ triggerEventGetter_

edm::GetterOfProducts<trigger::TriggerEvent> pat::PATTriggerProducer::triggerEventGetter_

private

Definition at line 123 of file PATTriggerProducer.cc.

◆ triggerResultsGetter_

edm::GetterOfProducts<edm::TriggerResults> pat::PATTriggerProducer::triggerResultsGetter_

private

Definition at line 121 of file PATTriggerProducer.cc.

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PATTriggerProducer()

◆ ~PATTriggerProducer()

Member Function Documentation

◆ beginLuminosityBlock()

◆ beginRun()

◆ produce()

Member Data Documentation

◆ addL1Algos_

◆ addPathModuleLabels_

◆ autoProcessName_

◆ autoProcessNameL1ExtraCenJet_

◆ autoProcessNameL1ExtraETM_

◆ autoProcessNameL1ExtraForJet_

◆ autoProcessNameL1ExtraHTM_

◆ autoProcessNameL1ExtraIsoEG_

◆ autoProcessNameL1ExtraMu_

◆ autoProcessNameL1ExtraNoIsoEG_

◆ autoProcessNameL1ExtraTauJet_

◆ exludeCollections_

◆ firstInRun_

◆ handleL1GtTriggerMenuToken_

◆ hltConfigInit_

◆ hltPrescaleLabel_

◆ hltPrescaleProvider_

◆ hltPrescaleTableEventGetter_

◆ hltPrescaleTableLumi_

◆ hltPrescaleTableLumiGetter_

◆ hltPrescaleTableRun_

◆ hltPrescaleTableRunGetter_

◆ l1ExtraCenJetGetter_

◆ l1ExtraETMGetter_

◆ l1ExtraForJetGetter_

◆ l1ExtraHTMGetter_

◆ l1ExtraIsoEGGetter_

◆ l1ExtraMuGetter_

◆ l1ExtraNoIsoEGGetter_

◆ l1ExtraTauJetGetter_

◆ l1GlobalTriggerObjectMapsToken_

◆ l1PSet_

◆ labelHltPrescaleTable_

◆ mainBxOnly_

◆ moduleLabelToPathAndFlags_

◆ nameProcess_

◆ onlyStandAlone_

◆ packLabels_

◆ packPathNames_

◆ packPrescales_

◆ saveL1Refs_

◆ tagL1ExtraCenJet_

◆ tagL1ExtraETM_

◆ tagL1ExtraForJet_

◆ tagL1ExtraHTM_

◆ tagL1ExtraIsoEG_

◆ tagL1ExtraMu_

◆ tagL1ExtraNoIsoEG_

◆ tagL1ExtraTauJet_

◆ tagL1GlobalTriggerObjectMaps_

◆ tagTriggerEvent_

◆ tagTriggerResults_

◆ triggerEventGetter_

◆ triggerResultsGetter_