CMS 3D CMS Logo
List of all members | Classes | Public Member Functions | Private Member Functions | Private Attributes
pat::PATTriggerProducer Class Reference

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

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

Inheritance diagram for pat::PATTriggerProducer:
edm::stream::EDProducer<>

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 hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () 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

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::PATTriggerProducer ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 45 of file PATTriggerProducer.cc.

46  : nameProcess_(iConfig.getParameter<std::string>("processName")),
47  autoProcessName_(nameProcess_ == "*"),
48  onlyStandAlone_(iConfig.getParameter<bool>("onlyStandAlone")),
49  firstInRun_(true),
50  // L1 configuration parameters
51  addL1Algos_(false),
52  tagL1GlobalTriggerObjectMaps_("l1L1GtObjectMap"),
53  tagL1ExtraMu_(),
54  tagL1ExtraNoIsoEG_(),
55  tagL1ExtraIsoEG_(),
56  tagL1ExtraCenJet_(),
57  tagL1ExtraForJet_(),
58  tagL1ExtraTauJet_(),
59  tagL1ExtraETM_(),
60  tagL1ExtraHTM_(),
61  autoProcessNameL1ExtraMu_(false),
62  autoProcessNameL1ExtraNoIsoEG_(false),
63  autoProcessNameL1ExtraIsoEG_(false),
64  autoProcessNameL1ExtraCenJet_(false),
65  autoProcessNameL1ExtraForJet_(false),
66  autoProcessNameL1ExtraTauJet_(false),
67  autoProcessNameL1ExtraETM_(false),
68  autoProcessNameL1ExtraHTM_(false),
69  mainBxOnly_(true),
70  saveL1Refs_(false),
71  hltPrescaleProvider_(iConfig, consumesCollector(), *this),
72  hltConfigInit_(false),
73  // HLT configuration parameters
74  tagTriggerResults_("TriggerResults"),
75  tagTriggerEvent_("hltTriggerSummaryAOD"),
76  hltPrescaleLabel_(),
77  labelHltPrescaleTable_(),
78  hltPrescaleTableRun_(),
79  hltPrescaleTableLumi_(),
80  addPathModuleLabels_(false),
81  packPathNames_(iConfig.existsAs<bool>("packTriggerPathNames") ? iConfig.getParameter<bool>("packTriggerPathNames")
82  : false),
83  packLabels_(iConfig.existsAs<bool>("packTriggerLabels") ? iConfig.getParameter<bool>("packTriggerLabels") : true),
84  packPrescales_(iConfig.existsAs<bool>("packTriggerPrescales") ? iConfig.getParameter<bool>("packTriggerPrescales")
85  : true) {
86  // L1 configuration parameters
87  if (iConfig.exists("addL1Algos"))
88  addL1Algos_ = iConfig.getParameter<bool>("addL1Algos");
89  if (iConfig.exists("l1GlobalTriggerObjectMaps"))
90  tagL1GlobalTriggerObjectMaps_ = iConfig.getParameter<InputTag>("l1GlobalTriggerObjectMaps");
91  l1GlobalTriggerObjectMapsToken_ = mayConsume<L1GlobalTriggerObjectMaps>(tagL1GlobalTriggerObjectMaps_);
92  if (iConfig.exists("l1ExtraMu")) {
93  tagL1ExtraMu_ = iConfig.getParameter<InputTag>("l1ExtraMu");
94  if (tagL1ExtraMu_.process() == "*") {
95  if (autoProcessName_)
96  autoProcessNameL1ExtraMu_ = true;
97  else
98  tagL1ExtraMu_ = InputTag(tagL1ExtraMu_.label(), tagL1ExtraMu_.instance(), nameProcess_);
99  }
100  l1ExtraMuGetter_ = GetterOfProducts<l1extra::L1MuonParticleCollection>(
101  InputTagMatch(InputTag(tagL1ExtraMu_.label(), tagL1ExtraMu_.instance())), this);
102  }
103  if (iConfig.exists("l1ExtraNoIsoEG")) {
104  tagL1ExtraNoIsoEG_ = iConfig.getParameter<InputTag>("l1ExtraNoIsoEG");
105  if (tagL1ExtraNoIsoEG_.process() == "*") {
106  if (autoProcessName_)
107  autoProcessNameL1ExtraNoIsoEG_ = true;
108  else
109  tagL1ExtraNoIsoEG_ = InputTag(tagL1ExtraNoIsoEG_.label(), tagL1ExtraNoIsoEG_.instance(), nameProcess_);
110  }
111  l1ExtraNoIsoEGGetter_ = GetterOfProducts<l1extra::L1EmParticleCollection>(
112  InputTagMatch(InputTag(tagL1ExtraNoIsoEG_.label(), tagL1ExtraNoIsoEG_.instance())), this);
113  }
114  if (iConfig.exists("l1ExtraIsoEG")) {
115  tagL1ExtraIsoEG_ = iConfig.getParameter<InputTag>("l1ExtraIsoEG");
116  if (tagL1ExtraIsoEG_.process() == "*") {
117  if (autoProcessName_)
118  autoProcessNameL1ExtraIsoEG_ = true;
119  else
120  tagL1ExtraIsoEG_ = InputTag(tagL1ExtraIsoEG_.label(), tagL1ExtraIsoEG_.instance(), nameProcess_);
121  }
122  l1ExtraIsoEGGetter_ = GetterOfProducts<l1extra::L1EmParticleCollection>(
123  InputTagMatch(InputTag(tagL1ExtraIsoEG_.label(), tagL1ExtraIsoEG_.instance())), this);
124  }
125  if (iConfig.exists("l1ExtraCenJet")) {
126  tagL1ExtraCenJet_ = iConfig.getParameter<InputTag>("l1ExtraCenJet");
127  if (tagL1ExtraCenJet_.process() == "*") {
128  if (autoProcessName_)
129  autoProcessNameL1ExtraCenJet_ = true;
130  else
131  tagL1ExtraCenJet_ = InputTag(tagL1ExtraCenJet_.label(), tagL1ExtraCenJet_.instance(), nameProcess_);
132  }
133  l1ExtraCenJetGetter_ = GetterOfProducts<l1extra::L1JetParticleCollection>(
134  InputTagMatch(InputTag(tagL1ExtraCenJet_.label(), tagL1ExtraCenJet_.instance())), this);
135  }
136  if (iConfig.exists("l1ExtraForJet")) {
137  tagL1ExtraForJet_ = iConfig.getParameter<InputTag>("l1ExtraForJet");
138  if (tagL1ExtraForJet_.process() == "*") {
139  if (autoProcessName_)
140  autoProcessNameL1ExtraForJet_ = true;
141  else
142  tagL1ExtraForJet_ = InputTag(tagL1ExtraForJet_.label(), tagL1ExtraForJet_.instance(), nameProcess_);
143  }
144  l1ExtraForJetGetter_ = GetterOfProducts<l1extra::L1JetParticleCollection>(
145  InputTagMatch(InputTag(tagL1ExtraForJet_.label(), tagL1ExtraForJet_.instance())), this);
146  }
147  if (iConfig.exists("l1ExtraTauJet")) {
148  tagL1ExtraTauJet_ = iConfig.getParameter<InputTag>("l1ExtraTauJet");
149  if (tagL1ExtraTauJet_.process() == "*") {
150  if (autoProcessName_)
151  autoProcessNameL1ExtraTauJet_ = true;
152  else
153  tagL1ExtraTauJet_ = InputTag(tagL1ExtraTauJet_.label(), tagL1ExtraTauJet_.instance(), nameProcess_);
154  }
155  l1ExtraTauJetGetter_ = GetterOfProducts<l1extra::L1JetParticleCollection>(
156  InputTagMatch(InputTag(tagL1ExtraTauJet_.label(), tagL1ExtraTauJet_.instance())), this);
157  }
158  if (iConfig.exists("l1ExtraETM")) {
159  tagL1ExtraETM_ = iConfig.getParameter<InputTag>("l1ExtraETM");
160  if (tagL1ExtraETM_.process() == "*") {
161  if (autoProcessName_)
162  autoProcessNameL1ExtraETM_ = true;
163  else
164  tagL1ExtraETM_ = InputTag(tagL1ExtraETM_.label(), tagL1ExtraETM_.instance(), nameProcess_);
165  }
166  l1ExtraETMGetter_ = GetterOfProducts<l1extra::L1EtMissParticleCollection>(
167  InputTagMatch(InputTag(tagL1ExtraETM_.label(), tagL1ExtraETM_.instance())), this);
168  }
169  if (iConfig.exists("l1ExtraHTM")) {
170  tagL1ExtraHTM_ = iConfig.getParameter<InputTag>("l1ExtraHTM");
171  if (tagL1ExtraHTM_.process() == "*") {
172  if (autoProcessName_)
173  autoProcessNameL1ExtraHTM_ = true;
174  else
175  tagL1ExtraHTM_ = InputTag(tagL1ExtraHTM_.label(), tagL1ExtraHTM_.instance(), nameProcess_);
176  }
177  l1ExtraHTMGetter_ = GetterOfProducts<l1extra::L1EtMissParticleCollection>(
178  InputTagMatch(InputTag(tagL1ExtraHTM_.label(), tagL1ExtraHTM_.instance())), this);
179  }
180  if (iConfig.exists("mainBxOnly"))
181  mainBxOnly_ = iConfig.getParameter<bool>("mainBxOnly");
182  if (iConfig.exists("saveL1Refs"))
183  saveL1Refs_ = iConfig.getParameter<bool>("saveL1Refs");
184 
185  // HLT configuration parameters
186  if (iConfig.exists("triggerResults"))
187  tagTriggerResults_ = iConfig.getParameter<InputTag>("triggerResults");
188  triggerResultsGetter_ =
189  GetterOfProducts<TriggerResults>(InputTagMatch(InputTag(tagTriggerResults_.label(),
190  tagTriggerResults_.instance(),
191  autoProcessName_ ? std::string("") : nameProcess_)),
192  this);
193  if (iConfig.exists("triggerEvent"))
194  tagTriggerEvent_ = iConfig.getParameter<InputTag>("triggerEvent");
195  triggerEventGetter_ = GetterOfProducts<trigger::TriggerEvent>(
196  InputTagMatch(InputTag(tagTriggerEvent_.label(), tagTriggerEvent_.instance())), this);
197  if (iConfig.exists("hltPrescaleLabel"))
198  hltPrescaleLabel_ = iConfig.getParameter<std::string>("hltPrescaleLabel");
199  if (iConfig.exists("hltPrescaleTable")) {
200  labelHltPrescaleTable_ = iConfig.getParameter<std::string>("hltPrescaleTable");
201  hltPrescaleTableRunGetter_ = GetterOfProducts<trigger::HLTPrescaleTable>(
202  InputTagMatch(InputTag(labelHltPrescaleTable_, "Run")), this, InRun);
203  hltPrescaleTableLumiGetter_ = GetterOfProducts<trigger::HLTPrescaleTable>(
204  InputTagMatch(InputTag(labelHltPrescaleTable_, "Lumi")), this, InLumi);
205  hltPrescaleTableEventGetter_ =
206  GetterOfProducts<trigger::HLTPrescaleTable>(InputTagMatch(InputTag(labelHltPrescaleTable_, "Event")), this);
207  }
208  if (iConfig.exists("addPathModuleLabels"))
209  addPathModuleLabels_ = iConfig.getParameter<bool>("addPathModuleLabels");
210  exludeCollections_.clear();
211  if (iConfig.exists("exludeCollections"))
212  exludeCollections_ = iConfig.getParameter<std::vector<std::string> >("exludeCollections");
213 
214  callWhenNewProductsRegistered([this, &iConfig](BranchDescription const& bd) {
215  if (iConfig.exists("l1ExtraMu"))
216  l1ExtraMuGetter_(bd);
217  if (iConfig.exists("l1ExtraNoIsoEG"))
218  l1ExtraNoIsoEGGetter_(bd);
219  if (iConfig.exists("l1ExtraIsoEG"))
220  l1ExtraIsoEGGetter_(bd);
221  if (iConfig.exists("l1ExtraCenJet"))
222  l1ExtraCenJetGetter_(bd);
223  if (iConfig.exists("l1ExtraForJet"))
224  l1ExtraForJetGetter_(bd);
225  if (iConfig.exists("l1ExtraTauJet"))
226  l1ExtraTauJetGetter_(bd);
227  if (iConfig.exists("l1ExtraETM"))
228  l1ExtraETMGetter_(bd);
229  if (iConfig.exists("l1ExtraHTM"))
230  l1ExtraHTMGetter_(bd);
231  if (not(this->autoProcessName_ and bd.processName() == this->moduleDescription().processName())) {
232  triggerResultsGetter_(bd);
233  }
234  triggerEventGetter_(bd);
235  if (iConfig.exists("hltPrescaleTable")) {
236  hltPrescaleTableRunGetter_(bd);
237  hltPrescaleTableLumiGetter_(bd);
238  hltPrescaleTableEventGetter_(bd);
239  }
240  });
241 
242  if (!onlyStandAlone_) {
243  produces<TriggerAlgorithmCollection>();
244  produces<TriggerConditionCollection>();
245  produces<TriggerPathCollection>();
246  produces<TriggerFilterCollection>();
247  produces<TriggerObjectCollection>();
248  }
249  if (packPrescales_) {
250  produces<PackedTriggerPrescales>();
251  produces<PackedTriggerPrescales>("l1max");
252  produces<PackedTriggerPrescales>("l1min");
253  }
254  produces<TriggerObjectStandAloneCollection>();
255 }

