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

#include "PhysicsTools/PatAlgos/plugins/PATTriggerProducer.h"

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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_

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<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	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 56 of file PATTriggerProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 43 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) {
   // 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>();
 }

pat::PATTriggerProducer::~PATTriggerProducer ( )

inlineoverride

Definition at line 59 of file PATTriggerProducer.h.

References beginLuminosityBlock(), beginRun(), iEvent, and produce().

59 {};

Member Function Documentation

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

overrideprivate

Definition at line 347 of file PATTriggerProducer.cc.

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

Referenced by ~PATTriggerProducer().

                                                                                                                {
   // 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());
       }
     }
   }
 }

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

overrideprivate

Definition at line 255 of file PATTriggerProducer.cc.

Referenced by ~PATTriggerProducer().

                                                                            {
   // 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());
       }
     }
   }
 }

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

overrideprivate

Definition at line 369 of file PATTriggerProducer.cc.

Referenced by ~PATTriggerProducer().

                                                                         {
   // 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);
         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;
           }
         }
         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
         const unsigned sizeModulesPath(hltConfig.size(indexPath));
         assert(indexLastFilterPathModules < sizeModulesPath);
         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.reset(new PackedTriggerPrescales(handleTriggerResults));
       packedPrescalesL1min.reset(new PackedTriggerPrescales(handleTriggerResults));
       packedPrescalesL1max.reset(new 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();
       ESHandle<L1GtTriggerMenu> handleL1GtTriggerMenu;
       iSetup.get<L1GtTriggerMenuRcd>().get(handleL1GtTriggerMenu);
       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;
 }