References addL1Algos_, addPathModuleLabels_, autoProcessName_, autoProcessNameL1ExtraCenJet_, autoProcessNameL1ExtraETM_, autoProcessNameL1ExtraForJet_, autoProcessNameL1ExtraHTM_, autoProcessNameL1ExtraIsoEG_, autoProcessNameL1ExtraMu_, autoProcessNameL1ExtraNoIsoEG_, autoProcessNameL1ExtraTauJet_, edm::ParameterSet::exists(), exludeCollections_, edm::ParameterSet::getParameter(), hltPrescaleLabel_, hltPrescaleTableEventGetter_, hltPrescaleTableLumiGetter_, hltPrescaleTableRunGetter_, edm::InLumi, HLT_FULL_cff::InputTag, edm::InRun, edm::InputTag::instance(), l1ExtraCenJetGetter_, l1ExtraETMGetter_, l1ExtraForJetGetter_, l1ExtraHTMGetter_, l1ExtraIsoEGGetter_, l1ExtraMuGetter_, l1ExtraNoIsoEGGetter_, l1ExtraTauJetGetter_, l1GlobalTriggerObjectMapsToken_, edm::InputTag::label(), labelHltPrescaleTable_, mainBxOnly_, nameProcess_, onlyStandAlone_, packPrescales_, edm::InputTag::process(), saveL1Refs_, AlCaHLTBitMon_QueryRunRegistry::string, tagL1ExtraCenJet_, tagL1ExtraETM_, tagL1ExtraForJet_, tagL1ExtraHTM_, tagL1ExtraIsoEG_, tagL1ExtraMu_, tagL1ExtraNoIsoEG_, tagL1ExtraTauJet_, tagL1GlobalTriggerObjectMaps_, tagTriggerEvent_, tagTriggerResults_, triggerEventGetter_, and triggerResultsGetter_.

◆ ~PATTriggerProducer()

pat::PATTriggerProducer::~PATTriggerProducer ( )
inlineoverride

Definition at line 59 of file PATTriggerProducer.h.

59 {};

Member Function Documentation

◆ beginLuminosityBlock()

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

Definition at line 349 of file PATTriggerProducer.cc.

349  {
350  // Terminate, if auto process name determination failed
351  if (nameProcess_ == "*")
352  return;
353 
354  // Extract pre-scales
355  if (hltConfigInit_) {
356  // Start from run
357  hltPrescaleTableLumi_ = trigger::HLTPrescaleTable(
358  hltPrescaleTableRun_.set(), hltPrescaleTableRun_.labels(), hltPrescaleTableRun_.table());
359  // Try lumi product, if configured and available
360  if (!labelHltPrescaleTable_.empty()) {
361  Handle<trigger::HLTPrescaleTable> handleHltPrescaleTable;
362  iLuminosityBlock.getByLabel(InputTag(labelHltPrescaleTable_, "Lumi", nameProcess_), handleHltPrescaleTable);
363  if (handleHltPrescaleTable.isValid()) {
364  hltPrescaleTableLumi_ = trigger::HLTPrescaleTable(
365  handleHltPrescaleTable->set(), handleHltPrescaleTable->labels(), handleHltPrescaleTable->table());
366  }
367  }
368  }
369 }

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 257 of file PATTriggerProducer.cc.

257  {
258  // Initialize
259  firstInRun_ = true;
260  l1PSet_ = nullptr;
261  hltConfigInit_ = false;
262 
263  // Initialize process name
264  if (autoProcessName_) {
265  // reset
266  nameProcess_ = "*";
267  // determine process name from last run TriggerSummaryProducerAOD module in process history of input
268  const ProcessHistory& processHistory(iRun.processHistory());
269  ProcessConfiguration processConfiguration;
270  ParameterSet processPSet;
271  // unbroken loop, which relies on time ordering (accepts the last found entry)
272  for (ProcessHistory::const_iterator iHist = processHistory.begin(); iHist != processHistory.end(); ++iHist) {
273  if (processHistory.getConfigurationForProcess(iHist->processName(), processConfiguration) &&
274  pset::Registry::instance()->getMapped(processConfiguration.parameterSetID(), processPSet) &&
275  processPSet.exists(tagTriggerEvent_.label())) {
276  nameProcess_ = iHist->processName();
277  LogDebug("autoProcessName") << "HLT process name '" << nameProcess_ << "' discovered";
278  }
279  }
280  // terminate, if nothing is found
281  if (nameProcess_ == "*") {
282  LogError("autoProcessName") << "trigger::TriggerEvent product with label '" << tagTriggerEvent_.label()
283  << "' not produced according to process history of input data\n"
284  << "No trigger information produced";
285  return;
286  }
287  LogInfo("autoProcessName") << "HLT process name' " << nameProcess_ << "' used for PAT trigger information";
288  }
289  // adapt configuration of used input tags
290  if (tagTriggerResults_.process().empty() || tagTriggerResults_.process() == "*") {
291  tagTriggerResults_ = InputTag(tagTriggerResults_.label(), tagTriggerResults_.instance(), nameProcess_);
292  } else if (tagTriggerEvent_.process() != nameProcess_) {
293  LogWarning("inputTags") << "TriggerResults process name '" << tagTriggerResults_.process()
294  << "' differs from HLT process name '" << nameProcess_ << "'";
295  }
296  if (tagTriggerEvent_.process().empty() || tagTriggerEvent_.process() == "*") {
297  tagTriggerEvent_ = InputTag(tagTriggerEvent_.label(), tagTriggerEvent_.instance(), nameProcess_);
298  } else if (tagTriggerEvent_.process() != nameProcess_) {
299  LogWarning("inputTags") << "TriggerEvent process name '" << tagTriggerEvent_.process()
300  << "' differs from HLT process name '" << nameProcess_ << "'";
301  }
302  if (autoProcessNameL1ExtraMu_)
303  tagL1ExtraMu_ = InputTag(tagL1ExtraMu_.label(), tagL1ExtraMu_.instance(), nameProcess_);
304  if (autoProcessNameL1ExtraNoIsoEG_)
305  tagL1ExtraNoIsoEG_ = InputTag(tagL1ExtraNoIsoEG_.label(), tagL1ExtraNoIsoEG_.instance(), nameProcess_);
306  if (autoProcessNameL1ExtraIsoEG_)
307  tagL1ExtraIsoEG_ = InputTag(tagL1ExtraIsoEG_.label(), tagL1ExtraIsoEG_.instance(), nameProcess_);
308  if (autoProcessNameL1ExtraCenJet_)
309  tagL1ExtraCenJet_ = InputTag(tagL1ExtraCenJet_.label(), tagL1ExtraCenJet_.instance(), nameProcess_);
310  if (autoProcessNameL1ExtraForJet_)
311  tagL1ExtraForJet_ = InputTag(tagL1ExtraForJet_.label(), tagL1ExtraForJet_.instance(), nameProcess_);
312  if (autoProcessNameL1ExtraTauJet_)
313  tagL1ExtraTauJet_ = InputTag(tagL1ExtraTauJet_.label(), tagL1ExtraTauJet_.instance(), nameProcess_);
314  if (autoProcessNameL1ExtraETM_)
315  tagL1ExtraETM_ = InputTag(tagL1ExtraETM_.label(), tagL1ExtraETM_.instance(), nameProcess_);
316  if (autoProcessNameL1ExtraHTM_)
317  tagL1ExtraHTM_ = InputTag(tagL1ExtraHTM_.label(), tagL1ExtraHTM_.instance(), nameProcess_);
318 
319  // Initialize HLTConfigProvider
320  HLTConfigProvider const& hltConfig = hltPrescaleProvider_.hltConfigProvider();
321  bool changed(true);
322  if (!hltPrescaleProvider_.init(iRun, iSetup, nameProcess_, changed)) {
323  LogError("hltConfig") << "HLT config extraction error with process name '" << nameProcess_ << "'";
324  } else if (hltConfig.size() <= 0) {
325  LogError("hltConfig") << "HLT config size error";
326  } else
327  hltConfigInit_ = true;
328 
329  // Update mapping from filter names to path names
330  if (hltConfigInit_ && changed)
331  moduleLabelToPathAndFlags_.init(hltConfig);
332 
333  // Extract pre-scales
334  if (hltConfigInit_) {
335  // Start empty
336  hltPrescaleTableRun_ = trigger::HLTPrescaleTable();
337  // Try run product, if configured
338  if (!labelHltPrescaleTable_.empty()) {
339  Handle<trigger::HLTPrescaleTable> handleHltPrescaleTable;
340  iRun.getByLabel(InputTag(labelHltPrescaleTable_, "Run", nameProcess_), handleHltPrescaleTable);
341  if (handleHltPrescaleTable.isValid()) {
342  hltPrescaleTableRun_ = trigger::HLTPrescaleTable(
343  handleHltPrescaleTable->set(), handleHltPrescaleTable->labels(), handleHltPrescaleTable->table());
344  }
345  }
346  }
347 }

References autoProcessName_, autoProcessNameL1ExtraCenJet_, autoProcessNameL1ExtraETM_, autoProcessNameL1ExtraForJet_, autoProcessNameL1ExtraHTM_, autoProcessNameL1ExtraIsoEG_, autoProcessNameL1ExtraMu_, autoProcessNameL1ExtraNoIsoEG_, autoProcessNameL1ExtraTauJet_, edm::ParameterSet::exists(), firstInRun_, edm::Run::getByLabel(), HltComparatorCreateWorkflow::hltConfig, hltConfigInit_, HLTPrescaleProvider::hltConfigProvider(), hltPrescaleProvider_, hltPrescaleTableRun_, HLTPrescaleProvider::init(), pat::PATTriggerProducer::ModuleLabelToPathAndFlags::init(), HLT_FULL_cff::InputTag, edm::InputTag::instance(), instance, edm::HandleBase::isValid(), l1PSet_, edm::InputTag::label(), labelHltPrescaleTable_, trigger::HLTPrescaleTable::labels(), LogDebug, moduleLabelToPathAndFlags_, nameProcess_, edm::InputTag::process(), edm::Run::processHistory(), trigger::HLTPrescaleTable::set(), trigger::HLTPrescaleTable::table(), tagL1ExtraCenJet_, tagL1ExtraETM_, tagL1ExtraForJet_, tagL1ExtraHTM_, tagL1ExtraIsoEG_, tagL1ExtraMu_, tagL1ExtraNoIsoEG_, tagL1ExtraTauJet_, tagTriggerEvent_, and tagTriggerResults_.

◆ produce()

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

Definition at line 371 of file PATTriggerProducer.cc.

371  {
372  // Terminate, if auto process name determination failed
373  if (nameProcess_ == "*")
374  return;
375 
376  auto triggerObjects = std::make_unique<TriggerObjectCollection>();
377  auto triggerObjectsStandAlone = std::make_unique<TriggerObjectStandAloneCollection>();
378  std::unique_ptr<PackedTriggerPrescales> packedPrescales, packedPrescalesL1min, packedPrescalesL1max;
379 
380  // HLT
381  HLTConfigProvider const& hltConfig = hltPrescaleProvider_.hltConfigProvider();
382 
383  // Get and check HLT event data
384  Handle<trigger::TriggerEvent> handleTriggerEvent;
385  iEvent.getByLabel(tagTriggerEvent_, handleTriggerEvent);
386  Handle<TriggerResults> handleTriggerResults;
387  iEvent.getByLabel(tagTriggerResults_, handleTriggerResults);
388  bool goodHlt(hltConfigInit_);
389  if (goodHlt) {
390  if (!handleTriggerResults.isValid()) {
391  LogError("triggerResultsValid") << "TriggerResults product with InputTag '" << tagTriggerResults_.encode()
392  << "' not in event\n"
393  << "No HLT information produced";
394  goodHlt = false;
395  } else if (!handleTriggerEvent.isValid()) {
396  LogError("triggerEventValid") << "trigger::TriggerEvent product with InputTag '" << tagTriggerEvent_.encode()
397  << "' not in event\n"
398  << "No HLT information produced";
399  goodHlt = false;
400  }
401  }
402 
403  // Produce HLT paths and determine status of modules
404 
405  if (goodHlt) {
406  // Extract pre-scales
407  // Start from lumi
408  trigger::HLTPrescaleTable hltPrescaleTable(
409  hltPrescaleTableLumi_.set(), hltPrescaleTableLumi_.labels(), hltPrescaleTableLumi_.table());
410  // Try event product, if configured and available
411  if (!labelHltPrescaleTable_.empty()) {
412  Handle<trigger::HLTPrescaleTable> handleHltPrescaleTable;
413  iEvent.getByLabel(InputTag(labelHltPrescaleTable_, "Event", nameProcess_), handleHltPrescaleTable);
414  if (handleHltPrescaleTable.isValid()) {
415  hltPrescaleTable = trigger::HLTPrescaleTable(
416  handleHltPrescaleTable->set(), handleHltPrescaleTable->labels(), handleHltPrescaleTable->table());
417  }
418  }
419  // Try event setup, if no product
420  if (hltPrescaleTable.size() == 0) {
421  if (!labelHltPrescaleTable_.empty()) {
422  LogWarning("hltPrescaleInputTag") << "HLTPrescaleTable product with label '" << labelHltPrescaleTable_
423  << "' not found in process" << nameProcess_ << "\n"
424  << "Using default from event setup";
425  }
426  if (hltConfig.prescaleSize() > 0) {
427  if (hltPrescaleProvider_.prescaleSet(iEvent, iSetup) != -1) {
428  hltPrescaleTable = trigger::HLTPrescaleTable(
429  hltPrescaleProvider_.prescaleSet(iEvent, iSetup), hltConfig.prescaleLabels(), hltConfig.prescaleTable());
430  LogDebug("hltPrescaleTable") << "HLT prescale table found in event setup";
431  } else {
432  LogWarning("hltPrescaleSet") << "HLTPrescaleTable from event setup has error";
433  }
434  }
435  }
436  unsigned set(hltPrescaleTable.set());
437  if (hltPrescaleTable.size() > 0) {
438  if (!hltPrescaleLabel_.empty()) {
439  bool foundPrescaleLabel(false);
440  for (unsigned iLabel = 0; iLabel < hltPrescaleTable.labels().size(); ++iLabel) {
441  if (hltPrescaleTable.labels().at(iLabel) == hltPrescaleLabel_) {
442  set = iLabel;
443  foundPrescaleLabel = true;
444  break;
445  }
446  }
447  if (!foundPrescaleLabel) {
448  LogWarning("hltPrescaleLabel") << "HLT prescale label '" << hltPrescaleLabel_ << "' not in prescale table\n"
449  << "Using default";
450  }
451  }
452  } else if (iEvent.isRealData()) {
453  if ((labelHltPrescaleTable_.empty() && firstInRun_) || !labelHltPrescaleTable_.empty()) {
454  LogError("hltPrescaleTable") << "No HLT prescale table found\n"
455  << "Using default empty table with all prescales 1";
456  }
457  }
458 
459  const unsigned sizePaths(hltConfig.size());
460  const unsigned sizeFilters(handleTriggerEvent->sizeFilters());
461  const unsigned sizeObjects(handleTriggerEvent->sizeObjects());
462 
463  std::map<std::string, int> moduleStates;
464 
465  if (!onlyStandAlone_) {
466  auto triggerPaths = std::make_unique<TriggerPathCollection>();
467  triggerPaths->reserve(sizePaths);
468  const std::vector<std::string>& pathNames = hltConfig.triggerNames();
469  for (size_t indexPath = 0; indexPath < sizePaths; ++indexPath) {
470  const std::string& namePath = pathNames.at(indexPath);
471  unsigned indexLastFilterPathModules(handleTriggerResults->index(indexPath) + 1);
472  while (indexLastFilterPathModules > 0) {
473  --indexLastFilterPathModules;
474  const std::string& labelLastFilterPathModules(hltConfig.moduleLabel(indexPath, indexLastFilterPathModules));
475  unsigned indexLastFilterFilters =
476  handleTriggerEvent->filterIndex(InputTag(labelLastFilterPathModules, "", nameProcess_));
477  if (indexLastFilterFilters < sizeFilters) {
478  if (hltConfig.moduleType(labelLastFilterPathModules) == "HLTBool")
479  continue;
480  break;
481  }
482  }
483  TriggerPath triggerPath(namePath,
484  indexPath,
485  hltConfig.prescaleValue(set, namePath),
486  handleTriggerResults->wasrun(indexPath),
487  handleTriggerResults->accept(indexPath),
488  handleTriggerResults->error(indexPath),
489  indexLastFilterPathModules,
490  hltConfig.saveTagsModules(namePath).size());
491  // add module names to path and states' map
492  const unsigned sizeModulesPath(hltConfig.size(indexPath));
493  assert(indexLastFilterPathModules < sizeModulesPath);
494  std::map<unsigned, std::string> indicesModules;
495  for (size_t iM = 0; iM < sizeModulesPath; ++iM) {
496  const std::string& nameModule(hltConfig.moduleLabel(indexPath, iM));
497  if (addPathModuleLabels_) {
498  triggerPath.addModule(nameModule);
499  }
500  const unsigned indexFilter(handleTriggerEvent->filterIndex(InputTag(nameModule, "", nameProcess_)));
501  if (indexFilter < sizeFilters) {
502  triggerPath.addFilterIndex(indexFilter);
503  }
504  const unsigned slotModule(hltConfig.moduleIndex(indexPath, nameModule));
505  indicesModules.insert(std::pair<unsigned, std::string>(slotModule, nameModule));
506  }
507  // add L1 seeds
508  const L1SeedCollection& l1Seeds(hltConfig.hltL1GTSeeds(namePath));
509  for (L1SeedCollection::const_iterator iSeed = l1Seeds.begin(); iSeed != l1Seeds.end(); ++iSeed) {
510  triggerPath.addL1Seed(*iSeed);
511  }
512  // store path
513  triggerPaths->push_back(triggerPath);
514  // cache module states to be used for the filters
515  for (std::map<unsigned, std::string>::const_iterator iM = indicesModules.begin(); iM != indicesModules.end();
516  ++iM) {
517  if (iM->first < indexLastFilterPathModules) {
518  moduleStates[iM->second] = 1;
519  } else if (iM->first == indexLastFilterPathModules) {
520  moduleStates[iM->second] = handleTriggerResults->accept(indexPath);
521  } else if (moduleStates.find(iM->second) == moduleStates.end()) {
522  moduleStates[iM->second] = -1;
523  }
524  }
525  }
526  // Put HLT paths to event
527  iEvent.put(std::move(triggerPaths));
528  }
529 
530  // Store used trigger objects and their types for HLT filters
531  // (only active filter(s) available from trigger::TriggerEvent)
532 
533  std::multimap<trigger::size_type, int> objectTypes;
534  std::multimap<trigger::size_type, std::string> filterLabels;
535 
536  for (size_t iF = 0; iF < sizeFilters; ++iF) {
537  const std::string nameFilter(handleTriggerEvent->filterLabel(iF));
538  const trigger::Keys& keys = handleTriggerEvent->filterKeys(iF);
539  const trigger::Vids& types = handleTriggerEvent->filterIds(iF);
540  assert(types.size() == keys.size());
541  for (size_t iK = 0; iK < keys.size(); ++iK) {
542  filterLabels.insert(std::pair<trigger::size_type, std::string>(keys[iK], nameFilter));
543  objectTypes.insert(std::pair<trigger::size_type, int>(keys[iK], types[iK]));
544  }
545  }
546 
547  // HLT objects
548 
549  triggerObjects->reserve(onlyStandAlone_ ? 0 : sizeObjects);
550  triggerObjectsStandAlone->reserve(sizeObjects);
551 
552  const trigger::Keys& collectionKeys(handleTriggerEvent->collectionKeys());
553  std::map<trigger::size_type, trigger::size_type> newObjectKeys;
554  for (size_t iO = 0, iC = 0, nC = handleTriggerEvent->sizeCollections(); iO < sizeObjects && iC < nC; ++iO) {
555  const trigger::TriggerObject tobj = handleTriggerEvent->getObjects().at(iO);
556  TriggerObject triggerObject(reco::Particle::PolarLorentzVector(tobj.pt(), tobj.eta(), tobj.phi(), tobj.mass()),
557  tobj.id());
558  // set collection
559  while (iO >= collectionKeys[iC])
560  ++iC; // relies on well ordering of trigger objects with respect to the collections
561  triggerObject.setCollection(handleTriggerEvent->collectionTagEncoded(iC));
562  // set filter ID
563  typedef std::multimap<trigger::size_type, int>::const_iterator it_type;
564  for (std::pair<it_type, it_type> trange = objectTypes.equal_range(iO); trange.first != trange.second;
565  ++trange.first) {
566  triggerObject.addTriggerObjectType(trange.first->second);
567  }
568 
569  // stand-alone trigger object
570  TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
571  // check for excluded collections
572  bool excluded(false);
573  for (size_t iE = 0; iE < exludeCollections_.size(); ++iE) {
574  if (triggerObjectStandAlone.hasCollection(exludeCollections_.at(iE))) {
575  if (!onlyStandAlone_)
576  newObjectKeys[iO] = trigger::size_type(sizeObjects);
577  excluded = true;
578  break;
579  }
580  }
581  if (excluded)
582  continue;
583  typedef std::multimap<trigger::size_type, std::string>::const_iterator it_fl;
584  for (std::pair<it_fl, it_fl> frange = filterLabels.equal_range(iO); frange.first != frange.second;
585  ++frange.first) {
586  triggerObjectStandAlone.addFilterLabel(frange.first->second);
587  const std::vector<ModuleLabelToPathAndFlags::PathAndFlags>& paths =
588  moduleLabelToPathAndFlags_[frange.first->second];
589  for (std::vector<ModuleLabelToPathAndFlags::PathAndFlags>::const_iterator iP = paths.begin(); iP != paths.end();
590  ++iP) {
591  bool pathFired = handleTriggerResults->wasrun(iP->pathIndex) && handleTriggerResults->accept(iP->pathIndex);
592  triggerObjectStandAlone.addPathName(iP->pathName, pathFired && iP->lastFilter, pathFired && iP->l3Filter);
593  }
594  }
595 
596  triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
597  if (!onlyStandAlone_) {
598  triggerObjects->push_back(triggerObject);
599  newObjectKeys[iO] = trigger::size_type(triggerObjects->size() - 1);
600  }
601  }
602 
603  // Re-iterate HLT filters and finally produce them in order to account for optionally skipped objects
604  if (!onlyStandAlone_) {
605  auto triggerFilters = std::make_unique<TriggerFilterCollection>();
606  triggerFilters->reserve(sizeFilters);
607  for (size_t iF = 0; iF < sizeFilters; ++iF) {
608  const std::string nameFilter(handleTriggerEvent->filterTag(iF).label());
609  const trigger::Keys& keys = handleTriggerEvent->filterKeys(iF); // not cached
610  const trigger::Vids& types = handleTriggerEvent->filterIds(iF); // not cached
611  TriggerFilter triggerFilter(nameFilter);
612  // set filter type
613  const std::string typeFilter(hltConfig.moduleType(nameFilter));
614  triggerFilter.setType(typeFilter);
615  triggerFilter.setSaveTags(hltConfig.saveTags(nameFilter));
616  // set keys and trigger object types of used objects
617  for (size_t iK = 0; iK < keys.size(); ++iK) { // identical to types.size()
618  // check, if current object is excluded
619  if (newObjectKeys.find(keys.at(iK)) != newObjectKeys.end()) {
620  if (newObjectKeys[keys.at(iK)] == sizeObjects)
621  continue;
622  triggerFilter.addObjectKey(newObjectKeys[keys.at(iK)]);
623  triggerFilter.addTriggerObjectType(types.at(iK));
624  } else {
625  LogWarning("triggerObjectKey") << "TriggerFilter '" << nameFilter
626  << "' requests non-existing TriggerObject key " << keys.at(iK) << "\n"
627  << "Skipping object assignment";
628  }
629  }
630  // set status from path info
631  std::map<std::string, int>::iterator iS(moduleStates.find(nameFilter));
632  if (iS != moduleStates.end()) {
633  if (!triggerFilter.setStatus(iS->second)) {
634  triggerFilter.setStatus(-1); // FIXME different code for "unvalid status determined" needed?
635  }
636  } else {
637  triggerFilter.setStatus(-1); // FIXME different code for "unknown" needed?
638  }
639  // store filter
640  triggerFilters->push_back(triggerFilter);
641  }
642  // put HLT filters to event
643  iEvent.put(std::move(triggerFilters));
644  }
645 
646  if (packPrescales_) {
647  packedPrescales = std::make_unique<PackedTriggerPrescales>(handleTriggerResults);
648  packedPrescalesL1min = std::make_unique<PackedTriggerPrescales>(handleTriggerResults);
649  packedPrescalesL1max = std::make_unique<PackedTriggerPrescales>(handleTriggerResults);
650  const edm::TriggerNames& names = iEvent.triggerNames(*handleTriggerResults);
651  //std::cout << "Run " << iEvent.id().run() << ", LS " << iEvent.id().luminosityBlock() << ": pset " << set << std::endl;
652  for (unsigned int i = 0, n = names.size(); i < n; ++i) {
653  auto pvdet = hltPrescaleProvider_.prescaleValuesInDetail(iEvent, iSetup, names.triggerName(i));
654  //int hltprescale = hltConfig_.prescaleValue(set, names.triggerName(i));
655  if (pvdet.first.empty()) {
656  packedPrescalesL1max->addPrescaledTrigger(i, 1);
657  packedPrescalesL1min->addPrescaledTrigger(i, 1);
658  } else {
659  int pmin = -1, pmax = -1;
660  for (const auto& p : pvdet.first) {
661  pmax = std::max(pmax, p.second);
662  if (p.second > 0 && (pmin == -1 || pmin > p.second))
663  pmin = p.second;
664  }
665  packedPrescalesL1max->addPrescaledTrigger(i, pmax);
666  packedPrescalesL1min->addPrescaledTrigger(i, pmin);
667  //std::cout << "\tTrigger " << names.triggerName(i) << ", L1 ps " << pmin << "-" << pmax << ", HLT ps " << hltprescale << std::endl;
668  }
669  packedPrescales->addPrescaledTrigger(i, pvdet.second);
670  //assert( hltprescale == pvdet.second );
671  }
672  iEvent.put(std::move(packedPrescales));
673  iEvent.put(std::move(packedPrescalesL1max), "l1max");
674  iEvent.put(std::move(packedPrescalesL1min), "l1min");
675  }
676 
677  } // if ( goodHlt )
678 
679  // L1 objects
680  // (needs to be done after HLT objects, since their x-links with filters rely on their collection keys)
681 
682  // map for assignments of objects to conditions
683  std::map<L1GtObject, std::vector<unsigned> > l1ObjectTypeMap;
684  if (!tagL1ExtraMu_.label().empty()) {
685  Handle<l1extra::L1MuonParticleCollection> handleL1ExtraMu;
686  iEvent.getByLabel(tagL1ExtraMu_, handleL1ExtraMu);
687  if (handleL1ExtraMu.isValid()) {
688  std::vector<unsigned> muKeys;
689  for (size_t l1Mu = 0; l1Mu < handleL1ExtraMu->size(); ++l1Mu) {
690  if (mainBxOnly_ && handleL1ExtraMu->at(l1Mu).bx() != 0)
691  continue;
692  TriggerObject triggerObject;
693  if (saveL1Refs_) {
694  const reco::CandidateBaseRef leafCandRef(l1extra::L1MuonParticleRef(handleL1ExtraMu, l1Mu));
695  triggerObject = TriggerObject(leafCandRef);
696  } else {
697  const reco::LeafCandidate leafCandidate(*(handleL1ExtraMu->at(l1Mu).reco::LeafCandidate::clone()));
698  triggerObject = TriggerObject(leafCandidate);
699  }
700  triggerObject.setCollection(tagL1ExtraMu_);
701  triggerObject.addTriggerObjectType(trigger::TriggerL1Mu);
702  if (!onlyStandAlone_)
703  triggerObjects->push_back(triggerObject);
704  TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
705  triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
706  if (handleL1ExtraMu->at(l1Mu).bx() == 0)
707  muKeys.push_back(triggerObjectsStandAlone->size() - 1);
708  }
709  l1ObjectTypeMap.insert(std::make_pair(Mu, muKeys));
710  } else
711  LogError("l1ExtraValid") << "l1extra::L1MuonParticleCollection product with InputTag '" << tagL1ExtraMu_.encode()
712  << "' not in event";
713  }
714  if (!tagL1ExtraNoIsoEG_.label().empty()) {
715  Handle<l1extra::L1EmParticleCollection> handleL1ExtraNoIsoEG;
716  iEvent.getByLabel(tagL1ExtraNoIsoEG_, handleL1ExtraNoIsoEG);
717  if (handleL1ExtraNoIsoEG.isValid()) {
718  std::vector<unsigned> noIsoEGKeys;
719  for (size_t l1NoIsoEG = 0; l1NoIsoEG < handleL1ExtraNoIsoEG->size(); ++l1NoIsoEG) {
720  if (mainBxOnly_ && handleL1ExtraNoIsoEG->at(l1NoIsoEG).bx() != 0)
721  continue;
722  TriggerObject triggerObject;
723  if (saveL1Refs_) {
724  const reco::CandidateBaseRef leafCandRef(l1extra::L1EmParticleRef(handleL1ExtraNoIsoEG, l1NoIsoEG));
725  triggerObject = TriggerObject(leafCandRef);
726  } else {
727  const reco::LeafCandidate leafCandidate(*(handleL1ExtraNoIsoEG->at(l1NoIsoEG).reco::LeafCandidate::clone()));
728  triggerObject = TriggerObject(leafCandidate);
729  }
730  triggerObject.setCollection(tagL1ExtraNoIsoEG_);
731  triggerObject.addTriggerObjectType(trigger::TriggerL1NoIsoEG);
732  if (!onlyStandAlone_)
733  triggerObjects->push_back(triggerObject);
734  TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
735  triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
736  if (handleL1ExtraNoIsoEG->at(l1NoIsoEG).bx() == 0)
737  noIsoEGKeys.push_back(triggerObjectsStandAlone->size() - 1);
738  }
739  l1ObjectTypeMap.insert(std::make_pair(NoIsoEG, noIsoEGKeys));
740  } else
741  LogError("l1ExtraValid") << "l1extra::L1EmParticleCollection product with InputTag '"
742  << tagL1ExtraNoIsoEG_.encode() << "' not in event";
743  }
744  if (!tagL1ExtraIsoEG_.label().empty()) {
745  Handle<l1extra::L1EmParticleCollection> handleL1ExtraIsoEG;
746  iEvent.getByLabel(tagL1ExtraIsoEG_, handleL1ExtraIsoEG);
747  if (handleL1ExtraIsoEG.isValid()) {
748  std::vector<unsigned> isoEGKeys;
749  for (size_t l1IsoEG = 0; l1IsoEG < handleL1ExtraIsoEG->size(); ++l1IsoEG) {
750  if (mainBxOnly_ && handleL1ExtraIsoEG->at(l1IsoEG).bx() != 0)
751  continue;
752  TriggerObject triggerObject;
753  if (saveL1Refs_) {
754  const reco::CandidateBaseRef leafCandRef(l1extra::L1EmParticleRef(handleL1ExtraIsoEG, l1IsoEG));
755  triggerObject = TriggerObject(leafCandRef);
756  } else {
757  const reco::LeafCandidate leafCandidate(*(handleL1ExtraIsoEG->at(l1IsoEG).reco::LeafCandidate::clone()));
758  triggerObject = TriggerObject(leafCandidate);
759  }
760  triggerObject.setCollection(tagL1ExtraIsoEG_);
761  triggerObject.addTriggerObjectType(trigger::TriggerL1IsoEG);
762  if (!onlyStandAlone_)
763  triggerObjects->push_back(triggerObject);
764  TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
765  triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
766  if (handleL1ExtraIsoEG->at(l1IsoEG).bx() == 0)
767  isoEGKeys.push_back(triggerObjectsStandAlone->size() - 1);
768  }
769  l1ObjectTypeMap.insert(std::make_pair(IsoEG, isoEGKeys));
770  } else
771  LogError("l1ExtraValid") << "l1extra::L1EmParticleCollection product with InputTag '" << tagL1ExtraIsoEG_.encode()
772  << "' not in event";
773  }
774  if (!tagL1ExtraCenJet_.label().empty()) {
775  Handle<l1extra::L1JetParticleCollection> handleL1ExtraCenJet;
776  iEvent.getByLabel(tagL1ExtraCenJet_, handleL1ExtraCenJet);
777  if (handleL1ExtraCenJet.isValid()) {
778  std::vector<unsigned> cenJetKeys;
779  for (size_t l1CenJet = 0; l1CenJet < handleL1ExtraCenJet->size(); ++l1CenJet) {
780  if (mainBxOnly_ && handleL1ExtraCenJet->at(l1CenJet).bx() != 0)
781  continue;
782  TriggerObject triggerObject;
783  if (saveL1Refs_) {
784  const reco::CandidateBaseRef leafCandRef(l1extra::L1JetParticleRef(handleL1ExtraCenJet, l1CenJet));
785  triggerObject = TriggerObject(leafCandRef);
786  } else {
787  const reco::LeafCandidate leafCandidate(*(handleL1ExtraCenJet->at(l1CenJet).reco::LeafCandidate::clone()));
788  triggerObject = TriggerObject(leafCandidate);
789  }
790  triggerObject.setCollection(tagL1ExtraCenJet_);
791  triggerObject.addTriggerObjectType(trigger::TriggerL1CenJet);
792  if (!onlyStandAlone_)
793  triggerObjects->push_back(triggerObject);
794  TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
795  triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
796  if (handleL1ExtraCenJet->at(l1CenJet).bx() == 0)
797  cenJetKeys.push_back(triggerObjectsStandAlone->size() - 1);
798  }
799  l1ObjectTypeMap.insert(std::make_pair(CenJet, cenJetKeys));
800  } else
801  LogError("l1ExtraValid") << "l1extra::L1JetParticleCollection product with InputTag '"
802  << tagL1ExtraCenJet_.encode() << "' not in event";
803  }
804  if (!tagL1ExtraForJet_.label().empty()) {
805  Handle<l1extra::L1JetParticleCollection> handleL1ExtraForJet;
806  iEvent.getByLabel(tagL1ExtraForJet_, handleL1ExtraForJet);
807  if (handleL1ExtraForJet.isValid()) {
808  std::vector<unsigned> forJetKeys;
809  for (size_t l1ForJet = 0; l1ForJet < handleL1ExtraForJet->size(); ++l1ForJet) {
810  if (mainBxOnly_ && handleL1ExtraForJet->at(l1ForJet).bx() != 0)
811  continue;
812  TriggerObject triggerObject;
813  if (saveL1Refs_) {
814  const reco::CandidateBaseRef leafCandRef(l1extra::L1JetParticleRef(handleL1ExtraForJet, l1ForJet));
815  triggerObject = TriggerObject(leafCandRef);
816  } else {
817  const reco::LeafCandidate leafCandidate(*(handleL1ExtraForJet->at(l1ForJet).reco::LeafCandidate::clone()));
818  triggerObject = TriggerObject(leafCandidate);
819  }
820  triggerObject.setCollection(tagL1ExtraForJet_);
821  triggerObject.addTriggerObjectType(trigger::TriggerL1ForJet);
822  if (!onlyStandAlone_)
823  triggerObjects->push_back(triggerObject);
824  TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
825  triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
826  if (handleL1ExtraForJet->at(l1ForJet).bx() == 0)
827  forJetKeys.push_back(triggerObjectsStandAlone->size() - 1);
828  }
829  l1ObjectTypeMap.insert(std::make_pair(ForJet, forJetKeys));
830  } else
831  LogError("l1ExtraValid") << "l1extra::L1JetParticleCollection product with InputTag '"
832  << tagL1ExtraForJet_.encode() << "' not in event";
833  }
834  if (!tagL1ExtraTauJet_.label().empty()) {
835  Handle<l1extra::L1JetParticleCollection> handleL1ExtraTauJet;
836  iEvent.getByLabel(tagL1ExtraTauJet_, handleL1ExtraTauJet);
837  if (handleL1ExtraTauJet.isValid()) {
838  std::vector<unsigned> tauJetKeys;
839  for (size_t l1TauJet = 0; l1TauJet < handleL1ExtraTauJet->size(); ++l1TauJet) {
840  if (mainBxOnly_ && handleL1ExtraTauJet->at(l1TauJet).bx() != 0)
841  continue;
842  TriggerObject triggerObject;
843  if (saveL1Refs_) {
844  const reco::CandidateBaseRef leafCandRef(l1extra::L1JetParticleRef(handleL1ExtraTauJet, l1TauJet));
845  triggerObject = TriggerObject(leafCandRef);
846  } else {
847  const reco::LeafCandidate leafCandidate(*(handleL1ExtraTauJet->at(l1TauJet).reco::LeafCandidate::clone()));
848  triggerObject = TriggerObject(leafCandidate);
849  }
850  triggerObject.setCollection(tagL1ExtraTauJet_);
851  triggerObject.addTriggerObjectType(trigger::TriggerL1TauJet);
852  if (!onlyStandAlone_)
853  triggerObjects->push_back(triggerObject);
854  TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
855  triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
856  if (handleL1ExtraTauJet->at(l1TauJet).bx() == 0)
857  tauJetKeys.push_back(triggerObjectsStandAlone->size() - 1);
858  }
859  l1ObjectTypeMap.insert(std::make_pair(TauJet, tauJetKeys));
860  } else
861  LogError("l1ExtraValid") << "l1extra::L1JetParticleCollection product with InputTag '"
862  << tagL1ExtraTauJet_.encode() << "' not in event";
863  }
864  if (!tagL1ExtraETM_.label().empty()) {
865  Handle<l1extra::L1EtMissParticleCollection> handleL1ExtraETM;
866  iEvent.getByLabel(tagL1ExtraETM_, handleL1ExtraETM);
867  if (handleL1ExtraETM.isValid()) {
868  std::vector<unsigned> etmKeys;
869  for (size_t l1ETM = 0; l1ETM < handleL1ExtraETM->size(); ++l1ETM) {
870  if (mainBxOnly_ && handleL1ExtraETM->at(l1ETM).bx() != 0)
871  continue;
872  TriggerObject triggerObject;
873  if (saveL1Refs_) {
874  const reco::CandidateBaseRef leafCandRef(l1extra::L1EtMissParticleRef(handleL1ExtraETM, l1ETM));
875  triggerObject = TriggerObject(leafCandRef);
876  } else {
877  const reco::LeafCandidate leafCandidate(*(handleL1ExtraETM->at(l1ETM).reco::LeafCandidate::clone()));
878  triggerObject = TriggerObject(leafCandidate);
879  }
880  triggerObject.setCollection(tagL1ExtraETM_);
881  triggerObject.addTriggerObjectType(trigger::TriggerL1ETM);
882  if (!onlyStandAlone_)
883  triggerObjects->push_back(triggerObject);
884  TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
885  triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
886  if (handleL1ExtraETM->at(l1ETM).bx() == 0)
887  etmKeys.push_back(triggerObjectsStandAlone->size() - 1);
888  }
889  l1ObjectTypeMap.insert(std::make_pair(ETM, etmKeys));
890  } else
891  LogError("l1ExtraValid") << "l1extra::L1EtMissParticleCollection product with InputTag '"
892  << tagL1ExtraETM_.encode() << "' not in event";
893  }
894  if (!tagL1ExtraHTM_.label().empty()) {
895  Handle<l1extra::L1EtMissParticleCollection> handleL1ExtraHTM;
896  iEvent.getByLabel(tagL1ExtraHTM_, handleL1ExtraHTM);
897  if (handleL1ExtraHTM.isValid()) {
898  std::vector<unsigned> htmKeys;
899  for (size_t l1HTM = 0; l1HTM < handleL1ExtraHTM->size(); ++l1HTM) {
900  if (mainBxOnly_ && handleL1ExtraHTM->at(l1HTM).bx() != 0)
901  continue;
902  TriggerObject triggerObject;
903  if (saveL1Refs_) {
904  const reco::CandidateBaseRef leafCandRef(l1extra::L1EtMissParticleRef(handleL1ExtraHTM, l1HTM));
905  triggerObject = TriggerObject(leafCandRef);
906  } else {
907  const reco::LeafCandidate leafCandidate(*(handleL1ExtraHTM->at(l1HTM).reco::LeafCandidate::clone()));
908  triggerObject = TriggerObject(leafCandidate);
909  }
910  triggerObject.setCollection(tagL1ExtraHTM_);
911  triggerObject.addTriggerObjectType(trigger::TriggerL1HTM);
912  if (!onlyStandAlone_)
913  triggerObjects->push_back(triggerObject);
914  TriggerObjectStandAlone triggerObjectStandAlone(triggerObject);
915  triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
916  if (handleL1ExtraHTM->at(l1HTM).bx() == 0)
917  htmKeys.push_back(triggerObjectsStandAlone->size() - 1);
918  }
919  l1ObjectTypeMap.insert(std::make_pair(HTM, htmKeys));
920  } else
921  LogError("l1ExtraValid") << "l1extra::L1EtMissParticleCollection product with InputTag '"
922  << tagL1ExtraHTM_.encode() << "' not in event";
923  }
924 
925  // Put trigger objects to event
926  if (!onlyStandAlone_)
927  iEvent.put(std::move(triggerObjects));
928 
929  // L1 algorithms
930  if (!onlyStandAlone_) {
931  auto triggerAlgos = std::make_unique<TriggerAlgorithmCollection>();
932  auto triggerConditions = std::make_unique<TriggerConditionCollection>();
933  if (addL1Algos_) {
934  // create trigger object types transalation map (yes, it's ugly!)
935  std::map<L1GtObject, trigger::TriggerObjectType> mapObjectTypes;
936  mapObjectTypes.insert(std::make_pair(Mu, trigger::TriggerL1Mu));
937  mapObjectTypes.insert(std::make_pair(NoIsoEG, trigger::TriggerL1NoIsoEG));
938  mapObjectTypes.insert(std::make_pair(IsoEG, trigger::TriggerL1IsoEG));
939  mapObjectTypes.insert(std::make_pair(CenJet, trigger::TriggerL1CenJet));
940  mapObjectTypes.insert(std::make_pair(ForJet, trigger::TriggerL1ForJet));
941  mapObjectTypes.insert(std::make_pair(TauJet, trigger::TriggerL1TauJet));
942  mapObjectTypes.insert(std::make_pair(ETM, trigger::TriggerL1ETM));
943  mapObjectTypes.insert(std::make_pair(HTM, trigger::TriggerL1HTM));
944  // get and cache L1 menu
945  L1GtUtils const& l1GtUtils = hltPrescaleProvider_.l1GtUtils();
946  ESHandle<L1GtTriggerMenu> handleL1GtTriggerMenu;
947  iSetup.get<L1GtTriggerMenuRcd>().get(handleL1GtTriggerMenu);
948  auto const& l1GtAlgorithms = handleL1GtTriggerMenu->gtAlgorithmMap();
949  auto const& l1GtTechTriggers = handleL1GtTriggerMenu->gtTechnicalTriggerMap();
950  auto const& l1GtConditionsVector = handleL1GtTriggerMenu->gtConditionMap();
951  // cache conditions in one single condition map
952  ConditionMap l1GtConditions;
953  for (size_t iCv = 0; iCv < l1GtConditionsVector.size(); ++iCv) {
954  l1GtConditions.insert(l1GtConditionsVector.at(iCv).begin(), l1GtConditionsVector.at(iCv).end());
955  }
956  triggerAlgos->reserve(l1GtAlgorithms.size() + l1GtTechTriggers.size());
957  Handle<L1GlobalTriggerObjectMaps> handleL1GlobalTriggerObjectMaps;
958  iEvent.getByToken(l1GlobalTriggerObjectMapsToken_, handleL1GlobalTriggerObjectMaps);
959  if (!handleL1GlobalTriggerObjectMaps.isValid()) {
960  LogError("l1ObjectMap") << "L1GlobalTriggerObjectMaps product with InputTag '"
961  << tagL1GlobalTriggerObjectMaps_.encode() << "' not in event\n"
962  << "No L1 objects and GTL results available for physics algorithms";
963  }
964  handleL1GlobalTriggerObjectMaps->consistencyCheck();
965  if (firstInRun_) {
966  l1PSet_ = (ParameterSet*)(pset::Registry::instance()->getMapped(
967  handleL1GlobalTriggerObjectMaps->namesParameterSetID()));
968  if (l1PSet_ == nullptr) {
969  LogError("l1ObjectMap") << "ParameterSet registry not available\n"
970  << "Skipping conditions for all L1 physics algorithm names in this run";
971  }
972  } else {
973  if (l1PSet_ == nullptr) {
974  LogInfo("l1ObjectMap") << "ParameterSet registry not available\n"
975  << "Skipping conditions for all L1 physics algorithm names in this event";
976  }
977  }
978  // physics algorithms
979  for (CItAlgo iAlgo = l1GtAlgorithms.begin(); iAlgo != l1GtAlgorithms.end(); ++iAlgo) {
980  const std::string& algoName(iAlgo->second.algoName());
981  if (!(iAlgo->second.algoBitNumber() < int(L1GlobalTriggerReadoutSetup::NumberPhysTriggers))) {
982  LogError("l1Algo") << "L1 physics algorithm '" << algoName << "' has bit number "
983  << iAlgo->second.algoBitNumber()
984  << " >= " << L1GlobalTriggerReadoutSetup::NumberPhysTriggers << "\n"
985  << "Skipping";
986  continue;
987  }
988  L1GtUtils::TriggerCategory category;
989  int bit;
990  if (!l1GtUtils.l1AlgoTechTrigBitNumber(algoName, category, bit)) {
991  LogError("l1Algo") << "L1 physics algorithm '" << algoName << "' not found in the L1 menu\n"
992  << "Skipping";
993  continue;
994  }
995  if (category != L1GtUtils::AlgorithmTrigger) {
996  LogError("l1Algo") << "L1 physics algorithm '" << algoName
997  << "' does not have category 'AlgorithmTrigger' from 'L1GtUtils'\n"
998  << "Skipping";
999  continue;
1000  }
1001  bool decisionBeforeMask;
1002  bool decisionAfterMask;
1003  int prescale;
1004  int mask;
1005  int error(l1GtUtils.l1Results(iEvent, algoName, decisionBeforeMask, decisionAfterMask, prescale, mask));
1006  if (error) {
1007  LogError("l1Algo") << "L1 physics algorithm '" << algoName << "' decision has error code " << error
1008  << " from 'L1GtUtils'\n"
1009  << "Skipping";
1010  continue;
1011  }
1012  TriggerAlgorithm triggerAlgo(algoName,
1013  iAlgo->second.algoAlias(),
1014  category == L1GtUtils::TechnicalTrigger,
1015  (unsigned)bit,
1016  (unsigned)prescale,
1017  (bool)mask,
1018  decisionBeforeMask,
1019  decisionAfterMask);
1020  triggerAlgo.setLogicalExpression(iAlgo->second.algoLogicalExpression());
1021  // GTL result and used conditions in physics algorithm
1022  if (!handleL1GlobalTriggerObjectMaps.isValid()) {
1023  triggerAlgos->push_back(triggerAlgo);
1024  continue; // LogWarning already earlier (before loop)
1025  }
1026  if (!handleL1GlobalTriggerObjectMaps->algorithmExists(bit)) {
1027  LogError("l1ObjectMap") << "L1 physics algorithm '" << algoName
1028  << "' is missing in L1GlobalTriggerObjectMaps\n"
1029  << "Skipping conditions and GTL result";
1030  triggerAlgos->push_back(triggerAlgo);
1031  continue;
1032  }
1033  bool algorithmResult = handleL1GlobalTriggerObjectMaps->algorithmResult(bit);
1034  // if ( ( algorithmResult != decisionBeforeMask ) && ( decisionBeforeMask == true || prescale == 1 ) ) {
1035  if ((algorithmResult != decisionBeforeMask) &&
1036  (decisionBeforeMask == true)) { // FIXME: understand the difference for un-prescaled algos 118, 119, 123
1037  LogInfo("l1ObjectMap") << "L1 physics algorithm '" << algoName << "' with different decisions in\n"
1038  << "L1GlobalTriggerObjectMaps (GTL result) : " << algorithmResult << "\n"
1039  << "L1GlobalTriggerReadoutRecord (decision before mask): " << decisionBeforeMask;
1040  }
1041  triggerAlgo.setGtlResult(algorithmResult);
1042  // conditions in algorithm
1043  L1GlobalTriggerObjectMaps::ConditionsInAlgorithm conditions =
1044  handleL1GlobalTriggerObjectMaps->getConditionsInAlgorithm(bit);
1045  if (l1PSet_ == nullptr) {
1046  triggerAlgos->push_back(triggerAlgo);
1047  continue;
1048  }
1049  if (!l1PSet_->exists(algoName)) {
1050  if (firstInRun_) {
1051  LogError("l1ObjectMap") << "L1 physics algorithm name '" << algoName
1052  << "' not available in ParameterSet registry\n"
1053  << "Skipping conditions for this algorithm in this run";
1054  } else {
1055  LogInfo("l1ObjectMap") << "L1 physics algorithm name '" << algoName
1056  << "' not available in ParameterSet registry\n"
1057  << "Skipping conditions for this algorithm in this event";
1058  }
1059  triggerAlgos->push_back(triggerAlgo);
1060  continue;
1061  }
1062  std::vector<std::string> conditionNames(l1PSet_->getParameter<std::vector<std::string> >(algoName));
1063 
1064  for (unsigned iT = 0; iT < conditionNames.size(); ++iT) {
1065  size_t key(triggerConditions->size());
1066  for (size_t iC = 0; iC < triggerConditions->size(); ++iC) {
1067  if (conditionNames.at(iT) == triggerConditions->at(iC).name()) {
1068  key = iC;
1069  break;
1070  }
1071  }
1072  if (key == triggerConditions->size()) {
1073  if (iT >= conditions.nConditions()) {
1074  LogError("l1CondMap") << "More condition names from ParameterSet registry than the "
1075  << conditions.nConditions() << " conditions in L1GlobalTriggerObjectMaps\n"
1076  << "Skipping condition " << conditionNames.at(iT) << " in algorithm " << algoName;
1077  break;
1078  }
1079  TriggerCondition triggerCond(conditionNames[iT], conditions.getConditionResult(iT));
1080  if (l1GtConditions.find(triggerCond.name()) != l1GtConditions.end()) {
1081  triggerCond.setCategory(l1GtConditions[triggerCond.name()]->condCategory());
1082  triggerCond.setType(l1GtConditions[triggerCond.name()]->condType());
1083  const std::vector<L1GtObject> l1ObjectTypes(l1GtConditions[triggerCond.name()]->objectType());
1084  for (size_t iType = 0; iType < l1ObjectTypes.size(); ++iType) {
1085  triggerCond.addTriggerObjectType(mapObjectTypes[l1ObjectTypes.at(iType)]);
1086  }
1087  // objects in condition
1088  L1GlobalTriggerObjectMaps::CombinationsInCondition combinations =
1089  handleL1GlobalTriggerObjectMaps->getCombinationsInCondition(bit, iT);
1090  for (size_t iVV = 0; iVV < combinations.nCombinations(); ++iVV) {
1091  for (size_t iV = 0; iV < combinations.nObjectsPerCombination(); ++iV) {
1092  unsigned objectIndex = combinations.getObjectIndex(iVV, iV);
1093  if (iV >= l1ObjectTypes.size()) {
1094  LogError("l1CondMap") << "Index " << iV << " in combinations vector overshoots size "
1095  << l1ObjectTypes.size() << " of types vector in conditions map\n"
1096  << "Skipping object key in condition " << triggerCond.name();
1097  } else if (l1ObjectTypeMap.find(l1ObjectTypes.at(iV)) != l1ObjectTypeMap.end()) {
1098  if (objectIndex >= l1ObjectTypeMap[l1ObjectTypes.at(iV)].size()) {
1099  LogError("l1CondMap")
1100  << "Index " << objectIndex << " in combination overshoots number "
1101  << l1ObjectTypeMap[l1ObjectTypes.at(iV)].size() << "of according trigger objects\n"
1102  << "Skipping object key in condition " << triggerCond.name();
1103  }
1104  const unsigned objectKey(l1ObjectTypeMap[l1ObjectTypes.at(iV)].at(objectIndex));
1105  triggerCond.addObjectKey(objectKey);
1106  // add current condition and algorithm also to the according stand-alone trigger object
1107  triggerObjectsStandAlone->at(objectKey).addAlgorithmName(
1108  triggerAlgo.name(), (triggerAlgo.decision() && triggerCond.wasAccept()));
1109  triggerObjectsStandAlone->at(objectKey).addConditionName(triggerCond.name());
1110  }
1111  }
1112  }
1113  } else {
1114  LogWarning("l1CondMap") << "L1 conditions '" << triggerCond.name() << "' not found in the L1 menu\n"
1115  << "Remains incomplete";
1116  }
1117  triggerConditions->push_back(triggerCond);
1118  }
1119  triggerAlgo.addConditionKey(key);
1120  }
1121  triggerAlgos->push_back(triggerAlgo);
1122  }
1123  // technical triggers
1124  for (CItAlgo iAlgo = l1GtTechTriggers.begin(); iAlgo != l1GtTechTriggers.end(); ++iAlgo) {
1125  const std::string& algoName(iAlgo->second.algoName());
1126  if (!(iAlgo->second.algoBitNumber() < int(L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers))) {
1127  LogError("l1Algo") << "L1 technical trigger '" << algoName << "' has bit number "
1128  << iAlgo->second.algoBitNumber()
1129  << " >= " << L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers << "\n"
1130  << "Skipping";
1131  continue;
1132  }
1133  L1GtUtils::TriggerCategory category;
1134  int bit;
1135  if (!l1GtUtils.l1AlgoTechTrigBitNumber(algoName, category, bit)) {
1136  LogError("l1Algo") << "L1 technical trigger '" << algoName << "' not found in the L1 menu\n"
1137  << "Skipping";
1138  continue;
1139  }
1140  if (category != L1GtUtils::TechnicalTrigger) {
1141  LogError("l1Algo") << "L1 technical trigger '" << algoName
1142  << "' does not have category 'TechnicalTrigger' from 'L1GtUtils'\n"
1143  << "Skipping";
1144  continue;
1145  }
1146  bool decisionBeforeMask;
1147  bool decisionAfterMask;
1148  int prescale;
1149  int mask;
1150  int error(l1GtUtils.l1Results(iEvent, algoName, decisionBeforeMask, decisionAfterMask, prescale, mask));
1151  if (error) {
1152  LogError("l1Algo") << "L1 technical trigger '" << algoName << "' decision has error code " << error
1153  << " from 'L1GtUtils'\n"
1154  << "Skipping";
1155  continue;
1156  }
1157  TriggerAlgorithm triggerAlgo(algoName,
1158  iAlgo->second.algoAlias(),
1159  category == L1GtUtils::TechnicalTrigger,
1160  (unsigned)bit,
1161  (unsigned)prescale,
1162  (bool)mask,
1163  decisionBeforeMask,
1164  decisionAfterMask);
1165  triggerAlgo.setLogicalExpression(iAlgo->second.algoLogicalExpression());
1166  triggerAlgos->push_back(triggerAlgo);
1167  }
1168  }
1169 
1170  // Put L1 algorithms and conditions to event
1171  iEvent.put(std::move(triggerAlgos));
1172  iEvent.put(std::move(triggerConditions));
1173  }
1174 
1175  edm::ProcessConfiguration config;
1176  iEvent.processHistory().getConfigurationForProcess(nameProcess_, config);
1177 
1178  const edm::TriggerNames& names = iEvent.triggerNames(*handleTriggerResults);
1179  for (pat::TriggerObjectStandAlone& obj : *triggerObjectsStandAlone) {
1180  obj.setPSetID(config.parameterSetID());
1181  if (packPathNames_)
1182  obj.packPathNames(names);
1183  if (packLabels_)
1184  obj.packFilterLabels(iEvent, *handleTriggerResults);
1185  }
1186 
1187  // Put (finally) stand-alone trigger objects to event
1188  iEvent.put(std::move(triggerObjectsStandAlone));
1189 
1190  firstInRun_ = false;
1191 }

References edm::HLTGlobalStatus::accept(), pat::TriggerAlgorithm::addConditionKey(), pat::TriggerObjectStandAlone::addFilterLabel(), addL1Algos_, addPathModuleLabels_, pat::TriggerObjectStandAlone::addPathName(), pat::TriggerObject::addTriggerObjectType(), HIPAlignmentAlgorithm_cfi::algoName, L1GlobalTriggerObjectMaps::algorithmExists(), L1GlobalTriggerObjectMaps::algorithmResult(), L1GtUtils::AlgorithmTrigger, cms::cuda::assert(), electrons_cff::bool, taus_updatedMVAIds_cff::category, CenJet, trigger::TriggerEvent::collectionKeys(), trigger::TriggerEvent::collectionTagEncoded(), submitPVValidationJobs::conditions, submitPVResolutionJobs::config, L1GlobalTriggerObjectMaps::consistencyCheck(), pat::TriggerAlgorithm::decision(), edm::InputTag::encode(), edm::HLTGlobalStatus::error(), relativeConstraints::error, trigger::TriggerObject::eta(), ETM, edm::ParameterSet::exists(), exludeCollections_, trigger::TriggerEvent::filterIds(), trigger::TriggerEvent::filterIndex(), trigger::TriggerEvent::filterKeys(), trigger::TriggerEvent::filterLabel(), patCandidatesForDimuonsSequences_cff::filterLabels, trigger::TriggerEvent::filterTag(), firstInRun_, ForJet, edm::EventSetup::get(), get, L1GlobalTriggerObjectMaps::getCombinationsInCondition(), L1GlobalTriggerObjectMaps::getConditionsInAlgorithm(), L1GlobalTriggerObjectMaps::CombinationsInCondition::getObjectIndex(), trigger::TriggerEvent::getObjects(), edm::ParameterSet::getParameter(), L1GtTriggerMenu::gtAlgorithmMap(), L1GtTriggerMenu::gtConditionMap(), L1GtTriggerMenu::gtTechnicalTriggerMap(), pat::TriggerObjectStandAlone::hasCollection(), HltComparatorCreateWorkflow::hltConfig, hltConfigInit_, HLTPrescaleProvider::hltConfigProvider(), hltPrescaleLabel_, hltPrescaleProvider_, hltPrescaleTableLumi_, HTM, mps_fire::i, trigger::TriggerObject::id(), iEvent, edm::HLTGlobalStatus::index(), HLT_FULL_cff::InputTag, instance, createfilelist::int, IsoEG, edm::HandleBase::isValid(), crabWrapper::key, relativeConstraints::keys, L1GtUtils::l1AlgoTechTrigBitNumber(), l1GlobalTriggerObjectMapsToken_, HLTPrescaleProvider::l1GtUtils(), l1PSet_, L1GtUtils::l1Results(), edm::InputTag::label(), labelHltPrescaleTable_, trigger::HLTPrescaleTable::labels(), LogDebug, mainBxOnly_, trigger::TriggerObject::mass(), SiStripPI::max, moduleLabelToPathAndFlags_, eostools::move(), Mu, dqmiodumpmetadata::n, pat::TriggerAlgorithm::name(), nameProcess_, names, L1GlobalTriggerObjectMaps::namesParameterSetID(), L1GlobalTriggerObjectMaps::CombinationsInCondition::nCombinations(), L1GlobalTriggerObjectMaps::CombinationsInCondition::nObjectsPerCombination(), NoIsoEG, L1GlobalTriggerReadoutSetup::NumberPhysTriggers, L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers, getGTfromDQMFile::obj, L1MuTriggerScaleKeysOnlineProd_cfi::objectTypes, onlyStandAlone_, AlCaHLTBitMon_ParallelJobs::p, packLabels_, packPathNames_, packPrescales_, patCandidatesForDimuonsSequences_cff::pathNames, Skims_PA_cff::paths, trigger::TriggerObject::phi(), HLTPrescaleProvider::prescaleSet(), HLTPrescaleProvider::prescaleValuesInDetail(), trigger::TriggerObject::pt(), saveL1Refs_, trigger::HLTPrescaleTable::set(), pat::TriggerCondition::setCategory(), pat::TriggerObject::setCollection(), pat::TriggerAlgorithm::setGtlResult(), pat::TriggerAlgorithm::setLogicalExpression(), trigger::TriggerEvent::sizeCollections(), trigger::TriggerEvent::sizeFilters(), trigger::TriggerEvent::sizeObjects(), AlCaHLTBitMon_QueryRunRegistry::string, trigger::HLTPrescaleTable::table(), tagL1ExtraCenJet_, tagL1ExtraETM_, tagL1ExtraForJet_, tagL1ExtraHTM_, tagL1ExtraIsoEG_, tagL1ExtraMu_, tagL1ExtraNoIsoEG_, tagL1ExtraTauJet_, tagL1GlobalTriggerObjectMaps_, tagTriggerEvent_, tagTriggerResults_, TauJet, L1GtUtils::TechnicalTrigger, PDWG_DiJetAODSkim_cff::triggerConditions, hotlineDQM_cfi::triggerFilter, trigger::TriggerL1CenJet, trigger::TriggerL1ETM, trigger::TriggerL1ForJet, trigger::TriggerL1HTM, trigger::TriggerL1IsoEG, trigger::TriggerL1Mu, trigger::TriggerL1NoIsoEG, trigger::TriggerL1TauJet, triggerMatchMonitor_cfi::triggerObjects, eventshapeDQM_cfi::triggerPath, triggerPaths, and edm::HLTGlobalStatus::wasrun().

Member Data Documentation

◆ addL1Algos_

bool pat::PATTriggerProducer::addL1Algos_
private

Definition at line 72 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer(), and produce().

◆ addPathModuleLabels_

bool pat::PATTriggerProducer::addPathModuleLabels_
private

Definition at line 115 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer(), and produce().

◆ autoProcessName_

bool pat::PATTriggerProducer::autoProcessName_
private

Definition at line 67 of file PATTriggerProducer.h.

Referenced by beginRun(), and PATTriggerProducer().

◆ autoProcessNameL1ExtraCenJet_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraCenJet_
private

Definition at line 94 of file PATTriggerProducer.h.

Referenced by beginRun(), and PATTriggerProducer().

◆ autoProcessNameL1ExtraETM_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraETM_
private

Definition at line 97 of file PATTriggerProducer.h.

Referenced by beginRun(), and PATTriggerProducer().

◆ autoProcessNameL1ExtraForJet_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraForJet_
private

Definition at line 95 of file PATTriggerProducer.h.

Referenced by beginRun(), and PATTriggerProducer().

◆ autoProcessNameL1ExtraHTM_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraHTM_
private

Definition at line 98 of file PATTriggerProducer.h.

Referenced by beginRun(), and PATTriggerProducer().

◆ autoProcessNameL1ExtraIsoEG_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraIsoEG_
private

Definition at line 93 of file PATTriggerProducer.h.

Referenced by beginRun(), and PATTriggerProducer().

◆ autoProcessNameL1ExtraMu_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraMu_
private

Definition at line 91 of file PATTriggerProducer.h.

Referenced by beginRun(), and PATTriggerProducer().

◆ autoProcessNameL1ExtraNoIsoEG_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraNoIsoEG_
private

Definition at line 92 of file PATTriggerProducer.h.

Referenced by beginRun(), and PATTriggerProducer().

◆ autoProcessNameL1ExtraTauJet_

bool pat::PATTriggerProducer::autoProcessNameL1ExtraTauJet_
private

Definition at line 96 of file PATTriggerProducer.h.

Referenced by beginRun(), and PATTriggerProducer().

◆ exludeCollections_

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

Definition at line 116 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer(), and produce().

◆ firstInRun_

bool pat::PATTriggerProducer::firstInRun_
private

Definition at line 69 of file PATTriggerProducer.h.

Referenced by beginRun(), and produce().

◆ hltConfigInit_

bool pat::PATTriggerProducer::hltConfigInit_
private

Definition at line 103 of file PATTriggerProducer.h.

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

◆ hltPrescaleLabel_

std::string pat::PATTriggerProducer::hltPrescaleLabel_
private

Definition at line 108 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer(), and produce().

◆ hltPrescaleProvider_

HLTPrescaleProvider pat::PATTriggerProducer::hltPrescaleProvider_
private

Definition at line 102 of file PATTriggerProducer.h.

Referenced by beginRun(), and produce().

◆ hltPrescaleTableEventGetter_

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

Definition at line 112 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ hltPrescaleTableLumi_

trigger::HLTPrescaleTable pat::PATTriggerProducer::hltPrescaleTableLumi_
private

Definition at line 114 of file PATTriggerProducer.h.

Referenced by beginLuminosityBlock(), and produce().

◆ hltPrescaleTableLumiGetter_

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

Definition at line 111 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ hltPrescaleTableRun_

trigger::HLTPrescaleTable pat::PATTriggerProducer::hltPrescaleTableRun_
private

Definition at line 113 of file PATTriggerProducer.h.

Referenced by beginLuminosityBlock(), and beginRun().

◆ hltPrescaleTableRunGetter_

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

Definition at line 110 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ l1ExtraCenJetGetter_

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

Definition at line 82 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ l1ExtraETMGetter_

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

Definition at line 88 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ l1ExtraForJetGetter_

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

Definition at line 84 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ l1ExtraHTMGetter_

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

Definition at line 90 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ l1ExtraIsoEGGetter_

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

Definition at line 80 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ l1ExtraMuGetter_

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

Definition at line 76 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ l1ExtraNoIsoEGGetter_

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

Definition at line 78 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ l1ExtraTauJetGetter_

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

Definition at line 86 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ l1GlobalTriggerObjectMapsToken_

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

Definition at line 74 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer(), and produce().

◆ l1PSet_

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

Definition at line 71 of file PATTriggerProducer.h.

Referenced by beginRun(), and produce().

◆ labelHltPrescaleTable_

std::string pat::PATTriggerProducer::labelHltPrescaleTable_
private

Definition at line 109 of file PATTriggerProducer.h.

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

◆ mainBxOnly_

bool pat::PATTriggerProducer::mainBxOnly_
private

Definition at line 99 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer(), and produce().

◆ moduleLabelToPathAndFlags_

ModuleLabelToPathAndFlags pat::PATTriggerProducer::moduleLabelToPathAndFlags_
private

Definition at line 147 of file PATTriggerProducer.h.

Referenced by beginRun(), and produce().

◆ nameProcess_

std::string pat::PATTriggerProducer::nameProcess_
private

Definition at line 66 of file PATTriggerProducer.h.

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

◆ onlyStandAlone_

bool pat::PATTriggerProducer::onlyStandAlone_
private

Definition at line 68 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer(), and produce().

◆ packLabels_

bool pat::PATTriggerProducer::packLabels_
private

Definition at line 118 of file PATTriggerProducer.h.

Referenced by produce().

◆ packPathNames_

bool pat::PATTriggerProducer::packPathNames_
private

Definition at line 117 of file PATTriggerProducer.h.

Referenced by produce().

◆ packPrescales_

bool pat::PATTriggerProducer::packPrescales_
private

Definition at line 119 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer(), and produce().

◆ saveL1Refs_

bool pat::PATTriggerProducer::saveL1Refs_
private

Definition at line 100 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer(), and produce().

◆ tagL1ExtraCenJet_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraCenJet_
private

Definition at line 81 of file PATTriggerProducer.h.

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

◆ tagL1ExtraETM_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraETM_
private

Definition at line 87 of file PATTriggerProducer.h.

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

◆ tagL1ExtraForJet_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraForJet_
private

Definition at line 83 of file PATTriggerProducer.h.

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

◆ tagL1ExtraHTM_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraHTM_
private

Definition at line 89 of file PATTriggerProducer.h.

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

◆ tagL1ExtraIsoEG_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraIsoEG_
private

Definition at line 79 of file PATTriggerProducer.h.

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

◆ tagL1ExtraMu_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraMu_
private

Definition at line 75 of file PATTriggerProducer.h.

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

◆ tagL1ExtraNoIsoEG_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraNoIsoEG_
private

Definition at line 77 of file PATTriggerProducer.h.

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

◆ tagL1ExtraTauJet_

edm::InputTag pat::PATTriggerProducer::tagL1ExtraTauJet_
private

Definition at line 85 of file PATTriggerProducer.h.

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

◆ tagL1GlobalTriggerObjectMaps_

edm::InputTag pat::PATTriggerProducer::tagL1GlobalTriggerObjectMaps_
private

Definition at line 73 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer(), and produce().

◆ tagTriggerEvent_

edm::InputTag pat::PATTriggerProducer::tagTriggerEvent_
private

Definition at line 106 of file PATTriggerProducer.h.

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

◆ tagTriggerResults_

edm::InputTag pat::PATTriggerProducer::tagTriggerResults_
private

Definition at line 104 of file PATTriggerProducer.h.

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

◆ triggerEventGetter_

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

Definition at line 107 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

◆ triggerResultsGetter_

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

Definition at line 105 of file PATTriggerProducer.h.

Referenced by PATTriggerProducer().

trigger::TriggerObject::phi
float phi() const
Definition: TriggerObject.h:54
TriggerObject
Definition: TriggerObject.py:1
taus_updatedMVAIds_cff.category
category
Definition: taus_updatedMVAIds_cff.py:31
trigger::TriggerEvent::sizeFilters
trigger::size_type sizeFilters() const
Definition: TriggerEvent.h:146
L1GlobalTriggerObjectMaps::getCombinationsInCondition
CombinationsInCondition getCombinationsInCondition(int algorithmBitNumber, unsigned conditionNumber) const
Definition: L1GlobalTriggerObjectMaps.cc:94
trigger::HLTPrescaleTable
The single EDProduct containing the HLT Prescale Table.
Definition: HLTPrescaleTable.h:20
HTM
Definition: L1GtObject.h:38
electrons_cff.bool
bool
Definition: electrons_cff.py:393
trigger::TriggerL1HTM
Definition: TriggerTypeDefs.h:39
mps_fire.i
i
Definition: mps_fire.py:428
pat::PATTriggerProducer::addL1Algos_
bool addL1Algos_
Definition: PATTriggerProducer.h:72
pat::PATTriggerProducer::tagL1ExtraNoIsoEG_
edm::InputTag tagL1ExtraNoIsoEG_
Definition: PATTriggerProducer.h:77
trigger::TriggerEvent::filterKeys
const Keys & filterKeys(trigger::size_type index) const
Definition: TriggerEvent.h:118
pat::PATTriggerProducer::tagL1ExtraCenJet_
edm::InputTag tagL1ExtraCenJet_
Definition: PATTriggerProducer.h:81
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
pat::PATTriggerProducer::packLabels_
bool packLabels_
Definition: PATTriggerProducer.h:118
L1GlobalTriggerObjectMaps::namesParameterSetID
edm::ParameterSetID const & namesParameterSetID() const
Definition: L1GlobalTriggerObjectMaps.h:64
trigger::TriggerL1IsoEG
Definition: TriggerTypeDefs.h:32
triggerMatchMonitor_cfi.triggerObjects
triggerObjects
Definition: triggerMatchMonitor_cfi.py:15
trigger::TriggerEvent::collectionKeys
const Keys & collectionKeys() const
Definition: TriggerEvent.h:100
trigger::Vids
std::vector< int > Vids
Definition: TriggerTypeDefs.h:21
edm::InputTag::instance
std::string const & instance() const
Definition: InputTag.h:37
trigger::TriggerEvent::collectionTagEncoded
const std::string & collectionTagEncoded(trigger::size_type index) const
Definition: TriggerEvent.h:106
pat::PATTriggerProducer::exludeCollections_
std::vector< std::string > exludeCollections_
Definition: PATTriggerProducer.h:116
ETM
Definition: L1GtObject.h:35
trigger::TriggerL1ForJet
Definition: TriggerTypeDefs.h:34
pat::PATTriggerProducer::packPrescales_
bool packPrescales_
Definition: PATTriggerProducer.h:119
pat::TriggerObjectStandAlone
Analysis-level trigger object class (stand-alone)
Definition: TriggerObjectStandAlone.h:32
HLTPrescaleProvider::hltConfigProvider
HLTConfigProvider const & hltConfigProvider() const
Definition: HLTPrescaleProvider.h:52
pat::PATTriggerProducer::l1ExtraHTMGetter_
edm::GetterOfProducts< l1extra::L1EtMissParticleCollection > l1ExtraHTMGetter_
Definition: PATTriggerProducer.h:90
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
pat::PATTriggerProducer::hltConfigInit_
bool hltConfigInit_
Definition: PATTriggerProducer.h:103
deep_tau::DeepTauBase::BasicDiscriminator
BasicDiscriminator
Definition: DeepTauBase.h:115
HLTPrescaleProvider::prescaleSet
int prescaleSet(const edm::Event &iEvent, const edm::EventSetup &iSetup)
Definition: HLTPrescaleProvider.cc:60
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89353
edm::HLTGlobalStatus::wasrun
bool wasrun() const
Was at least one path run?
Definition: HLTGlobalStatus.h:47
cms::cuda::assert
assert(be >=bs)
pat::PATTriggerProducer::nameProcess_
std::string nameProcess_
Definition: PATTriggerProducer.h:66
HIPAlignmentAlgorithm_cfi.algoName
algoName
Definition: HIPAlignmentAlgorithm_cfi.py:5
pat::PATTriggerProducer::autoProcessNameL1ExtraCenJet_
bool autoProcessNameL1ExtraCenJet_
Definition: PATTriggerProducer.h:94
edm::InputTag::process
std::string const & process() const
Definition: InputTag.h:40
trigger::HLTPrescaleTable::set
unsigned int set() const
low-level const accessors for data members
Definition: HLTPrescaleTable.h:73
pat::PATTriggerProducer::autoProcessName_
bool autoProcessName_
Definition: PATTriggerProducer.h:67
edm::HLTGlobalStatus::error
bool error() const
Has any path encountered an error (exception)
Definition: HLTGlobalStatus.h:51
NoIsoEG
Definition: L1GtObject.h:30
relativeConstraints.keys
keys
Definition: relativeConstraints.py:89
eventshapeDQM_cfi.triggerPath
triggerPath
Definition: eventshapeDQM_cfi.py:7
edm::ParameterSet::existsAs
bool existsAs(std::string const &parameterName, bool trackiness=true) const
checks if a parameter exists as a given type
Definition: ParameterSet.h:171
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
pat::PATTriggerProducer::l1ExtraIsoEGGetter_
edm::GetterOfProducts< l1extra::L1EmParticleCollection > l1ExtraIsoEGGetter_
Definition: PATTriggerProducer.h:80
IsoEG
Definition: L1GtObject.h:31
edm::Handle< trigger::HLTPrescaleTable >
relativeConstraints.error
error
Definition: relativeConstraints.py:53
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
edm::InRun
Definition: BranchType.h:11
pat::PATTriggerProducer::labelHltPrescaleTable_
std::string labelHltPrescaleTable_
Definition: PATTriggerProducer.h:109
pat::PATTriggerProducer::hltPrescaleTableRunGetter_
edm::GetterOfProducts< trigger::HLTPrescaleTable > hltPrescaleTableRunGetter_
Definition: PATTriggerProducer.h:110
L1GlobalTriggerObjectMaps::consistencyCheck
void consistencyCheck() const
Definition: L1GlobalTriggerObjectMaps.cc:138
pat::PATTriggerProducer::l1PSet_
edm::ParameterSet * l1PSet_
Definition: PATTriggerProducer.h:71
pat::TriggerCondition
Analysis-level L1 trigger condition class.
Definition: TriggerCondition.h:34
edm::Ref< L1MuonParticleCollection >
edm::HLTGlobalStatus::index
unsigned int index(const unsigned int i) const
Get index (slot position) of module giving the decision of the ith path.
Definition: HLTGlobalStatus.h:70
L1GtUtils::TechnicalTrigger
Definition: L1GtUtils.h:140
config
Definition: config.py:1
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
L1GlobalTriggerObjectMaps::algorithmExists
bool algorithmExists(int algorithmBitNumber) const
Returns true if there is an entry for this algorithm bit number.
Definition: L1GlobalTriggerObjectMaps.cc:30
trigger::TriggerObject::pt
float pt() const
Definition: TriggerObject.h:52
HLTPrescaleProvider::l1GtUtils
L1GtUtils const & l1GtUtils() const
Definition: HLTPrescaleProvider.cc:50
pat::TriggerAlgorithm
Analysis-level L1 trigger algorithm class.
Definition: TriggerAlgorithm.h:31
L1GlobalTriggerObjectMaps::ConditionsInAlgorithm
Definition: L1GlobalTriggerObjectMaps.h:120
pat::PATTriggerProducer::hltPrescaleTableLumi_
trigger::HLTPrescaleTable hltPrescaleTableLumi_
Definition: PATTriggerProducer.h:114
trigger::size_type
uint16_t size_type
Definition: TriggerTypeDefs.h:18
trigger::TriggerEvent::filterLabel
std::string filterLabel(trigger::size_type index) const
Definition: TriggerEvent.h:112
pat::PATTriggerProducer::autoProcessNameL1ExtraETM_
bool autoProcessNameL1ExtraETM_
Definition: PATTriggerProducer.h:97
edm::EventSetup::get
T get() const
Definition: EventSetup.h:80
trigger::TriggerEvent::filterTag
const edm::InputTag filterTag(trigger::size_type index) const
Definition: TriggerEvent.h:108
CItAlgo
AlgorithmMap::const_iterator CItAlgo
iterators through map containing the algorithms
Definition: L1GtTriggerMenuFwd.h:38
names
const std::string names[nVars_]
Definition: PhotonIDValueMapProducer.cc:124
submitPVResolutionJobs.config
config
parse the configuration file
Definition: submitPVResolutionJobs.py:281
L1GtUtils::TriggerCategory
TriggerCategory
Definition: L1GtUtils.h:140
hotlineDQM_cfi.triggerFilter
triggerFilter
Definition: hotlineDQM_cfi.py:15
ConditionMap
std::map< std::string, L1GtCondition * > ConditionMap
map containing the conditions
Definition: L1GtTriggerMenuFwd.h:28
L1GtTriggerMenuRcd
Definition: L1GtTriggerMenuRcd.h:32
pat::PATTriggerProducer::l1ExtraForJetGetter_
edm::GetterOfProducts< l1extra::L1JetParticleCollection > l1ExtraForJetGetter_
Definition: PATTriggerProducer.h:84
L1GlobalTriggerReadoutSetup::NumberPhysTriggers
static const unsigned int NumberPhysTriggers
Definition: L1GlobalTriggerReadoutSetup.h:36
edm::ESHandle
Definition: DTSurvey.h:22
CenJet
Definition: L1GtObject.h:32
pat::PATTriggerProducer::autoProcessNameL1ExtraTauJet_
bool autoProcessNameL1ExtraTauJet_
Definition: PATTriggerProducer.h:96
L1GtUtils
Definition: L1GtUtils.h:66
pat::PATTriggerProducer::triggerEventGetter_
edm::GetterOfProducts< trigger::TriggerEvent > triggerEventGetter_
Definition: PATTriggerProducer.h:107
reco::Particle::PolarLorentzVector
math::PtEtaPhiMLorentzVector PolarLorentzVector
Lorentz vector.
Definition: Particle.h:23
pat::PATTriggerProducer::ModuleLabelToPathAndFlags::init
void init(const HLTConfigProvider &)
Definition: PATTriggerProducer.cc:1193
pat::PATTriggerProducer::hltPrescaleProvider_
HLTPrescaleProvider hltPrescaleProvider_
Definition: PATTriggerProducer.h:102
trigger::TriggerObject
Single trigger physics object (e.g., an isolated muon)
Definition: TriggerObject.h:21
getGTfromDQMFile.obj
obj
Definition: getGTfromDQMFile.py:32
pat::PATTriggerProducer::mainBxOnly_
bool mainBxOnly_
Definition: PATTriggerProducer.h:99
pat::PATTriggerProducer::tagL1ExtraTauJet_
edm::InputTag tagL1ExtraTauJet_
Definition: PATTriggerProducer.h:85
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HLTPrescaleProvider::prescaleValuesInDetail
std::pair< std::vector< std::pair< std::string, TL1 > >, THLT > prescaleValuesInDetail(const edm::Event &iEvent, const edm::EventSetup &iSetup, const std::string &trigger)
Definition: HLTPrescaleProvider.h:82
L1GlobalTriggerObjectMaps::CombinationsInCondition
Definition: L1GlobalTriggerObjectMaps.h:131
pat::PATTriggerProducer::tagL1GlobalTriggerObjectMaps_
edm::InputTag tagL1GlobalTriggerObjectMaps_
Definition: PATTriggerProducer.h:73
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:681
pat::L1SeedCollection
std::vector< L1Seed > L1SeedCollection
Collection of L1Seed.
Definition: TriggerPath.h:34
pat::PATTriggerProducer::tagL1ExtraMu_
edm::InputTag tagL1ExtraMu_
Definition: PATTriggerProducer.h:75
trigger::TriggerEvent::sizeCollections
trigger::size_type sizeCollections() const
other
Definition: TriggerEvent.h:144
pat::PATTriggerProducer::hltPrescaleTableRun_
trigger::HLTPrescaleTable hltPrescaleTableRun_
Definition: PATTriggerProducer.h:113
TauJet
Definition: L1GtObject.h:34
pat::PATTriggerProducer::moduleLabelToPathAndFlags_
ModuleLabelToPathAndFlags moduleLabelToPathAndFlags_
Definition: PATTriggerProducer.h:147
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:223
L1GlobalTriggerObjectMaps::CombinationsInCondition::nCombinations
unsigned nCombinations() const
Definition: L1GlobalTriggerObjectMaps.h:137
pat::PATTriggerProducer::firstInRun_
bool firstInRun_
Definition: PATTriggerProducer.h:69
edm::ParameterSet
Definition: ParameterSet.h:47
pat::PATTriggerProducer::tagL1ExtraIsoEG_
edm::InputTag tagL1ExtraIsoEG_
Definition: PATTriggerProducer.h:79
edm::ProcessHistory::const_iterator
collection_type::const_iterator const_iterator
Definition: ProcessHistory.h:19
edm::InLumi
Definition: BranchType.h:11
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
pat::PATTriggerProducer::tagL1ExtraForJet_
edm::InputTag tagL1ExtraForJet_
Definition: PATTriggerProducer.h:83
pat::PATTriggerProducer::autoProcessNameL1ExtraNoIsoEG_
bool autoProcessNameL1ExtraNoIsoEG_
Definition: PATTriggerProducer.h:92
L1GlobalTriggerObjectMaps::CombinationsInCondition::nObjectsPerCombination
unsigned short nObjectsPerCombination() const
Definition: L1GlobalTriggerObjectMaps.h:138
trigger::TriggerL1Mu
enum start value shifted to 81 so as to avoid clashes with PDG codes
Definition: TriggerTypeDefs.h:30
pat::TriggerPath
Analysis-level HLTrigger path class.
Definition: TriggerPath.h:36
trigger::TriggerObject::id
int id() const
getters
Definition: TriggerObject.h:51
trigger::HLTPrescaleTable::table
const std::map< std::string, std::vector< unsigned int > > & table() const
Definition: HLTPrescaleTable.h:75
L1GtUtils::l1Results
const int l1Results(const edm::Event &iEvent, const std::string &nameAlgoTechTrig, bool &decisionBeforeMask, bool &decisionAfterMask, int &prescaleFactor, int &triggerMask) const
Definition: L1GtUtils.cc:666
pat::PATTriggerProducer::autoProcessNameL1ExtraIsoEG_
bool autoProcessNameL1ExtraIsoEG_
Definition: PATTriggerProducer.h:93
createfilelist.int
int
Definition: createfilelist.py:10
pat::PATTriggerProducer::hltPrescaleTableLumiGetter_
edm::GetterOfProducts< trigger::HLTPrescaleTable > hltPrescaleTableLumiGetter_
Definition: PATTriggerProducer.h:111
iEvent
int iEvent
Definition: GenABIO.cc:224
L1GlobalTriggerObjectMaps::algorithmResult
bool algorithmResult(int algorithmBitNumber) const
Returns whether an algorithm trigger passed or failed.
Definition: L1GlobalTriggerObjectMaps.cc:39
trigger::TriggerEvent::filterIndex
trigger::size_type filterIndex(const edm::InputTag &filterTag) const
find index of filter in data-member vector from filter tag
Definition: TriggerEvent.h:132
edm::GetterOfProducts< l1extra::L1MuonParticleCollection >
pat::TriggerObject::addTriggerObjectType
void addTriggerObjectType(trigger::TriggerObjectType triggerObjectType)
Add a new trigger object type identifier.
Definition: TriggerObject.h:82
pat::PATTriggerProducer::autoProcessNameL1ExtraMu_
bool autoProcessNameL1ExtraMu_
Definition: PATTriggerProducer.h:91
trigger::Keys
std::vector< size_type > Keys
Definition: TriggerTypeDefs.h:19
pat::PATTriggerProducer::tagTriggerEvent_
edm::InputTag tagTriggerEvent_
Definition: PATTriggerProducer.h:106
trigger::TriggerObject::eta
float eta() const
Definition: TriggerObject.h:53
pat::PATTriggerProducer::l1ExtraETMGetter_
edm::GetterOfProducts< l1extra::L1EtMissParticleCollection > l1ExtraETMGetter_
Definition: PATTriggerProducer.h:88
edm::InputTag::encode
std::string encode() const
Definition: InputTag.cc:159
triggerPaths
static const std::string triggerPaths
Definition: EdmProvDump.cc:46
L1GtUtils::l1AlgoTechTrigBitNumber
const bool l1AlgoTechTrigBitNumber(const std::string &nameAlgoTechTrig, TriggerCategory &trigCategory, int &bitNumber) const
Definition: L1GtUtils.cc:371
pat::PATTriggerProducer::triggerResultsGetter_
edm::GetterOfProducts< edm::TriggerResults > triggerResultsGetter_
Definition: PATTriggerProducer.h:105
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
get
#define get
prescale
Definition: PrescaleEventFilter.cc:32
edm::InputTagMatch
Definition: InputTagMatch.h:20
trigger::TriggerEvent::getObjects
const TriggerObjectCollection & getObjects() const
Definition: TriggerEvent.h:101
trigger::TriggerEvent::sizeObjects
trigger::size_type sizeObjects() const
Definition: TriggerEvent.h:145
HLTPrescaleProvider::init
bool init(const edm::Run &iRun, const edm::EventSetup &iSetup, const std::string &processName, bool &changed)
Definition: HLTPrescaleProvider.cc:21
pat::PATTriggerProducer::addPathModuleLabels_
bool addPathModuleLabels_
Definition: PATTriggerProducer.h:115
trigger::TriggerEvent::filterIds
const Vids & filterIds(trigger::size_type index) const
Definition: TriggerEvent.h:117
instance
static PFTauRenderPlugin instance
Definition: PFTauRenderPlugin.cc:70
pat::PATTriggerProducer::onlyStandAlone_
bool onlyStandAlone_
Definition: PATTriggerProducer.h:68
L1GlobalTriggerObjectMaps::getConditionsInAlgorithm
ConditionsInAlgorithm getConditionsInAlgorithm(int algorithmBitNumber) const
Definition: L1GlobalTriggerObjectMaps.cc:86
L1GtTriggerMenu::gtConditionMap
const std::vector< ConditionMap > & gtConditionMap() const
get / set / build the condition maps
Definition: L1GtTriggerMenu.h:80
pat::PATTriggerProducer::hltPrescaleTableEventGetter_
edm::GetterOfProducts< trigger::HLTPrescaleTable > hltPrescaleTableEventGetter_
Definition: PATTriggerProducer.h:112
types
types
Definition: AlignPCLThresholds_PayloadInspector.cc:30
L1GtUtils::AlgorithmTrigger
Definition: L1GtUtils.h:140
L1GlobalTriggerObjectMaps::CombinationsInCondition::getObjectIndex
unsigned char getObjectIndex(unsigned combination, unsigned object) const
Definition: L1GlobalTriggerObjectMaps.cc:268
Mu
Definition: L1GtObject.h:29
patCandidatesForDimuonsSequences_cff.pathNames
pathNames
Definition: patCandidatesForDimuonsSequences_cff.py:109
pat::PATTriggerProducer::l1ExtraMuGetter_
edm::GetterOfProducts< l1extra::L1MuonParticleCollection > l1ExtraMuGetter_
Definition: PATTriggerProducer.h:76
HLTConfigProvider
Definition: HLTConfigProvider.h:29
submitPVValidationJobs.conditions
list conditions
Definition: submitPVValidationJobs.py:674
eostools.move
def move(src, dest)
Definition: eostools.py:511
trigger::TriggerL1NoIsoEG
Definition: TriggerTypeDefs.h:31
trigger::TriggerL1TauJet
Definition: TriggerTypeDefs.h:35
pat::PATTriggerProducer::l1ExtraTauJetGetter_
edm::GetterOfProducts< l1extra::L1JetParticleCollection > l1ExtraTauJetGetter_
Definition: PATTriggerProducer.h:86
edm::TriggerNames
Definition: TriggerNames.h:55
pat::PATTriggerProducer::l1GlobalTriggerObjectMapsToken_
edm::EDGetTokenT< L1GlobalTriggerObjectMaps > l1GlobalTriggerObjectMapsToken_
Definition: PATTriggerProducer.h:74
pat::PATTriggerProducer::l1ExtraCenJetGetter_
edm::GetterOfProducts< l1extra::L1JetParticleCollection > l1ExtraCenJetGetter_
Definition: PATTriggerProducer.h:82
pat::TriggerCondition::setCategory
void setCategory(L1GtConditionCategory category)
Set the condition category.
Definition: TriggerCondition.h:73
trigger::TriggerL1ETM
Definition: TriggerTypeDefs.h:36
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
edm::RefToBase< Candidate >
HltComparatorCreateWorkflow.hltConfig
hltConfig
Definition: HltComparatorCreateWorkflow.py:161
ForJet
Definition: L1GtObject.h:33
Skims_PA_cff.paths
paths
Definition: Skims_PA_cff.py:18
pat::PATTriggerProducer::autoProcessNameL1ExtraForJet_
bool autoProcessNameL1ExtraForJet_
Definition: PATTriggerProducer.h:95
edm::HLTGlobalStatus::accept
bool accept() const
Has at least one path accepted the event?
Definition: HLTGlobalStatus.h:49
patCandidatesForDimuonsSequences_cff.filterLabels
filterLabels
Definition: patCandidatesForDimuonsSequences_cff.py:108
pat::PATTriggerProducer::tagTriggerResults_
edm::InputTag tagTriggerResults_
Definition: PATTriggerProducer.h:104
pat::PATTriggerProducer::saveL1Refs_
bool saveL1Refs_
Definition: PATTriggerProducer.h:100
L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers
static const unsigned int NumberTechnicalTriggers
Definition: L1GlobalTriggerReadoutSetup.h:38
trigger::HLTPrescaleTable::labels
const std::vector< std::string > & labels() const
Definition: HLTPrescaleTable.h:74
edm::BranchDescription
Definition: BranchDescription.h:32
pat::PATTriggerProducer::tagL1ExtraHTM_
edm::InputTag tagL1ExtraHTM_
Definition: PATTriggerProducer.h:89
reco::LeafCandidate
Definition: LeafCandidate.h:16
edm::Run::getByLabel
bool getByLabel(std::string const &label, Handle< PROD > &result) const
Definition: Run.h:281
edm::ProcessHistory
Definition: ProcessHistory.h:13
trigger::TriggerL1CenJet
Definition: TriggerTypeDefs.h:33
PDWG_DiJetAODSkim_cff.triggerConditions
triggerConditions
Definition: PDWG_DiJetAODSkim_cff.py:6
L1MuTriggerScaleKeysOnlineProd_cfi.objectTypes
objectTypes
Definition: L1MuTriggerScaleKeysOnlineProd_cfi.py:11
pat::PATTriggerProducer::l1ExtraNoIsoEGGetter_
edm::GetterOfProducts< l1extra::L1EmParticleCollection > l1ExtraNoIsoEGGetter_
Definition: PATTriggerProducer.h:78
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
crabWrapper.key
key
Definition: crabWrapper.py:19
L1GtTriggerMenu::gtTechnicalTriggerMap
const AlgorithmMap & gtTechnicalTriggerMap() const
get / set the technical trigger map
Definition: L1GtTriggerMenu.h:197
pat::TriggerFilter
Analysis-level HLTrigger filter class.
Definition: TriggerFilter.h:33
pat::TriggerObject::setCollection
void setCollection(const std::string &collName)
Methods.
Definition: TriggerObject.h:79
pat::PATTriggerProducer::tagL1ExtraETM_
edm::InputTag tagL1ExtraETM_
Definition: PATTriggerProducer.h:87
edm::LuminosityBlock::getByLabel
bool getByLabel(std::string const &label, Handle< PROD > &result) const
Definition: LuminosityBlock.h:282
trigger::TriggerObject::mass
float mass() const
Definition: TriggerObject.h:55
edm::InputTag
Definition: InputTag.h:15
pat::PATTriggerProducer::hltPrescaleLabel_
std::string hltPrescaleLabel_
Definition: PATTriggerProducer.h:108
pat::PATTriggerProducer::autoProcessNameL1ExtraHTM_
bool autoProcessNameL1ExtraHTM_
Definition: PATTriggerProducer.h:98
edm::ProcessConfiguration
Definition: ProcessConfiguration.h:14
L1GtTriggerMenu::gtAlgorithmMap
const AlgorithmMap & gtAlgorithmMap() const
get / set the algorithm map (by name)
Definition: L1GtTriggerMenu.h:187
pat::PATTriggerProducer::packPathNames_
bool packPathNames_
Definition: PATTriggerProducer.h:117
edm::Run::processHistory
ProcessHistory const & processHistory() const
Definition: Run.cc:110
Generated for CMSSW Reference Manual by doxygen 1.8.16